Merge pull request #47610 from holly-cummins/do-not-start-dev-services-in-augmentation

Do not start redis dev services in augmentation (plus supporting framework)

Author: holly-cummins

core/deployment/src/main/java/io/quarkus/deployment/builditem/ApplicationInstanceIdBuildItem.java

@@ -0,0 +1,25 @@
+package io.quarkus.deployment.builditem;
+
+import java.util.UUID;
+
+import io.quarkus.builder.item.SimpleBuildItem;
+
+/**
+ * A unique identifier for an instance of an application.
+ * Development and test modes will have different IDs.
+ * The application ID will persist across continuous test restarts and dev mode restarts.
+ * It mirrors the lifecycle of a curated application.
+ *
+ */
+public final class ApplicationInstanceIdBuildItem extends SimpleBuildItem {
+
+    final UUID UUID;
+
+    public ApplicationInstanceIdBuildItem(UUID uuid) {
+        this.UUID = uuid;
+    }
+
+    public UUID getUUID() {
+        return UUID;
+    }
+}

core/deployment/src/main/java/io/quarkus/deployment/builditem/CuratedApplicationShutdownBuildItem.java

@@ -13,7 +13,7 @@
  * <p>
  * For production applications, this will be at the end of the Maven/Gradle build. For dev mode applications, this will be
  * when dev mode shuts down. For tests, it will generally be at the end of the test run. However, for continuous testing this
