Reload POMs that have changed during dev mode

Author: aloubyansky

devtools/maven/src/main/java/io/quarkus/maven/DevMojo.java

@@ -1,6 +1,8 @@
 package io.quarkus.maven;
 
 import static io.quarkus.analytics.dto.segment.TrackEventType.DEV_MODE;
+import static io.quarkus.maven.QuarkusBootstrapMojo.CLOSE_BOOTSTRAPPED_APP_PARAM;
+import static io.quarkus.maven.QuarkusBootstrapMojo.MODE_PARAM;
 import static io.smallrye.common.expression.Expression.Flag.LENIENT_SYNTAX;
 import static io.smallrye.common.expression.Expression.Flag.NO_TRIM;
 import static java.util.Collections.emptyMap;
@@ -557,27 +559,31 @@ public void close() throws IOException {
                         }
                         return;
                     }
-                    final Set<Path> changed = new HashSet<>();
+                    List<String> changedPoms = List.of();
                     for (Map.Entry<Path, Long> e : pomFiles.entrySet()) {
                         long t = Files.getLastModifiedTime(e.getKey()).toMillis();
                         if (t > e.getValue()) {
-                            changed.add(e.getKey());
+                            if (changedPoms.isEmpty()) {
+                                // unless it's a git or some other command, there won't be many POMs modified in 100 milliseconds
+                                changedPoms = new ArrayList<>(1);
+                            }
+                            changedPoms.add(e.getKey().toString());
                             pomFiles.put(e.getKey(), t);
                         }
                     }
