feat: implement shared container feature for Dapr Dev Services with configuration options

matheusandre1 · matheusandre1 · commit f0ee05ba8b5e · 2026-04-15T13:52:40.000-03:00
diff --git a/deployment/src/main/java/io/quarkiverse/dapr/deployment/devservices/DaprDevServiceBuildTimeConfig.java b/deployment/src/main/java/io/quarkiverse/dapr/deployment/devservices/DaprDevServiceBuildTimeConfig.java
@@ -57,5 +57,13 @@ interface Dashboard {
         @WithDefault("true")
         Optional<Boolean> enabled();
 
+        /**
+         * The value of the {@code quarkus-dev-service-dapr-dashboard} label attached to the started container.
+         * <p>
+         * This is used to discover and re-use an existing shared Dapr Dashboard container.
+         */
+        @WithDefault("dapr-dashboard")
+        String serviceName();
+
     }
 }
diff --git a/deployment/src/main/java/io/quarkiverse/dapr/deployment/devservices/DashboardContainerStartable.java b/deployment/src/main/java/io/quarkiverse/dapr/deployment/devservices/DashboardContainerStartable.java
@@ -2,6 +2,7 @@
 
 import static io.quarkiverse.dapr.deployment.devservices.StateStoreContainerStartable.PGSQL_NETWORK_ALIAS;
 import static io.quarkiverse.dapr.deployment.devservices.StateStoreContainerStartable.PGSQL_STATE_STORE;
+import static io.quarkus.devservices.common.ConfigureUtil.configureSharedServiceLabel;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -13,17 +14,19 @@
 import io.dapr.testcontainers.DaprContainerConstants;
 import io.dapr.testcontainers.WorkflowDashboardContainer;
 import io.quarkus.deployment.builditem.Startable;