- * will be when the outer dev mode process shuts down. For unit style tests, this will usually be the end of the test.
+ * will be when the outer dev mode process shuts down. For extension unit tests, this will usually be the end of the test.
  */
 public final class CuratedApplicationShutdownBuildItem extends SimpleBuildItem {
 

core/deployment/src/main/java/io/quarkus/deployment/builditem/DevServicesRegistryBuildItem.java

@@ -0,0 +1,61 @@
+package io.quarkus.deployment.builditem;
+
+import java.io.Closeable;
+import java.util.Set;
+import java.util.UUID;
+
+import io.quarkus.builder.item.SimpleBuildItem;
+import io.quarkus.deployment.dev.devservices.DevServicesConfig;
+import io.quarkus.devservices.crossclassloader.runtime.ComparableDevServicesConfig;
+import io.quarkus.devservices.crossclassloader.runtime.DevServiceOwner;
+import io.quarkus.devservices.crossclassloader.runtime.RunningDevServicesRegistry;
+import io.quarkus.runtime.LaunchMode;
+
+// Ideally we would have a unique build item for each processor/feature, but that would need a new KeyedBuildItem or FeatureBuildItem type
+// Needs to be in core because DevServicesResultBuildItem is in core
+public final class DevServicesRegistryBuildItem extends SimpleBuildItem {
+
+    // This is a fairly thin wrapper around the tracker, so the tracker can be loaded with the system classloader
+    // The QuarkusClassLoader takes care of loading the tracker with the right classloader
+    private final RunningDevServicesRegistry tracker;
+    private final UUID uuid;
+    private final DevServicesConfig globalConfig;
+    private final LaunchMode launchMode;
+
+    public DevServicesRegistryBuildItem(UUID uuid, DevServicesConfig globalDevServicesConfig, LaunchMode launchMode) {
+        this.launchMode = launchMode;
+        this.tracker = new RunningDevServicesRegistry();
+        this.uuid = uuid;
+        this.globalConfig = globalDevServicesConfig;
+    }
+
+    public Set<Closeable> getRunningServices(String featureName, String configName, Object identifyingConfig) {
+        DevServiceOwner owner = new DevServiceOwner(featureName, launchMode.name(), configName);
+        ComparableDevServicesConfig key = new ComparableDevServicesConfig(uuid, owner, globalConfig, identifyingConfig);
+        return tracker.getRunningServices(key);
+    }
+
+    public Set<Closeable> getAllRunningServices(String featureName, String configName) {
+        DevServiceOwner owner = new DevServiceOwner(featureName, launchMode.name(), configName);
+        return tracker.getAllRunningServices(owner);
+    }
+
+    public void addRunningService(String featureName, String configName, Object identifyingConfig,
+            DevServicesResultBuildItem.RunnableDevService service) {
+        DevServiceOwner owner = new DevServiceOwner(featureName, launchMode.name(), configName);
+        ComparableDevServicesConfig key = new ComparableDevServicesConfig(uuid, owner, globalConfig, identifyingConfig);
+        tracker.addRunningService(key, service);
+    }
+
+    public void removeRunningService(String featureName, String configName, Object identifyingConfig,
+            DevServicesResultBuildItem.RunnableDevService service) {
+        DevServiceOwner owner = new DevServiceOwner(featureName, launchMode.name(), configName);
+        ComparableDevServicesConfig key = new ComparableDevServicesConfig(uuid, owner, globalConfig, identifyingConfig);
+        tracker.removeRunningService(key, service);
+    }
+
+    public void closeAllRunningServices() {
+        tracker.closeAllRunningServices(launchMode.name());
+    }
+
+}

core/deployment/src/main/java/io/quarkus/deployment/builditem/DevServicesResultBuildItem.java

@@ -2,27 +2,35 @@
 
 import java.io.Closeable;
 import java.io.IOException;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.Supplier;
+
+import org.jboss.logging.Logger;
 
 import io.quarkus.builder.item.MultiBuildItem;
 
 /**
  * BuildItem for running dev services.
  * Combines injected configs to the application with container id (if it exists).
- *
+ * <p>
  * Processors are expected to return this build item not only when the dev service first starts,
  * but also if a running dev service already exists.
- *
+ * <p>
  * {@link RunningDevService} helps to manage the lifecycle of the running dev service.
  */
 public final class DevServicesResultBuildItem extends MultiBuildItem {
 
+    private static final Logger log = Logger.getLogger(DevServicesResultBuildItem.class);
+
     private final String name;
     private final String description;
+    // Will be null if there is a runnable dev service
     private final String containerId;
-    private final Map<String, String> config;
+    protected final Map<String, String> config;
+    protected RunnableDevService runnableDevService;
 
     public DevServicesResultBuildItem(String name, String containerId, Map<String, String> config) {
         this(name, null, containerId, config);
@@ -35,6 +43,12 @@ public DevServicesResultBuildItem(String name, String description, String contai
         this.config = config;
     }
 
+    public DevServicesResultBuildItem(String name, String description, Map<String, String> config,
+            RunnableDevService runnableDevService) {
+        this(name, description, null, config);
+        this.runnableDevService = runnableDevService;
+    }
+
     public String getName() {
         return name;
     }
@@ -44,20 +58,42 @@ public String getDescription() {
     }
 
     public String getContainerId() {
-        return containerId;
+        if (runnableDevService != null) {
+            return runnableDevService.getContainerId();
+        } else {
+            return containerId;
+        }
     }
 
     public Map<String, String> getConfig() {
         return config;
     }
 
+    public void start() {
+        if (runnableDevService != null) {
+            runnableDevService.start();
+        } else {
+            log.debugf("Not starting %s because runnable dev service is null (it is probably a running dev service.", name);
+        }
+    }
+
+    // Ideally everyone would use the config source, but if people need to ask for config directly, make it possible
+    public Map<String, String> getDynamicConfig() {
+        if (runnableDevService != null && runnableDevService.isRunning()) {
+            return runnableDevService.get();
+        } else {
+            return Collections.emptyMap();
+        }
+    }
+
     public static class RunningDevService implements Closeable {
 
-        private final String name;
-        private final String description;
-        private final String containerId;
-        private final Map<String, String> config;
-        private final Closeable closeable;
+        protected final String name;
+        protected final String description;
+        protected final String containerId;
+        protected final Map<String, String> config;
+        protected final Closeable closeable;
+        protected volatile boolean isRunning = true;
 
         private static Map<String, String> mapOf(String key, String value) {
             Map<String, String> map = new HashMap<>();
@@ -109,6 +145,9 @@ public Closeable getCloseable() {
             return closeable;
         }
 
+        // This method should be on RunningDevService, but not on RunnableDevService, where we use different logic to
+        // decide when it's time to close a container. For now, leave it where it is and hope it doesn't get called when it shouldn't.
+        // We can either make a common parent class or throw unsupported when this is called from Runnable.
         public boolean isOwner() {
             return closeable != null;
         }
@@ -117,11 +156,135 @@ public boolean isOwner() {
         public void close() throws IOException {
             if (this.closeable != null) {
                 this.closeable.close();
+                isRunning = false;
             }
         }
 
         public DevServicesResultBuildItem toBuildItem() {
             return new DevServicesResultBuildItem(name, description, containerId, config);
         }
     }
+
+    public static class RunnableDevService extends RunningDevService implements Supplier<Map<String, String>> {
+
+        private final DevServicesRegistryBuildItem tracker;
+        private final Startable container;
+        private final Object identifyingConfig;
+        private final String featureName;
+        private final String configName;
+        private final Map<String, Supplier<String>> lazyConfig;
+
+        /**
+         * There are several configs in this argument, but there's a reason! (For now, at least.)
+         * The identifying config object is the user-defined config, and are what we use to establish ownership and reusability.
+         * The config name is used to identify sub-configuration.
+         * The first feature name is generated by the processor.
+         */
+        public RunnableDevService(String featureName, String configName, Startable container,
+                Map lazyConfig,
+                Object identifyingConfig,
+                DevServicesRegistryBuildItem tracker) {
+            super(featureName, null, container::close, Collections.emptyMap());
+
+            this.featureName = featureName;
+            this.configName = configName;
+            this.container = container;
+            this.tracker = tracker;
+            isRunning = false;
+            this.lazyConfig = lazyConfig;
+            this.identifyingConfig = identifyingConfig;
+        }
+
+        public boolean isRunning() {
+            return isRunning;
+        }
+
+        @Override
+        public String getContainerId() {
+            return container != null ? container.getContainerId() : null;
+        }
+
+        /**
+         * Starts the service, after first checking for a compatible service in the tracker.
+         * Calling classes may wish to do their own checks for compatible services before calling start().
+         */
+        public void start() {
+            // We want to do two things; find things with the same config as us to reuse them, and find things with different config to close them
+            // We figure out if we need to shut down existing redis containers that might have been started in previous profiles or restarts
+
+            // These RunnableDevService classes could be from another classloader, so don't make assumptions about the class
+            Collection<?> matchedDevServices = tracker.getRunningServices(featureName, configName, identifyingConfig);
+            // if the redis containers have already started we just return; if we wanted to be very cautious we could check the entries for an isRunningStatus, but they might be in the wrong classloader, so that's hard work
+            if (matchedDevServices == null || matchedDevServices.isEmpty()) {
+                // There isn't a running container that has the right config, we need to do work
+                // Let's get all the running dev services associated with this feature (+ launch mode plus named section), so we can close them
+                closeOwnedServices();
+
+                reallyStart();
+            }
+        }
+
+        private void closeOwnedServices() {
+            Collection<Closeable> unusableDevServices = tracker.getAllRunningServices(featureName, configName);
+            if (unusableDevServices != null) {
+                for (Closeable closeable : unusableDevServices) {
+                    try {
+                        closeable.close();
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+        }
+
+        /**
+         * Starts, without doing any duplicate checking, and without doing any cleanup.
+         * The duplicate checking is optional, the cleanup is not.
+         */
+        private void reallyStart() {
+            if (container != null) {
+                synchronized (this) {
+                    container.start();
+
+                    //  tell the tracker that we started
+                    isRunning = true;
+                    tracker.addRunningService(featureName, configName, identifyingConfig, this);
+                }
+                // Ideally we'd print out a port number here, but we can only do that if we add a dependency on GenericContainer (or update startable to add a method)
+
+                log.infof("The %s dev service is ready to accept connections on %s", name, container.getConnectionInfo());
+            } else {
+                throw new IllegalStateException("Internal error: attempted to start a null container.");
+            }
+        }
+
+        @Override
+        public void close() throws IOException {
+            tracker.removeRunningService(featureName, configName, identifyingConfig, this);
+            super.close();
+        }
+
+        public DevServicesResultBuildItem toBuildItem() {
+            return new DevServicesResultBuildItem(name, description, config, this);
+        }
+
+        /**
+         * This is a supplier interface to maintain type-compatibility across classloaders.
+         * What this is actually giving is an aggregate of the hardcoded and lazy (dynamic at runtime) config.
+         *
+         */
+        @Override
+        public Map<String, String> get() {
+            // printlns show this gets called super often, so want to be as efficient as we can in this code
+            Map<String, String> newConfig = new HashMap<>(getConfig());
+            // We don't want to be returning config while the container is in the process of starting, so synchronize
+            synchronized (this) {
+                for (Map.Entry<String, Supplier<String>> entry : lazyConfig.entrySet()) {
+                    newConfig.put(entry.getKey(), entry.getValue().get());
+                }
+            }
+            return newConfig;
+        }
+
+    }
 }

core/deployment/src/main/java/io/quarkus/deployment/builditem/Startable.java

@@ -0,0 +1,13 @@
+package io.quarkus.deployment.builditem;
+
+import java.io.Closeable;
+
+public interface Startable extends Closeable {
+    void start();
+
+    String getConnectionInfo();
+
+    // This starts to couple to containers, so we could move it to sub-interface and use that in dev services
+    String getContainerId();
+
+}