Merge branch '9.x-polyglot-fix' into 9.x

fix: route all Truffle operations through dedicated platform thread (oracle/graal#7520)

Resolves merge conflicts by taking the fix version for all polyglot files,
superseding obsolete commits after 9.7.0.

Closes #663
See #665

Author: mkjsix

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

@@ -82,9 +82,38 @@ public ContextQueue(Engine engine, String name, Configuration conf, Logger logge
         this.modulesReplacements = modulesReplacements;
         this.OPTS = OPTS;
 
-        // Pre-populate pool
+        // Pre-populate pool on the dedicated platform thread.  Each Context
+        // is created, entered, bound, left and returned to the pool — all on
+        // the same thread that will be used at runtime, to avoid
+        // DefaultContextThreadLocal index corruption (oracle/graal#7520).
+        //
+        // If already on the platform thread (e.g. called from within a
+        // JSInterceptorFactory.create lambda), create directly to avoid
+        // self-deadlock on the single-threaded executor.
+        if (PolyglotThreadUtils.isAlreadyOnPlatformThread()) {
+            populatePool(engine, name, conf, logger, mclient, modulesReplacements);
+        } else {
+            try {
+                PolyglotThreadUtils.onPlatformThread(() -> {
+                    populatePool(engine, name, conf, logger, mclient, modulesReplacements);
+                    return null;
+                });
+            } catch (Exception e) {
+                throw new IllegalStateException("Error pre-populating polyglot context pool", e);
+            }
+        }
+    }
+
+    private void populatePool(Engine engine, String name, Configuration conf, Logger logger, Optional<MongoClient> mclient, String modulesReplacements) {
         for (var c = 0;c < POOL_SIZE;c++) {
-            pool.offer(newContext());
+            var ctx = newContext(engine, name, conf, logger, mclient, modulesReplacements, OPTS);
+            ctx.enter();
+            try {
+                addBindings(ctx, name, conf, logger, mclient);
+            } finally {
+                ctx.leave();
+            }
+            pool.offer(ctx);
         }
     }
 
@@ -110,9 +139,16 @@ private Context acquire() {
      */
     private void release(Context ctx) {
         if (!pool.offer(ctx)) {
-            // Pool is full, close the context
-            ctx.close();
-            LOGGER.debug("Pool full, closed excess context");
+            try {
+                // Context.close() touches thread locals, must run on a platform thread, see PolyglotThreadUtils
+                PolyglotThreadUtils.onPlatformThread(() -> {
+                    ctx.close();
+                    return null;
+                });
+                LOGGER.debug("Pool full, closed excess context");
+            } catch (Exception e) {
+                LOGGER.warn("Error closing excess context", e);
+            }
         }
     }
 
@@ -127,14 +163,23 @@ private void release(Context ctx) {
      * @throws Exception if the task throws an exception
      */
     public <T> T executeWithContext(ContextTask<T> task) throws Exception {
-        Context ctx = acquire();
-        ctx.enter();
-        try {
-            return task.run(ctx);
-        } finally {
-            ctx.leave();
-            release(ctx);
-        }
+        // acquire/enter/task/leave/release must all happen on the very same
+        // platform thread: if the pool is empty, acquire() calls newContext()
+        // which creates a Context that must be entered on the same thread
+        // (see PolyglotThreadUtils / oracle/graal#7520).
+        return PolyglotThreadUtils.onPlatformThread(() -> {
+            Context ctx = acquire();
+            try {
+                ctx.enter();
+                try {
+                    return task.run(ctx);
+                } finally {
+                    ctx.leave();
+                }
+            } finally {
+                release(ctx);
+            }
+        });
     }
 
     /**
@@ -144,14 +189,20 @@ public <T> T executeWithContext(ContextTask<T> task) throws Exception {
      * @throws Exception if the task throws an exception
      */
     public void executeWithContext(VoidContextTask task) throws Exception {
-        Context ctx = acquire();
-        ctx.enter();
-        try {
-            task.run(ctx);
-        } finally {
-            ctx.leave();
-            release(ctx);
-        }
+        PolyglotThreadUtils.onPlatformThread(() -> {
+            Context ctx = acquire();
+            try {
+                ctx.enter();
+                try {
+                    task.run(ctx);
+                } finally {
+                    ctx.leave();
+                }
+            } finally {
+                release(ctx);
+            }
+            return null;
+        });
     }
 
     /**
@@ -228,12 +279,18 @@ public static Context newContext(Engine engine, String name, Configuration conf,
                 .options(OPTS)
                 .build();
 
-        addBindings(ctx, name, conf, logger, mclient);
-
+        // NOTE: addBindings() is NOT called here.  It requires ctx.enter(),
+        // and a second enter()/leave() cycle before the caller's own
+        // enter() corrupts Truffle's DefaultContextThreadLocal (oracle/graal#7520).
+        // Callers must call addBindings() AFTER entering the context.
         return ctx;
     }
 
-    private static void addBindings(Context ctx,
+    /**
+     * Adds default bindings (LOGGER, mclient, pluginArgs) to an already-entered
+     * context.  Must only be called between ctx.enter() and ctx.leave().
+     */
+    public static void addBindings(Context ctx,
                                     String pluginName,
                                     Configuration conf,
                                     Logger logger,

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

@@ -35,7 +35,34 @@
 public abstract class JSPlugin {
     protected static final Logger LOGGER = LoggerFactory.getLogger(JSPlugin.class);
 
-    private static final Engine engine = Engine.create();
+    private static volatile Engine engine;
+
+    /**
+     * Returns the shared polyglot Engine, creating it on the dedicated
+     * platform thread on first access.  Lazy initialization avoids the
+     * deadlock that would occur if we created the Engine in a static
+     * initializer (the main thread holds the class-init lock while
+     * waiting for the platform thread).
+     */
+    public static Engine engine() {
+        if (engine == null) {
+            synchronized (JSPlugin.class) {
+                if (engine == null) {
+                    try {
+                        if (PolyglotThreadUtils.isAlreadyOnPlatformThread()) {
+                            engine = PolyglotClassloaderHelper.withPluginsClassloaderResult(Engine::create);
+                        } else {
+                            engine = PolyglotThreadUtils.onPlatformThread(
+                                () -> PolyglotClassloaderHelper.withPluginsClassloaderResult(Engine::create));
+                        }
+                    } catch (Exception e) {
+                        throw new IllegalStateException("Error creating polyglot Engine", e);
+                    }
+                }
+            }
+        }
+        return engine;
+    }
 
     private final String modulesReplacements;
     private final Source handleSource;
@@ -116,7 +143,4 @@ public Configuration configuration() {
         return configuration;
     }
 
-    public static Engine engine() {
-        return engine;
-    }
 }

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

@@ -61,7 +61,7 @@ private PolyglotClassloaderHelper() {}
      * Returns the PluginsClassloader instance via reflection, or null if
      * unavailable.
      */
-    private static ClassLoader getPluginsClassloader() {
+    public static ClassLoader getPluginsClassloader() {
         try {
             Class<?> pclClass = Class.forName(PCL_CLASS);
             var getInstance = pclClass.getMethod("getInstance");

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

@@ -78,9 +78,9 @@
  * @author Andrea Di Cesare {@literal <andrea@softinstigate.com>}
  */
 @RegisterPlugin(
-        name = "polyglotDeployer",
-        description = "handles GraalVM polyglot plugins",
-        enabledByDefault = true)
+    name = "polyglotDeployer",
+    description = "handles GraalVM polyglot plugins",
+    enabledByDefault = true)
 public class PolyglotDeployer implements Initializer {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(PolyglotDeployer.class);
@@ -352,17 +352,12 @@ private List<Path> findDeclaredPlugins(final Path path, final String prop, final
 
                         if (checkPluginFiles) {
                             if (Files.isRegularFile(pluginPath)) {
-                                try {
-                                    final var language = PolyglotClassloaderHelper.withPluginsClassloaderResult(
-                                        () -> Source.findLanguage(pluginPath.toFile()));
-                                    if ("js".equals(language)) {
-                                        ret.add(pluginPath);
-                                    } else {
-                                        LOGGER.warn("{} is not javascript", pluginPath.toAbsolutePath());
-                                    }
-                                } catch (final IOException e) {
-                                    LOGGER.warn("{} is not javascript", pluginPath.toAbsolutePath(), e);
-                                }
+                                // Source.findLanguage() is NOT called here:
+                                // it triggers Truffle's language-discovery
+                                // internals which corrupt DefaultContextThread-
+                                // Local (oracle/graal#7520).  Files are
+                                // already filtered to .mjs by the deployer.
+                                ret.add(pluginPath);
                             } else {
                                 LOGGER.warn("pluging not found {}, it is declared in {}", pluginPath.toAbsolutePath(),
                                         packagePath.toAbsolutePath());
@@ -454,8 +449,8 @@ private void deployNodeService(final Path pluginPath) throws IOException {
                 DEPLOYEES.put(pluginPath.toAbsolutePath(), srv);
 
                 LOGGER.info(ansi().fg(GREEN).a(
-                                "Service '{}' deployed at URI '{}' with description: '{}'. Secured: {}. Uri match policy: {}")
-                                .reset().toString(), srv.name(), srv.uri(), srv.getDescription(), srv.secured(),
+                        "Service '{}' deployed at URI '{}' with description: '{}'. Secured: {}. Uri match policy: {}")
+                        .reset().toString(), srv.name(), srv.uri(), srv.getDescription(), srv.secured(),
                         srv.matchPolicy());
             } catch (IOException | InterruptedException | ExecutionException | TimeoutException ex) {
                 LOGGER.error("Error deploying node service {}", pluginPath, ex);