+import io.quarkus.runtime.LaunchMode;
 
 public class DashboardContainerStartable extends WorkflowDashboardContainer implements Startable {
 
     public static final int INTERNAL_DAPR_DASHBOARD_WORKFLOW_PORT = 8080;
 
     private static final Map<String, String> POSTGRE_SQL_DETAILS = new HashMap<>();
 
-    public DashboardContainerStartable(Network network) {
+    public DashboardContainerStartable(Network network, LaunchMode launchMode, String serviceName) {
         super(DockerImageName.parse(DaprContainerConstants.DAPR_WORKFLOWS_DASHBOARD));
         super.withExposedPorts(INTERNAL_DAPR_DASHBOARD_WORKFLOW_PORT)
                 .withNetwork(network);
+        configureSharedServiceLabel(this, launchMode, DevServicesDaprProcessor.DASHBOARD_WORKFLOW_LABEL, serviceName);
     }
 
     @Override
diff --git a/deployment/src/main/java/io/quarkiverse/dapr/deployment/devservices/DevServicesDaprProcessor.java b/deployment/src/main/java/io/quarkiverse/dapr/deployment/devservices/DevServicesDaprProcessor.java
@@ -8,6 +8,7 @@
 import static io.quarkus.devservices.common.ContainerLocator.locateContainerWithLabels;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -37,10 +38,15 @@ public class DevServicesDaprProcessor {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(DevServicesDaprProcessor.class);
     static final String DEV_SERVICE_LABEL = "quarkus-dev-service-dapr";
+    static final String DASHBOARD_WORKFLOW_LABEL = "quarkus-dev-service-dapr-dashboard";
+
     private static final int DAPR_INTERNAL_HTTP_PORT = 3500;
     private static final int DAPR_INTERNAL_GRPC_PORT = 50001;
     private static final ContainerLocator DAPR_CONTAINER_LOCATOR = locateContainerWithLabels(DAPR_INTERNAL_HTTP_PORT,
             DEV_SERVICE_LABEL);
+    private static final ContainerLocator DASHBOARD_CONTAINER_LOCATOR = locateContainerWithLabels(
+            DashboardContainerStartable.INTERNAL_DAPR_DASHBOARD_WORKFLOW_PORT,
+            DASHBOARD_WORKFLOW_LABEL);
 
     private static final String QUARKUS_DAPR_SERVICE_NAME_PREFIX = "quarkus-dev-service-";
     private static final String DASHBOARD_WORKFLOW = QUARKUS_DAPR_SERVICE_NAME_PREFIX + "dashboard-workflow";
@@ -79,17 +85,35 @@ List<DevServicesResultBuildItem> devServices(
         DevServicesResultBuildItem discoveredDapr = discoverDaprContainer(config, launchMode);
         if (discoveredDapr != null) {
             containers.add(discoveredDapr);
+            // Even when reusing a shared Dapr container, we still need to start the
+            // dashboard and state-store containers for this application (or discover them).
+            if (config.dashboard().enabled().get()) {
+                DevServicesResultBuildItem discoveredDashboard = discoverDashboardContainer(config, launchMode);
+                if (discoveredDashboard != null) {
+                    containers.add(discoveredDashboard);
+                } else {
+                    DevServicesResultBuildItem pgsql = configurePgsqlContainer(network, launchMode);
+                    DevServicesResultBuildItem dashboard = configureDashboardWorkflowContainer(config, network, launchMode);
+                    containers.add(pgsql);
+                    containers.add(dashboard);
+                }
+            }
             return containers;
         }
 
         DevServicesResultBuildItem dapr = configureDaprContainer(config, launchMode, network);
         containers.add(dapr);
 
         if (config.dashboard().enabled().get()) {
-            DevServicesResultBuildItem pgsql = configurePgsqlContainer(network);
-            DevServicesResultBuildItem dashboard = configureDashboardWorkflowContainer(network);
-            containers.add(dashboard);
-            containers.add(pgsql);
+            DevServicesResultBuildItem discoveredDashboard = discoverDashboardContainer(config, launchMode);
+            if (discoveredDashboard != null) {
+                containers.add(discoveredDashboard);
+            } else {
+                DevServicesResultBuildItem pgsql = configurePgsqlContainer(network, launchMode);
+                DevServicesResultBuildItem dashboard = configureDashboardWorkflowContainer(config, network, launchMode);
+                containers.add(pgsql);
+                containers.add(dashboard);
+            }
         }
 
         return containers;
@@ -114,12 +138,21 @@ private static DevServicesResultBuildItem discoverDaprContainer(DaprDevServiceBu
             return null;
         }
 
-        configureDaprPorts(grpcAddress.getPort(), httpAddress.getPort());
+        int grpcPort = grpcAddress.getPort();
+        int httpPort = httpAddress.getPort();
+        configureDaprPorts(grpcPort, httpPort);
         LOGGER.info("Re-using shared Dapr container {} listening on HTTP {} and gRPC {}",
-                containerId.get(), httpAddress.getPort(), grpcAddress.getPort());
+                containerId.get(), httpPort, grpcPort);
+
+        // Always supply a non-null config map so DevServicesConfigBuildStep#setup won't NPE
+        Map<String, String> portConfig = new HashMap<>();
+        portConfig.put(Properties.HTTP_PORT.getName(), Integer.toString(httpPort));
+        portConfig.put(Properties.GRPC_PORT.getName(), Integer.toString(grpcPort));
+
         return DevServicesResultBuildItem.discovered()
                 .name(FEATURE)
                 .containerId(containerId.get())
+                .config(Collections.unmodifiableMap(portConfig))
                 .build();
     }
 
@@ -150,19 +183,54 @@ public Startable get() {
                 .build();
     }
 
+    private static DevServicesResultBuildItem discoverDashboardContainer(DaprDevServiceBuildTimeConfig config,
+            LaunchModeBuildItem launchModeBuildItem) {
+        Map<Integer, ContainerAddress> mappedPorts = new HashMap<>();
+        Optional<String> containerId = DASHBOARD_CONTAINER_LOCATOR.locateContainer(
+                config.dashboard().serviceName(),
+                config.shared().get(),
+                launchModeBuildItem.getLaunchMode(),
+                mappedPorts::put);
+
+        if (containerId.isEmpty()) {
+            return null;
+        }
+
+        ContainerAddress dashboardAddress = mappedPorts.get(DashboardContainerStartable.INTERNAL_DAPR_DASHBOARD_WORKFLOW_PORT);
+        if (dashboardAddress == null) {
+            LOGGER.warn("Found shared Dapr Dashboard container {} but missing mapped port. Creating a new one instead.",
+                    containerId.get());
+            return null;
+        }
+
+        String dashboardUrl = "http://127.0.0.1:" + dashboardAddress.getPort();
+        LOGGER.info("Re-using shared Dapr Dashboard container {} at {}", containerId.get(), dashboardUrl);
+
+        Map<String, String> dashboardConfig = new HashMap<>();
+        dashboardConfig.put(DAPR_DASHBOARD_WORKFLOW_URL, dashboardUrl);
+
+        return DevServicesResultBuildItem.discovered()
+                .name(FEATURE)
+                .containerId(containerId.get())
+                .config(Collections.unmodifiableMap(dashboardConfig))
+                .build();
+    }
+
     private static void configureDaprPorts(int grpcPort, int httpPort) {
         System.setProperty(Properties.GRPC_PORT.getName(), Integer.toString(grpcPort));
         System.setProperty(Properties.HTTP_PORT.getName(), Integer.toString(httpPort));
     }
 
-    private static DevServicesResultBuildItem configureDashboardWorkflowContainer(Network network) {
+    private static DevServicesResultBuildItem configureDashboardWorkflowContainer(DaprDevServiceBuildTimeConfig config,
+            Network network, LaunchModeBuildItem launchMode) {
         DevServicesResultBuildItem dashboard = DevServicesResultBuildItem.owned()
                 .serviceName(DASHBOARD_WORKFLOW)
                 .feature(FEATURE)
                 .startable(new Supplier<Startable>() {
                     @Override
                     public Startable get() {
-                        return new DashboardContainerStartable(network);
+                        return new DashboardContainerStartable(network, launchMode.getLaunchMode(),
+                                config.dashboard().serviceName());
                     }
                 })
                 .dependsOnConfig(POSTGRESQL_PORT_PROPERTY, (Startable startable, String value) -> {
@@ -178,7 +246,8 @@ public Startable get() {
         return dashboard;
     }
 
-    private static DevServicesResultBuildItem configurePgsqlContainer(Network network) {
+    private static DevServicesResultBuildItem configurePgsqlContainer(Network network,
+            LaunchModeBuildItem launchMode) {
         return DevServicesResultBuildItem.owned()
                 .serviceName(STATESTORE_PG)
                 .feature(FEATURE)
@@ -189,7 +258,7 @@ private static DevServicesResultBuildItem configurePgsqlContainer(Network networ
                 .startable(new Supplier<Startable>() {
                     @Override
                     public Startable get() {
-                        return new StateStoreContainerStartable(network);
+                        return new StateStoreContainerStartable(network, launchMode.getLaunchMode());
                     }
                 })
                 .build();
diff --git a/deployment/src/main/java/io/quarkiverse/dapr/deployment/devservices/StateStoreContainerStartable.java b/deployment/src/main/java/io/quarkiverse/dapr/deployment/devservices/StateStoreContainerStartable.java
@@ -1,11 +1,14 @@
 package io.quarkiverse.dapr.deployment.devservices;
 
+import static io.quarkus.devservices.common.ConfigureUtil.configureSharedServiceLabel;
+
 import org.testcontainers.containers.Network;
 import org.testcontainers.postgresql.PostgreSQLContainer;
 import org.testcontainers.utility.DockerImageName;
 
 import io.quarkiverse.dapr.deployment.DaprProcessor;
 import io.quarkus.deployment.builditem.Startable;
+import io.quarkus.runtime.LaunchMode;
 
 public class StateStoreContainerStartable extends PostgreSQLContainer implements Startable {
 
@@ -15,14 +18,16 @@ public class StateStoreContainerStartable extends PostgreSQLContainer implements
     public static String USERNAME = POSTGRES;
     public static String PASSWORD = POSTGRES;
     public static String PGSQL_STATE_STORE = "kvstore";
+    static final String DEV_SERVICE_LABEL = "quarkus-dev-service-dapr-pgsql";
 
-    public StateStoreContainerStartable(Network network) {
+    public StateStoreContainerStartable(Network network, LaunchMode launchMode) {
         super(DockerImageName.parse("postgres"));
         super.withNetwork(network)
                 .withNetworkAliases(PGSQL_NETWORK_ALIAS)
                 .withDatabaseName(DaprProcessor.FEATURE)
                 .withUsername(USERNAME)
                 .withPassword(PASSWORD);
+        configureSharedServiceLabel(this, launchMode, DEV_SERVICE_LABEL, "dapr-pgsql");
     }
 
     @Override
diff --git a/deployment/src/test/java/io/quarkiverse/dapr/test/DaprDevServicesSharedContainerTest.java b/deployment/src/test/java/io/quarkiverse/dapr/test/DaprDevServicesSharedContainerTest.java
@@ -0,0 +1,115 @@
+package io.quarkiverse.dapr.test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+
+import io.dapr.config.Properties;
+import io.quarkus.deployment.builditem.DevServicesResultBuildItem;
+
+/**
+ * Regression tests for the shared-container feature.
+ *
+ * <h2>Background</h2>
+ * When a second application starts in dev-mode and finds an already-running Dapr container
+ * via {@code DAPR_CONTAINER_LOCATOR}, the processor used to call
+ * {@code DevServicesResultBuildItem.discovered().name(...).containerId(...).build()} without
+ * providing a config map.
+ * <p>
+ * The deprecated constructor that backs {@code DiscoveredServiceBuilder.build()} stores
+ * {@code this.config = config} as-is, so the {@code getConfig()} accessor returned
+ * {@code null}. Quarkus core's {@code DevServicesConfigBuildStep#setup} then called
+ * {@code newProperties.putAll(resultBuildItem.getConfig())} which threw:
+ *
+ * <pre>
+ * java.lang.NullPointerException: Cannot invoke "java.util.Map.size()" because "m" is null
+ *   at java.util.HashMap.putMapEntries
+ *   at io.quarkus.deployment.steps.DevServicesConfigBuildStep.setup(DevServicesConfigBuildStep.java:32)
+ * </pre>
+ *
+ * <h2>Fix</h2>
+ * The fix is to always call {@code .config(nonNullMap)} on the {@code DiscoveredServiceBuilder},
+ * populating it with the resolved Dapr HTTP- and gRPC-port values so the second application
+ * also receives them as runtime configuration.
+ */
+class DaprDevServicesSharedContainerTest {
+
+    /**
+     * Simulates what the processor does when it discovers a shared container.
+     * The produced {@code DevServicesResultBuildItem} must never expose a null config map,
+     * otherwise {@code DevServicesConfigBuildStep} will NPE.
+     */
+    @Test
+    void discoveredItemMustHaveNonNullConfigMap() {
+        int httpPort = 3500;
+        int grpcPort = 50001;
+
+        Map<String, String> portConfig = new HashMap<>();
+        portConfig.put(Properties.HTTP_PORT.getName(), Integer.toString(httpPort));
+        portConfig.put(Properties.GRPC_PORT.getName(), Integer.toString(grpcPort));
+
+        DevServicesResultBuildItem item = DevServicesResultBuildItem.discovered()
+                .name("dapr")
+                .containerId("abc123")
+                .config(java.util.Collections.unmodifiableMap(portConfig))
+                .build();
+
+        // getConfig() must never return null – putAll(null) would throw NPE
+        assertThat(item.getConfig())
+                .as("DevServicesResultBuildItem.getConfig() must not be null")
+                .isNotNull();
+    }
+
+    /**
+     * Verifies that the Dapr HTTP port is stored in the config map under the property name
+     * used by the Dapr SDK ({@link Properties#HTTP_PORT}).
+     */
+    @Test
+    void discoveredItemContainsHttpPortProperty() {
+        int httpPort = 13500;
+        int grpcPort = 60001;
+
+        Map<String, String> portConfig = new HashMap<>();
+        portConfig.put(Properties.HTTP_PORT.getName(), Integer.toString(httpPort));
+        portConfig.put(Properties.GRPC_PORT.getName(), Integer.toString(grpcPort));
+
+        DevServicesResultBuildItem item = DevServicesResultBuildItem.discovered()
+                .name("dapr")
+                .containerId("container-42")
+                .config(java.util.Collections.unmodifiableMap(portConfig))
+                .build();
+
+        assertThat(item.getConfig())
+                .containsEntry(Properties.HTTP_PORT.getName(), "13500")
+                .containsEntry(Properties.GRPC_PORT.getName(), "60001");
+    }
+
+    /**
+     * Emulates the exact line in {@code DevServicesConfigBuildStep#setup} that was crashing,
+     * to make the failure mode explicit and guarantee the fix prevents a regression.
+     */
+    @Test
+    void putAllOnDiscoveredItemConfigDoesNotThrowNpe() {
+        Map<String, String> portConfig = new HashMap<>();
+        portConfig.put(Properties.HTTP_PORT.getName(), "3500");
+        portConfig.put(Properties.GRPC_PORT.getName(), "50001");
+
+        DevServicesResultBuildItem item = DevServicesResultBuildItem.discovered()
+                .name("dapr")
+                .containerId("container-shared")
+                .config(java.util.Collections.unmodifiableMap(portConfig))
+                .build();
+
+        Map<String, String> aggregated = new HashMap<>();
+        // This is the exact operation that was NPE-ing in DevServicesConfigBuildStep:
+        assertThatCode(() -> aggregated.putAll(item.getConfig()))
+                .as("putAll(getConfig()) must not throw NullPointerException")
+                .doesNotThrowAnyException();
+
+        assertThat(aggregated).isNotEmpty();
+    }
+}
diff --git a/docs/modules/ROOT/pages/includes/quarkus-dapr.adoc b/docs/modules/ROOT/pages/includes/quarkus-dapr.adoc

Original file line number	Diff line number	Diff line change
`@@ -57,5 +57,13 @@ interface Dashboard {`
`57`	`57`	`@WithDefault("true")`
`58`	`58`	`Optional<Boolean> enabled();`
`59`	`59`
	`60`	`+ /**`
	`61`	`+ * The value of the {@code quarkus-dev-service-dapr-dashboard} label attached to the started container.`
	`62`	`+ * <p>`
	`63`	`+ * This is used to discover and re-use an existing shared Dapr Dashboard container.`
	`64`	`+ */`
	`65`	`+ @WithDefault("dapr-dashboard")`
	`66`	`+ String serviceName();`
	`67`	`+`
`60`	`68`	`}`
`61`	`69`	`}`