fix: refactor engine creation in JSPlugin to use a dedicated createEngine method in PolyglotThreadUtils to avoid deadlock issues

See #663

Author: mkjsix

polyglot/src/main/java/org/restheart/polyglot/JSPlugin.java

@@ -39,9 +39,12 @@ public abstract class JSPlugin {
 
     static {
         try {
-            // Engine.create() touches Truffle thread locals, must run on a platform thread (see PolyglotThreadUtils)
-            // and needs PluginsClassloader so ServiceLoader can find js-language's TruffleLanguageProvider
-            engine = PolyglotThreadUtils.onPlatformThread(() -> PolyglotClassloaderHelper.withPluginsClassloaderResult(Engine::create));
+            // Must be a plain method reference to a method NOT declared here: a lambda
+            // body written inside this static initializer would become a private
+            // synthetic method of JSPlugin, and invoking it from the platform thread
+            // would then require JSPlugin's own <clinit> to finish -- which is exactly
+            // what's blocked waiting for this platform thread, causing a deadlock.
+            engine = PolyglotThreadUtils.onPlatformThread(PolyglotThreadUtils::createEngine);
         } catch (Exception e) {
             throw new IllegalStateException("Error creating polyglot Engine", e);
         }

polyglot/src/main/java/org/restheart/polyglot/PolyglotThreadUtils.java

@@ -20,11 +20,14 @@
  */
 package org.restheart.polyglot;
 
+import java.io.IOException;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
+import org.graalvm.polyglot.Engine;
+
 /**
  * Runs GraalVM polyglot Context creation, enter/leave and eval on a platform thread.
  *
@@ -47,6 +50,20 @@ private PolyglotThreadUtils() {}
      * @return the result of the task
      * @throws Exception if the task throws an exception
      */
+    /**
+     * Creates a polyglot Engine with the PluginsClassloader as context classloader.
+     *
+     * <p>Declared here (not as a lambda body inside JSPlugin's static initializer)
+     * so that invoking it from a platform thread never needs to wait on JSPlugin's
+     * own class-initialization monitor, which would deadlock since JSPlugin's
+     * &lt;clinit&gt; is the one submitting this task and blocking on its result.</p>
+     *
+     * @return a newly created Engine
+     */
+    public static Engine createEngine() throws IOException {
+        return PolyglotClassloaderHelper.withPluginsClassloaderResult(Engine::create);
+    }
+
     public static <T> T onPlatformThread(Callable<T> task) throws Exception {
         try {
             return PLATFORM_EXECUTOR.submit(task).get();