fix: create Contexts and Engine directly on the calling thread to prevent thread-local issues

Author: mkjsix

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

@@ -82,19 +82,14 @@ public ContextQueue(Engine engine, String name, Configuration conf, Logger logge
         this.modulesReplacements = modulesReplacements;
         this.OPTS = OPTS;
 
-        // Pre-populate pool: each Context must be created on a platform thread.
-        // Do NOT delegate to newContext() here -- its callers (args(), create())
-        // are already inside onPlatformThread, so newContext() must not wrap again
-        // (nested dispatch creates the Context on a *different* platform thread
-        // than the one that will enter it, which corrupts Truffle's
-        // DefaultContextThreadLocal bookkeeping, see oracle/graal#7520).
+        // Pre-populate pool: create Contexts directly on the calling thread.
+        // The calling thread is the main thread during startup (platform thread
+        // where Engine was just created), so DefaultContextThreadLocal is already
+        // initialised.  We must NOT dispatch to a pool thread here: Truffle's
+        // bookkeeping breaks when a Context is created on one thread and entered
+        // on another (see oracle/graal#7520).
         for (var c = 0;c < POOL_SIZE;c++) {
-            try {
-                pool.offer(PolyglotThreadUtils.onPlatformThread(
-                        () -> newContext(engine, name, conf, logger, mclient, modulesReplacements, OPTS)));
-            } catch (Exception e) {
-                LOGGER.warn("Error pre-creating polyglot context", e);
-            }
+            pool.offer(newContext(engine, name, conf, logger, mclient, modulesReplacements, OPTS));
         }
     }
 

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

@@ -26,6 +26,7 @@
 import org.graalvm.polyglot.Engine;
 import org.graalvm.polyglot.Source;
 import org.restheart.configuration.Configuration;
+import org.restheart.polyglot.PolyglotClassloaderHelper;
 import org.restheart.polyglot.services.JSServiceArgs;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -39,12 +40,16 @@ public abstract class JSPlugin {
 
     static {
         try {
-            // 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);
+            // Engine.create() is called directly on the main thread (not dispatched
+            // to a pool thread).  This avoids Truffle's DefaultContextThreadLocal
+            // being initialised on a throwaway pool thread, which corrupts the
+            // bookkeeping when a *different* thread later enters a Context
+            // (see oracle/graal#7520).
+            //
+            // No deadlock risk: PolyglotClassloaderHelper and Engine are both on
+            // different classes, so referencing them from this <clinit> never
+            // re-enters JSPlugin's own class initialisation.
+            engine = PolyglotClassloaderHelper.withPluginsClassloaderResult(Engine::create);
         } catch (Exception e) {
             throw new IllegalStateException("Error creating polyglot Engine", e);
         }

polyglot/src/main/java/org/restheart/polyglot/interceptors/JSInterceptorFactory.java

@@ -65,9 +65,9 @@ public JSInterceptorFactory(Optional<MongoClient> mclient, Configuration config)
         this.mclient = mclient;
         this.config = config;
         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
-            this.engine = PolyglotThreadUtils.onPlatformThread(PolyglotThreadUtils::createEngine);
+            // Engine.create() called directly on the calling thread (main thread during
+            // startup).  See JSPlugin.<clinit> for the rationale.
+            this.engine = PolyglotClassloaderHelper.withPluginsClassloaderResult(Engine::create);
         } catch (Exception e) {
             throw new IllegalStateException("Error creating polyglot Engine", e);
         }