buildSrc/src/main/java/cc/squirreljme/plugin/multivm/VMFullSuiteTaskAction.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the GNU General Public License v3+, or later.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package cc.squirreljme.plugin.multivm;
  11
  12 import cc.squirreljme.plugin.multivm.ident.SourceTargetClassifier;
  13 import cc.squirreljme.plugin.util.GradleLoggerOutputStream;
  14 import cc.squirreljme.plugin.util.UnassistedLaunchEntry;
  15 import cc.squirreljme.plugin.util.GradleJavaExecSpecFiller;
  16 import java.io.IOException;
  17 import java.nio.file.Files;
  18 import java.nio.file.Path;
  19 import java.util.Arrays;
  20 import java.util.Collection;
  21 import java.util.LinkedHashMap;
  22 import java.util.LinkedHashSet;
  23 import java.util.stream.Stream;
  24 import org.gradle.api.Action;
  25 import org.gradle.api.Project;
  26 import org.gradle.api.Task;
  27 import org.gradle.api.logging.LogLevel;
  28 import org.gradle.api.tasks.SourceSet;
  29 import org.gradle.process.ExecResult;
  30
  31 /**
  32  * This is the action for running the full entire suite in the emulator.
  33  *
  34  * @since 2020/10/17
  35  */
  36 public class VMFullSuiteTaskAction
  37         implements Action<Task>
  38 {
  39         /** The additional libraries to load. */
  40         public static final String LIBRARIES_PROPERTY =
  41                 "full.libraries";
  42
  43         /** The source target classifier used. */
  44         protected final SourceTargetClassifier classifier;
  45
  46         /**
  47          * Initializes the task.
  48          *
  49          * @param __classifier The classifier used.
  50          * @throws NullPointerException On null arguments.
  51          * @since 2020/10/17
  52          */
  53         public VMFullSuiteTaskAction(SourceTargetClassifier __classifier)
  54                 throws NullPointerException
  55         {
  56                 if (__classifier == null)
  57                         throw new NullPointerException("NARG");
  58
  59                 this.classifier = __classifier;
  60         }
  61
  62         /**
  63          * {@inheritDoc}
  64          * @since 2020/10/17
  65          */
  66         @Override
  67         public void execute(Task __task)
  68         {
  69                 Project root = __task.getProject().getRootProject();
  70
  71                 // We need all the libraries to load and to be available
  72                 Collection<Path> libPath = VMHelpers.fullSuiteLibraries(__task);
  73
  74                 // Additional items onto the library set?
  75                 String exLib = System.getProperty(
  76                         VMFullSuiteTaskAction.LIBRARIES_PROPERTY);
  77                 if (exLib != null)
  78                         for (Path p : VMHelpers.classpathDecode(exLib))
  79                         {
  80                                 // Add contents of a given directory
  81                                 if (Files.isDirectory(p))
  82                                         try (Stream<Path> s = Files.list(p))
  83                                         {
  84                                                 libPath.addAll(Arrays.asList(s.toArray(Path[]::new)));
  85                                         }
  86                                         catch (IOException e)
  87                                         {
  88                                                 e.printStackTrace();
  89                                         }
  90
  91                                 // Add single path
  92                                 else
  93                                         libPath.add(p);
  94                         }
  95
  96                 // Determine the initial classpath of the launcher, which is always
  97                 // ran first
  98                 SourceTargetClassifier withMain = this.classifier
  99                         .withSourceSet(SourceSet.MAIN_SOURCE_SET_NAME);
 100                 Collection<Path> classPath = new LinkedHashSet<>();
 101                 classPath.addAll(Arrays
 102                         .asList(VMHelpers.runClassPath((VMExecutableTask)root.project(
 103                                 ":modules:launcher").getTasks().getByName(TaskInitialization
 104                                         .task("lib", withMain)),
 105                                 withMain)));
 106
 107                 // Debug these, just to ensure they work
 108                 __task.getLogger().debug("LibPath: {}", libPath);
 109                 __task.getLogger().debug("Classpath: {}", classPath);
 110
 111                 // Run the virtual machine with everything
 112                 ExecResult exitResult = __task.getProject().javaexec(__spec ->
 113                         {
 114                                 // Use filled JVM arguments
 115                                 this.classifier.getVmType().spawnJvmArguments(
 116                                         (VMBaseTask)__task,
 117                                         true,
 118                                         new GradleJavaExecSpecFiller(__spec),
 119                                         UnassistedLaunchEntry.MIDLET_MAIN_CLASS,
 120                                         "fullSuite",
 121                                         new LinkedHashMap<String, String>(),
 122                                         libPath.<Path>toArray(new Path[libPath.size()]),
 123                                         classPath.<Path>toArray(new Path[classPath.size()]),
 124                                         "cc.squirreljme.runtime.launcher.ui.MidletMain");
 125
 126                                 // Use these streams directly
 127                                 __spec.setStandardOutput(new GradleLoggerOutputStream(
 128                                         __task.getLogger(), LogLevel.LIFECYCLE, -1, -1));
 129                                 __spec.setErrorOutput(new GradleLoggerOutputStream(
 130                                         __task.getLogger(), LogLevel.ERROR, -1, -1));
 131                         });
 132
 133                 // Did the task fail?
 134                 int exitValue = exitResult.getExitValue();
 135                 if (exitValue != 0)
 136                         throw new RuntimeException("Task exited with: " + exitValue);
 137         }
 138 }