Merged in bugfix/EL-365-datastore-not-accessible-at-runti (pull request #185)

EL-365 Made morphia accessible via the mongo dao ElementDependency

Author: krh372

common-servlet/src/main/java/dev/getelements/elements/servlet/security/HttpServletAuthenticationFilter.java

@@ -78,6 +78,10 @@ public void doFilter(final ServletRequest _request,
     }
 
     private void fail(final HttpServletResponse response, final Exception ex) throws IOException {
+        if (response.isCommitted()) {
+            logger.debug("Response already committed; suppressing secondary error write.", ex);
+            return;
+        }
         final var error = new ErrorResponse();
         error.setCode(UNKNOWN.toString());
         error.setMessage(ex.getMessage());
@@ -86,6 +90,10 @@ private void fail(final HttpServletResponse response, final Exception ex) throws
     }
 
     private void fail(final HttpServletResponse response, final BaseException ex) throws IOException {
+        if (response.isCommitted()) {
+            logger.debug("Response already committed; suppressing secondary error write.", ex);
+            return;
+        }
         final var error = new ErrorResponse();
         error.setCode(ex.getCode().toString());
         error.setMessage(ex.getMessage());

deployment-jetty/src/main/java/dev/getelements/elements/deployment/jetty/JettyElementContainerService.java

@@ -123,14 +123,23 @@ public List<ContainerRecord> getActiveContainers() {
         try (var mon = Monitor.enter(lock)) {
             return activeContainers.values()
                     .stream()
-                    .map(active -> new ContainerRecord(
-                            active.runtime(),
-                            active.status(),
-                            active.uris(),
-                            active.logs(),
-                            active.errors(),
-                            active.elements()
-                    ))
+                    .map(active -> {
+                        // Override status to LOADING if any loader still has background work
+                        // in progress for any element in this container (e.g. async Jersey start).
+                        final var status = active.status() != FAILED
+                                && active.elements().stream().anyMatch(
+                                        e -> getLoaders().stream().anyMatch(l -> l.hasPendingWork(e)))
+                                ? LOADING
+                                : active.status();
+                        return new ContainerRecord(
+                                active.runtime(),
+                                status,
+                                active.uris(),
+                                active.logs(),
+                                active.errors(),
+                                active.elements()
+                        );
+                    })
                     .toList();
         }
     }
@@ -174,7 +183,11 @@ public void onRuntimeLoaded(final ElementRuntimeService.RuntimeRecord runtimeRec
             // Check if already mounted
             final var existing = activeContainers.get(deploymentId);
             if (existing != null) {
-                logger.warn("Container already mounted for deployment: {}, remounting", deploymentId);
+                if (existing.runtime().deployment().version() == runtimeRecord.deployment().version()) {
+                    logger.debug("Container already mounted at current version for deployment: {}, skipping event-driven mount", deploymentId);
+                    return;
+                }
+                logger.info("Container mounted at stale version for deployment: {}, remounting", deploymentId);
                 doUnmount(deploymentId);
             }
 
@@ -218,9 +231,22 @@ public void onRuntimeLoaded(final ElementRuntimeService.RuntimeRecord runtimeRec
     public void onRuntimeUnloaded(final String deploymentId) {
         boolean unmounted = false;
 
+        // Check BEFORE acquiring the container lock whether the deployment is still active
+        // in the runtime service. If it is, the deployment was reloaded (not truly removed),
+        // and the RuntimeUnloaded event is the "old version" notification from reconcile().
+        // In that case we must not unmount the freshly-loaded container.
+        final var stillActive = getElementRuntimeService().getActiveRuntimes()
+                .stream()
+                .anyMatch(r -> r.deployment().id().equals(deploymentId));
+
         try (var mon = Monitor.enter(lock)) {
             logger.info("Received RuntimeUnloaded event for deployment: {}", deploymentId);
 
+            if (stillActive) {
+                logger.debug("Deployment {} was reloaded; skipping event-driven unmount", deploymentId);
+                return;
+            }
+
             // Unmount the container if it exists
             final var existing = activeContainers.get(deploymentId);
             if (existing != null) {
@@ -335,13 +361,16 @@ private void doMount(final RuntimeRecord runtime) {
         logs.add("Starting container mount for deployment " + deploymentId);
 
         try {
+            // Identity set to deduplicate elements across multiple loaders that may report the same element.
+            final var seenElements = Collections.newSetFromMap(new IdentityHashMap<>());
+
             // Create pending deployment context
             final var pending = new Loader.PendingDeployment(
                     uris::add,
                     logs::add,
                     warnings::add,
                     errors::add,
-                    elements::add
+                    element -> { if (seenElements.add(element)) elements.add(element); }
             );
 
             // Run all loaders

deployment-jetty/src/main/java/dev/getelements/elements/deployment/jetty/StandardElementRuntimeService.java

@@ -498,7 +498,8 @@ private List<Element> loadElements(final DeploymentContext context) {
 
             // PHASE A: STAGING
             // Collect all element source paths into a list
-            context.log("=== Phase A: Staging all element sources ===");
+            context.log("=== Staging all element sources ===");
+            final var phaseAStartNs = System.nanoTime();
 
             // Strategy 1: Stage uploaded ELM from LargeObject if present
             if (hasElmFromLargeObject(context.deployment())) {
@@ -573,10 +574,12 @@ private List<Element> loadElements(final DeploymentContext context) {
             }
 
             context.log("Staged " + context.elementPaths().size() + " element path(s)");
+            context.log("Staging completed in " + (System.nanoTime() - phaseAStartNs) / 1_000_000 + " ms");
 
             // PHASE B: LOADING
             // Load all elements in a single operation
-            context.log("=== Phase B: Loading all elements ===");
+            context.log("=== Loading all elements ===");
+            final var phaseBStartNs = System.nanoTime();
 
             final List<Element> allElements;
 
@@ -619,6 +622,7 @@ private List<Element> loadElements(final DeploymentContext context) {
                     ));
                 }
 
+                context.log("Guice/classloader completed in " + (System.nanoTime() - phaseBStartNs) / 1_000_000 + " ms");
                 context.log("Successfully loaded " + allElements.size() + " element(s)");
 
             } catch (Exception ex) {
@@ -1257,6 +1261,9 @@ public void close() {
             for (final FileSystem fileSystem : filesystems) {
                 try {
                     fileSystem.close();
+                } catch (java.nio.file.NoSuchFileException ex) {
+                    logger.debug("File system backing file already gone for deployment {} (file was likely replaced): {}",
+                            deployment.id(), ex.getFile());
                 } catch (IOException ex) {
                     logger.warn("Failed to close file system {} for deployment {}", fileSystem, deployment.id(), ex);
                 }

deployment-jetty/src/main/java/dev/getelements/elements/deployment/jetty/guice/JettySdkElementModule.java

@@ -5,6 +5,7 @@
 import dev.getelements.elements.deployment.jetty.StandardElementRuntimeService;
 import dev.getelements.elements.deployment.jetty.loader.AuthFilterFeature;
 import dev.getelements.elements.deployment.jetty.loader.HttpPathRegistry;
+import dev.getelements.elements.deployment.jetty.loader.ElementEntityLoader;
 import dev.getelements.elements.deployment.jetty.loader.JakartaRsLoader;
 import dev.getelements.elements.deployment.jetty.loader.JakartaWebsocketLoader;
 import dev.getelements.elements.deployment.jetty.loader.Loader;
@@ -46,6 +47,7 @@ protected void configureElement() {
                 .asEagerSingleton();
 
         final var loaders = newSetBinder(binder(), Loader.class);
+        loaders.addBinding().to(ElementEntityLoader.class);
         loaders.addBinding().to(JakartaRsLoader.class);
         loaders.addBinding().to(JakartaWebsocketLoader.class);
         loaders.addBinding().to(StaticContentLoader.UI.class);

deployment-jetty/src/main/java/dev/getelements/elements/deployment/jetty/loader/ClassLoaderSwitchHandler.java

@@ -0,0 +1,65 @@
+package dev.getelements.elements.deployment.jetty.loader;
+
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Response;
+import org.eclipse.jetty.util.Callback;
+
+/**
+ * A Jetty {@link Handler.Wrapper} that switches the thread context classloader (TCCL) to the
+ * element's {@link ClassLoader} for the duration of each request, restoring the original
+ * classloader in a {@code finally} block.
+ *
+ * <p>This is required for element-hosted services that share the platform Morphia
+ * {@code Datastore}. Morphia's {@code DiscriminatorLookup} falls back to
+ * {@code Class.forName(discriminatorValue)} when an entity class is not pre-registered; that
+ * call resolves classes using the calling thread's context classloader. Without this wrapper it
+ * would use the Jetty thread pool's classloader (the platform classloader), making
+ * element-specific entity classes invisible during document decoding.
+ *
+ * <p>Placing this wrapper outside the {@link org.eclipse.jetty.ee10.servlet.ServletContextHandler}
+ * ensures the TCCL is set before Jetty's own context scope handling, and also covers any
+ * non-servlet code paths (e.g. async dispatch, error handling) that Jetty may route through
+ * the handler chain without re-entering the servlet context.
+ */
+class ClassLoaderSwitchHandler extends Handler.Wrapper {
+
+    private final ClassLoader classLoader;
+
+    ClassLoaderSwitchHandler(final ClassLoader classLoader, final Handler handler) {
+        super(handler);
+        this.classLoader = classLoader;
+    }
+
+    @Override
+    public boolean handle(final Request request, final Response response, final Callback callback)
+            throws Exception {
+        final var thread = Thread.currentThread();
+        final var previous = thread.getContextClassLoader();
+        // Wrap the callback so the element's TCCL is also active when Jetty invokes
+        // succeeded()/failed() — which may happen on a different thread for async requests
+        // (e.g. async dispatch, error handling, or non-blocking I/O completion).
+        final var wrapped = Callback.from(
+                () -> withTccl(callback::succeeded),
+                x  -> withTccl(() -> callback.failed(x))
+        );
+        try {
+            thread.setContextClassLoader(classLoader);
+            return super.handle(request, response, wrapped);
+        } finally {
+            thread.setContextClassLoader(previous);
+        }
+    }
+
+    private void withTccl(final Runnable action) {
+        final var thread = Thread.currentThread();
+        final var previous = thread.getContextClassLoader();
+        try {
+            thread.setContextClassLoader(classLoader);
+            action.run();
+        } finally {
+            thread.setContextClassLoader(previous);
+        }
+    }
+
+}

deployment-jetty/src/main/java/dev/getelements/elements/deployment/jetty/loader/ElementEntityLoader.java

@@ -0,0 +1,49 @@
+package dev.getelements.elements.deployment.jetty.loader;
+
+import dev.getelements.elements.sdk.Element;
+import dev.getelements.elements.sdk.dao.ElementEntityRegistrar;
+import dev.getelements.elements.sdk.deployment.ElementRuntimeService.RuntimeRecord;
+import jakarta.inject.Inject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A {@link Loader} that registers an element's entity classes with the platform database mapper
+ * on load and deregisters them on unload.
+ *
+ * <p>This loader is independent of the RS and WS loaders so that entity registration applies
+ * to all element types uniformly.
+ */
+public class ElementEntityLoader implements Loader {
+
+    private static final Logger logger = LoggerFactory.getLogger(ElementEntityLoader.class);
+
+    private ElementEntityRegistrar elementEntityRegistrar;
+
+    @Override
+    public void load(final PendingDeployment pending, final RuntimeRecord record, final Element element) {
+        if (elementEntityRegistrar != null) {
+            elementEntityRegistrar.registerEntityClasses(element);
+        }
+    }
+
+    @Override
+    public void unload(final Element element) {
+        if (elementEntityRegistrar != null) {
+            elementEntityRegistrar.unregisterEntityClasses(element);
+        } else {
+            logger.debug("No ElementEntityRegistrar bound; skipping entity deregistration for {}",
+                    element.getElementRecord().definition().name());
+        }
+    }
+
+    public ElementEntityRegistrar getElementEntityRegistrar() {
+        return elementEntityRegistrar;
+    }
+
+    @Inject
+    public void setElementEntityRegistrar(final ElementEntityRegistrar elementEntityRegistrar) {
+        this.elementEntityRegistrar = elementEntityRegistrar;
+    }
+
+}