-                    if (!changed.isEmpty()) {
-                        getLog().info("Changes detected to " + changed + ", restarting dev mode");
+                    if (!changedPoms.isEmpty()) {
+                        logPomChanges(changedPoms);
 
                         // stop the runner before we build the new one as the debug port being free
                         // is tested when building the runner
                         runner.stop();
 
                         final DevModeRunner newRunner;
                         try {
-                            bootstrapId = handleAutoCompile();
+                            bootstrapId = handleAutoCompile(changedPoms);
                             newRunner = new DevModeRunner(runner.commandLine.getDebugPort(), bootstrapId);
                         } catch (Exception e) {
-                            getLog().info("Could not load changed pom.xml file, changes not applied", e);
+                            getLog().info("Could not load changedPoms pom.xml file, changes not applied", e);
                             continue;
                         }
                         newRunner.run();
@@ -590,6 +596,15 @@ public void close() throws IOException {
         }
     }
 
+    private void logPomChanges(List<String> changedPoms) {
+        final StringBuilder sb = new StringBuilder().append("Restarting dev mode following changes in ");
+        sb.append(changedPoms.get(0));
+        for (int i = 1; i < changedPoms.size(); ++i) {
+            sb.append(", ").append(changedPoms.get(i));
+        }
+        getLog().info(sb.toString());
+    }
+
     /**
      * if the process is forcibly killed then the terminal may be left in raw mode, which
      * messes everything up. This attempts to fix that by saving the state so it can be restored
@@ -649,7 +664,18 @@ private void restoreTerminalState() {
     }
 
     private String handleAutoCompile() throws MojoExecutionException {
+        return handleAutoCompile(List.of());
+    }
 
+    /**
+     * Invokes Maven project goals that are meant to be executed before quarkus:dev,
+     * unless they have already been executed.
+     *
+     * @param reloadPoms a list of POM files that should be reloaded from disk instead of read from the reactor
+     * @return bootstrap id
+     * @throws MojoExecutionException in case of an error
+     */
+    private String handleAutoCompile(List<String> reloadPoms) throws MojoExecutionException {
         List<String> goals = session.getGoals();
         // check for default goal(s) if none were specified explicitly,
         // see also org.apache.maven.lifecycle.internal.DefaultLifecycleTaskSegmentCalculator
@@ -761,10 +787,7 @@ private String handleAutoCompile() throws MojoExecutionException {
             }
         }
 
-        final Map<String, String> quarkusGoalParams = Map.of(
-                "mode", LaunchMode.DEVELOPMENT.name(),
-                QuarkusBootstrapMojo.CLOSE_BOOTSTRAPPED_APP, "false",
-                "bootstrapId", bootstrapId);
+        Map<String, String> quarkusGoalParams = null;
         for (int phaseIndex = latestHandledPhaseIndex + 1; phaseIndex < PRE_DEV_MODE_PHASES.size(); ++phaseIndex) {
             var executions = phaseExecutions.get(PRE_DEV_MODE_PHASES.get(phaseIndex));
             if (executions == null) {
@@ -774,6 +797,9 @@ private String handleAutoCompile() throws MojoExecutionException {
                 var executedGoals = executedPluginGoals.getOrDefault(pe.plugin.getId(), List.of());
                 for (String goal : pe.execution.getGoals()) {
                     if (!executedGoals.contains(goal)) {
+                        if (quarkusGoalParams == null) {
+                            quarkusGoalParams = getQuarkusGoalParams(bootstrapId, reloadPoms);
+                        }
                         try {
                             executeGoal(pe, goal,
                                     pe.getPluginId().equals(quarkusPluginId) ? quarkusGoalParams : Map.of());
@@ -793,6 +819,35 @@ private String handleAutoCompile() throws MojoExecutionException {
         return bootstrapId;
     }
 
+    /**
+     * Returns a map of parameters for the Quarkus plugin goals to be invoked.
+     *
+     * @param bootstrapId bootstrap id
+     * @param reloadPoms POM files to be reloaded from disk instead of taken from the reactor
+     * @return map of parameters for the Quarkus plugin goals
+     */
+    private static Map<String, String> getQuarkusGoalParams(String bootstrapId, List<String> reloadPoms) {
+        final Map<String, String> result = new HashMap<>(4);
+        result.put(QuarkusBootstrapMojo.MODE_PARAM, LaunchMode.DEVELOPMENT.name());
+        result.put(QuarkusBootstrapMojo.CLOSE_BOOTSTRAPPED_APP_PARAM, "false");
+        result.put(QuarkusBootstrapMojo.BOOTSTRAP_ID_PARAM, bootstrapId);
+        if (reloadPoms != null && !reloadPoms.isEmpty()) {
+            String reloadPomsStr;
+            if (reloadPoms.size() == 1) {
+                reloadPomsStr = reloadPoms.get(0);
+            } else {
+                final StringBuilder sb = new StringBuilder();
+                sb.append(reloadPoms.get(0));
+                for (int i = 1; i < reloadPoms.size(); ++i) {
+                    sb.append(",").append(reloadPoms.get(i));
+                }
+                reloadPomsStr = sb.toString();
+            }
+            result.put(QuarkusBootstrapMojo.RELOAD_POMS_PARAM, reloadPomsStr);
+        }
+        return result;
+    }
+
     private String getCurrentGoal() {
         return mojoExecution.getMojoDescriptor().getPluginDescriptor().getGoalPrefix() + ":"
                 + mojoExecution.getGoal();
@@ -1004,7 +1059,7 @@ && matchesExecution(executionId, exec.getId())) {
             }
         }
 
-        if ((Xpp3Dom) plugin.getConfiguration() != null) {
+        if (plugin.getConfiguration() != null) {
             mergedConfig = mergedConfig == null ? (Xpp3Dom) plugin.getConfiguration()
                     : Xpp3Dom.mergeXpp3Dom(mergedConfig, (Xpp3Dom) plugin.getConfiguration(), true);
         }
@@ -1300,17 +1355,15 @@ void run() throws Exception {
             process = processBuilder.start();
 
             //https://github.com/quarkusio/quarkus/issues/232
-            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    process.destroy();
-                    try {
-                        process.waitFor();
-                    } catch (InterruptedException e) {
-                        getLog().warn("Unable to properly wait for dev-mode end", e);
-                    }
-                }
-            }, "Development Mode Shutdown Hook"));
+            Runtime.getRuntime().addShutdownHook(new Thread(this::safeStop, "Development Mode Shutdown Hook"));
+        }
+
+        private void safeStop() {
+            try {
+                stop();
+            } catch (InterruptedException e) {
+                getLog().warn("Unable to properly wait for dev-mode end", e);
+            }
         }
 
         void stop() throws InterruptedException {
@@ -1467,7 +1520,7 @@ private DevModeCommandLine newLauncher(String actualDebugPort, String bootstrapI
                     .setRootProjectDir(rootProjectDir);
 
             // There are a couple of reasons we don't want to use the original Maven session:
-            // 1) a reload could be triggered by a change in a pom.xml, in which case the Maven session might not be in sync any more with the effective POM;
+            // 1) a reload could be triggered by a change in a pom.xml, in which case the Maven session might not be in sync anymore with the effective POM;
             // 2) in case there is a local module that has a snapshot version, which is also available in a remote snapshot repository,
             // the Maven resolver will be checking for newer snapshots in the remote repository and might end up resolving the artifact from there.
             final BootstrapMavenContext mvnCtx = workspaceProvider.createMavenContext(mvnConfig);

devtools/maven/src/main/java/io/quarkus/maven/QuarkusBootstrapMojo.java

@@ -8,6 +8,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Properties;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
@@ -36,7 +37,10 @@
 
 public abstract class QuarkusBootstrapMojo extends AbstractMojo {
 
-    static final String CLOSE_BOOTSTRAPPED_APP = "closeBootstrappedApp";
+    static final String BOOTSTRAP_ID_PARAM = "bootstrapId";
+    static final String CLOSE_BOOTSTRAPPED_APP_PARAM = "closeBootstrappedApp";
+    static final String MODE_PARAM = "mode";
+    static final String RELOAD_POMS_PARAM = "reloadPoms";
 
     static final String NATIVE_PROFILE_NAME = "native";
 
@@ -158,7 +162,14 @@ public abstract class QuarkusBootstrapMojo extends AbstractMojo {
      * Whether to close the bootstrapped applications after the execution
      */
     @Parameter(property = "quarkusCloseBootstrappedApp")
-    private Boolean closeBootstrappedApp;
+    Boolean closeBootstrappedApp;
+
+    /**
+     * POM files from the workspace that should be reloaded from the disk instead of taken from the Maven reactor.
+     * This parameter is not supposed to be configured by a user.
+     */
+    @Parameter(property = "reloadPoms")
+    Set<File> reloadPoms = Set.of();
 
     private ArtifactKey projectId;
 

devtools/maven/src/main/java/io/quarkus/maven/QuarkusBootstrapProvider.java

@@ -6,8 +6,6 @@
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
-import java.nio.file.Path;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -21,7 +19,6 @@
 import javax.inject.Singleton;
 
 import org.apache.maven.artifact.Artifact;
-import org.apache.maven.execution.MavenSession;
 import org.apache.maven.model.Model;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.project.MavenProject;
@@ -80,25 +77,25 @@ static ArtifactKey getProjectId(MavenProject project) {
         return ArtifactKey.ga(project.getGroupId(), project.getArtifactId());
     }
 
-    static Map<Path, Model> getProjectMap(MavenSession session) {
-        final List<MavenProject> allProjects = session.getAllProjects();
-        if (allProjects == null) {
-            return Map.of();
-        }
-        final Map<Path, Model> projectModels = new HashMap<>(allProjects.size());
-        for (MavenProject mp : allProjects) {
-            final Model model = getRawModel(mp);
-            projectModels.put(mp.getFile().toPath(), model);
-            // The Maven Model API determines the project directory as the directory containing the POM file.
-            // However, in case when plugins manipulating POMs store their results elsewhere
-            // (such as the flatten plugin storing the flattened POM under the target directory),
-            // both the base directory and the directory containing the POM file should be added to the map.
-            var pomDir = mp.getFile().getParentFile();
-            if (!pomDir.equals(mp.getBasedir())) {
-                projectModels.put(mp.getBasedir().toPath().resolve("pom.xml"), model);
+    static void setProjectModels(QuarkusBootstrapMojo mojo, BootstrapMavenContextConfig<?> config) {
+        final List<MavenProject> allProjects = mojo.mavenSession().getAllProjects();
+        if (allProjects != null) {
+            for (MavenProject mp : allProjects) {
+                if (mojo.reloadPoms.contains(mp.getFile())) {
+                    continue;
+                }
+                final Model model = getRawModel(mp);
+                config.addProvidedModule(mp.getFile().toPath(), model, mp.getModel());
+                // The Maven Model API determines the project directory as the directory containing the POM file.
+                // However, in case when plugins manipulating POMs store their results elsewhere
+                // (such as the flatten plugin storing the flattened POM under the target directory),
+                // both the base directory and the directory containing the POM file should be added to the map.
+                var pomDir = mp.getFile().getParentFile();
+                if (!pomDir.equals(mp.getBasedir())) {
+                    config.addProvidedModule(mp.getBasedir().toPath().resolve("pom.xml"), model, mp.getModel());
+                }
             }
         }
-        return projectModels;
     }
 
     /**
@@ -123,8 +120,6 @@ private static Model getRawModel(MavenProject mp) {
             model.setDependencies(mp.getDependencies());
         }
         model.setPomFile(mp.getFile());
-        // activated profiles or custom extensions may have overridden the build defaults
-        model.setBuild(mp.getModel().getBuild());
         return model;
     }
 
@@ -227,18 +222,18 @@ public class QuarkusMavenAppBootstrap implements Closeable {
         private MavenArtifactResolver artifactResolver(QuarkusBootstrapMojo mojo, LaunchMode mode) {
             try {
                 if (mode == LaunchMode.DEVELOPMENT || mode == LaunchMode.TEST || isWorkspaceDiscovery(mojo)) {
-                    var resolver = workspaceProvider.createArtifactResolver(
-                            BootstrapMavenContext.config()
-                                    // it's important to pass user settings in case the process was not launched using the original mvn script
-                                    // for example using org.codehaus.plexus.classworlds.launcher.Launcher
-                                    .setUserSettings(mojo.mavenSession().getRequest().getUserSettingsFile())
-                                    .setCurrentProject(mojo.mavenProject().getFile().toString())
-                                    .setPreferPomsFromWorkspace(true)
-                                    .setProjectModelProvider(getProjectMap(mojo.mavenSession()))
-                                    // pass the repositories since Maven extensions could manipulate repository configs
-                                    .setRemoteRepositories(mojo.remoteRepositories())
-                                    .setEffectiveModelBuilder(BootstrapMavenContextConfig
-                                            .getEffectiveModelBuilderProperty(mojo.mavenProject().getProperties())));
+                    final BootstrapMavenContextConfig<?> config = BootstrapMavenContext.config()
+                            // it's important to pass user settings in case the process was not launched using the original mvn script,
+                            // for example, using org.codehaus.plexus.classworlds.launcher.Launcher
+                            .setUserSettings(mojo.mavenSession().getRequest().getUserSettingsFile())
+                            .setCurrentProject(mojo.mavenProject().getFile().toString())
+                            .setPreferPomsFromWorkspace(true)
+                            // pass the repositories since Maven extensions could manipulate repository configs
+                            .setRemoteRepositories(mojo.remoteRepositories())
+                            .setEffectiveModelBuilder(BootstrapMavenContextConfig
+                                    .getEffectiveModelBuilderProperty(mojo.mavenProject().getProperties()));
+                    setProjectModels(mojo, config);
+                    var resolver = workspaceProvider.createArtifactResolver(config);
                     final LocalProject currentProject = resolver.getMavenContext().getCurrentProject();
                     if (currentProject != null && workspaceId == 0) {
                         workspaceId = currentProject.getWorkspace().getId();

independent-projects/bootstrap/core/src/main/java/io/quarkus/bootstrap/BootstrapAppModelFactory.java

@@ -171,9 +171,9 @@ private BootstrapAppModelResolver initAppModelResolver(MavenArtifactResolver art
                 .setDevMode(devMode);
         var project = artifactResolver.getMavenContext().getCurrentProject();
         if (project != null) {
-            final Properties modelProps = project.getModelBuildingResult() == null
+            final Properties modelProps = project.getEffectiveModel() == null
                     ? project.getRawModel().getProperties()
-                    : project.getModelBuildingResult().getEffectiveModel().getProperties();
+                    : project.getEffectiveModel().getProperties();
             appModelResolver.setLegacyModelResolver(BootstrapAppModelResolver.isLegacyModelResolver(modelProps));
         }
         return appModelResolver;

independent-projects/bootstrap/maven-resolver/src/main/java/io/quarkus/bootstrap/resolver/maven/BootstrapMavenContext.java

@@ -77,6 +77,7 @@
 import io.quarkus.bootstrap.resolver.maven.workspace.LocalProject;
 import io.quarkus.bootstrap.resolver.maven.workspace.LocalWorkspace;
 import io.quarkus.bootstrap.resolver.maven.workspace.ModelUtils;
+import io.quarkus.bootstrap.resolver.maven.workspace.WorkspaceModulePom;
 import io.quarkus.bootstrap.util.PropertyUtils;
 import io.quarkus.maven.dependency.ArtifactCoords;
 import io.smallrye.beanbag.maven.MavenFactory;
@@ -194,7 +195,7 @@ public BootstrapMavenContext(BootstrapMavenContextConfig<?> config)
             this.currentPom = currentProject.getRawModel().getPomFile().toPath();
             this.workspace = config.currentProject.getWorkspace();
         } else if (config.workspaceDiscovery) {
-            currentProject = resolveCurrentProject(config.modelProvider);
+            currentProject = resolveCurrentProject(config.providedModules);
             this.workspace = currentProject == null ? null : currentProject.getWorkspace();
             if (workspace != null) {
                 if (config.repoSession == null && repoSession != null && repoSession.getWorkspaceReader() == null) {
@@ -377,9 +378,9 @@ private boolean getLocalRepoTailIgnoreAvailability() {
                 : localRepoTailIgnoreAvailability;
     }
 
-    private LocalProject resolveCurrentProject(Map<Path, Model> modelProvider) throws BootstrapMavenException {
+    private LocalProject resolveCurrentProject(List<WorkspaceModulePom> providedModules) throws BootstrapMavenException {
         try {
-            return LocalProject.loadWorkspace(this, modelProvider);
+            return LocalProject.loadWorkspace(this, providedModules);
         } catch (Exception e) {
             throw new BootstrapMavenException("Failed to load current project at " + getCurrentProjectPomOrNull(), e);
         }