Various bug fixes and improvements. -jar works now.

Also change how we pass the boot script to Node, should fix #3

Author: Mike Hearn

dat-sample/build.gradle.kts

@@ -4,6 +4,7 @@ plugins {
     java
     kotlin("jvm")
     application
+    id("com.github.johnrengelman.shadow") version("5.1.0")
 }
 
 group = "net.plan99.nodejs"

dat-sample/src/main/kotlin/net/plan99/nodejs/sample/DatExplorer.kt

@@ -39,5 +39,5 @@ fun main() {
          """)
     }
 
-    Thread.sleep(5000)
+    Thread.sleep(25000)
 }

docsite/docs/running-polyglot-programs.md

@@ -8,9 +8,26 @@ Start your Java programs as normal but run `nodejvm` instead of `java`, e.g.
 
 `nodejvm -cp "libs/*.jar" my.main.Class arg1 arg2`
 
+## Running the samples
+
+Check out the NodeJVM repository. Then try:
+
+```
+gradle dat-sample:run
+```
+
+It should join the DAT network and might print some peer infos, depending on your luck.
+
+Also try something a bit less Gradley:
+
+```
+gradle build spinners-sample:shadowJar
+../build/nodejvm/nodejvm -jar build/libs/spinners-sample-*-all.jar
+```
+
 ## From Gradle
 
-This is currently a bit awkward. The easiest way is to adjust your JavaCompile tasks to run `nodejvm` instead of `java`:
+The easiest way is to adjust your JavaCompile tasks to run `nodejvm` instead of `java`:
 
 ```
 tasks.withType<JavaExec> {

spinners-sample/build.gradle.kts

@@ -4,6 +4,7 @@ plugins {
     java
     kotlin("jvm")
     application
+    id("com.github.johnrengelman.shadow") version("5.1.0")
 }
 
 group = "net.plan99.nodejs"

src/main/java/net/plan99/nodejs/java/NodeJS.java

@@ -7,14 +7,28 @@
 import org.intellij.lang.annotations.Language;
 import org.jetbrains.annotations.NotNull;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.net.JarURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.Arrays;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.LinkedBlockingDeque;
 import java.util.function.Supplier;
+import java.util.jar.JarInputStream;
 
 /**
  * Provides an interface to the NodeJS runtime for Java developers. You can only access the NodeJS world
@@ -44,27 +58,72 @@ private static class Linkage {
     // Called from the boot.js file as part of NodeJVM startup, do not call.
     @SuppressWarnings("unused")
     @Deprecated
-    public static void boot(String entryPointName,
-                            LinkedBlockingDeque<Runnable> taskQueue,
+    public static void boot(LinkedBlockingDeque<Runnable> taskQueue,
                             Value evalFunction,
-                            String[] args) {
+                            String[] args) throws ClassNotFoundException, IOException {
+        try {
+            boot1(taskQueue, evalFunction, args);
+        } catch (Throwable e) {
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+
+    private static void boot1(LinkedBlockingDeque<Runnable> taskQueue, Value evalFunction, String[] args) throws ClassNotFoundException, IOException {
         assert linkage == null : "Don't call this function directly. Already started!";
         assert evalFunction.canExecute();
         NodeJS.linkage = new Linkage(taskQueue, evalFunction);
         Thread.currentThread().setName("NodeJS main thread");
+
+        if (args.length == 0) {
+            System.err.println("You must specify at least a class name, or -jar jarname.jar");
+            System.exit(1);
+        } else if (!args[0].equals("-jar")) {
+            Class<?> entryPoint = Class.forName(args[0]);
+            startJavaThread(entryPoint, Arrays.copyOfRange(args, 1, args.length));
+        } else {
+            File myJar = new File(args[1]);
+            final URL url = myJar.toURI().toURL();
+            String mainClassName = "";
+            try (InputStream stream = Files.newInputStream(Paths.get(args[1]), StandardOpenOption.READ)) {
+                JarInputStream jis = new JarInputStream(stream);
+                mainClassName = jis.getManifest().getMainAttributes().getValue("Main-Class");
+            }
+
+            if (mainClassName == null) {
+                System.err.println("JAR file does not have a Main-Class attribute, is not executable.");
+                System.exit(1);
+            }
+            // Use the parent classloader to forcibly toss out this version of the interop JAR, to avoid confusion
+            // later when there are two classloaders in play, BUT, holepunch this specific class and inner classes
+            // through so the state linked up from the bootstrap script is still here. In other words, this class is
+            // special, so don't give it dependencies outside the JDK.
+            ClassLoader thisClassLoader = NodeJS.class.getClassLoader();
+            URLClassLoader child = new URLClassLoader(new URL[] {url}, thisClassLoader.getParent()) {
+                @Override
+                protected Class<?> findClass(String name) throws ClassNotFoundException {
+                    if (name.startsWith(NodeJS.class.getName())) {
+                        return thisClassLoader.loadClass(name);
+                    } else
+                        return super.findClass(name);
+                }
+            };
+            Class<?> entryPoint = Class.forName(mainClassName, true, child);
+            startJavaThread(entryPoint, Arrays.copyOfRange(args, 2, args.length));
+        }
+    }
+
+    private static void startJavaThread(Class<?> entryPoint, String[] args) {
         Thread javaThread = new Thread(() -> {
             try {
-                Class<?> entryPoint = Class.forName(entryPointName);
                 Method main = entryPoint.getMethod("main", String[].class);
                 assert Modifier.isStatic(main.getModifiers());
                 main.invoke(null, new Object[] { args });
                 System.exit(0);
             } catch (NoSuchMethodException e) {
-                System.err.println("No main method found in " + entryPointName);
+                System.err.println("No main method found in " + entryPoint.getName());
             } catch (InvocationTargetException e) {
                 e.getCause().printStackTrace();
-            } catch (ClassNotFoundException e) {
-                System.err.println(String.format("Main class with name '%s' not found.", entryPointName));
             } catch (Throwable e) {
                 e.printStackTrace();
             }

src/main/resources/boot.js

@@ -1,10 +1,3 @@
-const javaEntryPoint = process.argv[2];
-
-if (javaEntryPoint === undefined) {
-    console.error("You must provide the main class name as the first argument.");
-    process.exit(1);
-}
-
 // Set up a task queue that we'll proxy onto the NodeJS main thread.
 //
 // We have to do it this way because NodeJS/V8 are not thread safe,
@@ -37,11 +30,6 @@ worker.on('message', (callback) => {
     }
 });
 
-// We need this wrapper because GraalJS barfs if we try to call eval() directly from Java context, it assumes
+// We need this wrapper around eval because GraalJS barfs if we try to call eval() directly from Java context, it assumes
 // it will only ever be called from JS context.
-let evalWrapper = function(str)  {
-    return eval(str);
-};
-
-// Now pass control to the Java side.
-Java.type('net.plan99.nodejs.java.NodeJS').boot(javaEntryPoint, javaToJSQueue, evalWrapper, process.argv.slice(2));
+Java.type('net.plan99.nodejs.java.NodeJS').boot(javaToJSQueue, function(str)  { return eval(str); }, process.env['ARGS'].split(" "));

src/main/resources/nodejvm

@@ -39,44 +39,43 @@ fi
 # Mangle the command line arguments. We expect to receive a normal JVM command line
 # and want to convert it into a GraalJS node command line, which requires adding flags,
 # editing flag names, inserting options, etc.
-newargs=()
-i=0
-modifying=true
+export NODE_JVM_OPTIONS=""
 declare -a args
 args=( $@ )
 argCount=${#args[@]}
-while (( j < argCount )); do
-    arg="${args[j]}"
-    newarg="$arg"
+i=0
+while (( i < argCount )); do
+    arg="${args[i]}"
     case "$arg" in
-        --classpath|-cp|-classpath)
-           (( j++ ))
-           newargs[i]="--vm.cp=$interopJar:${args[j]}"
-           (( j++ ))
-           (( i++ ))
-           continue
-           ;;
-        --*) if $modifying; then newarg="--vm.${arg[@]:2}"; fi;;
-        -*) if $modifying; then newarg="--vm.${arg[@]:1}"; fi;;
-        *) if $modifying; then
-               modifying=false;
-               newarg="/dev/stdin $newarg";
-           fi;;
+        -cp|-classpath|--classpath)
+            NODE_JVM_CLASSPATH="${args[i+1]}"
+            (( i++ ))
+            ;;
+        --*|-*)
+            if [[ "$arg" == "-jar" ]]; then break; fi;
+            NODE_JVM_OPTIONS="$NODE_JVM_OPTIONS $arg"
+            ;;
+        *)
+           break;;
     esac
-    newargs[i]="$newarg"
     (( i++ ))
-    (( j++ ))
 done
+args=${args[@]:$i}
 
 # Make node look for modules in the executed-from directory in the same way
 # it would if run from the command line normally.
 export NODE_PATH=$PWD/node_modules
 
-# Now feed the boot.js script to the node binary. The quoted "EOF" here
+# Now feed the boot.js script to the node binary. The quoted 'EOF' here
 # doc string disables parsing and interpolation of the embedded script,
 # which is needed because backticks are meaningful to both JS and shell.
-cmd="$node --experimental-worker --jvm ${newargs[@]}"
-echo $cmd
-cat <<"EOF" | $cmd
+read -r -d '' BOOTJS <<'EOF'
 @bootjs@
 EOF
+
+export BOOTJS="$BOOTJS"
+export ARGS="$args"
+export NODE_JVM_CLASSPATH="$interopJar:$NODE_JVM_CLASSPATH"
+
+cmd="$node --experimental-worker --jvm -e eval(process.env['BOOTJS'])"
+exec $cmd