You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by gn...@apache.org on 2026/09/19 19:58:15 UTC

(maven) branch master updated: Fix #13190: pre-build full reactor once using BUILD_PROJECT, drop temp dir in PluginUpgradeStrategy

This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/master by this push:
     new a98d8fa111 Fix #13190: pre-build full reactor once using BUILD_PROJECT, drop temp dir in PluginUpgradeStrategy
a98d8fa111 is described below

commit a98d8fa111f76d2486a06bb6e263f6c1b822dfcc
Author: Guillaume Nodet <gn...@gmail.com>
AuthorDate: Sat Sep 19 21:58:10 2026 +0200

    Fix #13190: pre-build full reactor once using BUILD_PROJECT, drop temp dir in PluginUpgradeStrategy
    
    Fix #13190: pre-build full reactor once using BUILD_PROJECT, drop temp dir in PluginUpgradeStrategy
    
    - AbstractUpgradeStrategy.apply() now calls prebuildReactorModels() before doApply() to populate effectiveModelCache via a single BUILD_PROJECT request with recursive(true)
    - Eliminates per-POM fresh sessions whose empty mappedSources caused coordinate inference (inferParentVersion, inferDependencyVersion, inferDependencyGroupId) to silently return null
    - Enables profile activation (file/property/condition-activated profiles) that BUILD_EFFECTIVE skips
    - Split isFilesystemRequest() from isBuildRequest() for clearer semantics at call sites (strict XML parsing, pomFile stamping, relativePath computation, findLocalParent, transformFileToRaw)
    - Remove temporary directory creation in PluginUpgradeStrategy (was only needed as a workaround for the per-POM session approach)
    - Add unit tests for prebuildReactorModels() covering single-module and multi-module scenarios
---
 .../mvnup/goals/AbstractUpgradeStrategy.java       | 216 +++++++++++++++++----
 .../invoker/mvnup/goals/PluginUpgradeStrategy.java |  77 ++++----
 .../mvnup/goals/AbstractUpgradeStrategyTest.java   | 124 ++++++++++++
 .../mvnup/goals/PluginUpgradeStrategyTest.java     | 170 +++++++++-------
 4 files changed, 431 insertions(+), 156 deletions(-)

diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/AbstractUpgradeStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/AbstractUpgradeStrategy.java
index 94bfcd8d22..7072ce21bb 100644
--- a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/AbstractUpgradeStrategy.java
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/AbstractUpgradeStrategy.java
@@ -18,14 +18,12 @@
  */
 package org.apache.maven.cling.invoker.mvnup.goals;
 
-import java.io.File;
-import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Stream;
 
 import eu.maveniverse.domtrip.Document;
 import eu.maveniverse.domtrip.Element;
@@ -35,6 +33,7 @@
 import org.apache.maven.api.cli.mvnup.UpgradeOptions;
 import org.apache.maven.api.di.Inject;
 import org.apache.maven.api.di.Named;
+import org.apache.maven.api.model.Model;
 import org.apache.maven.api.services.ModelBuilder;
 import org.apache.maven.api.services.ModelBuilderRequest;
 import org.apache.maven.api.services.ModelBuilderResult;
@@ -56,6 +55,32 @@
  * // ... perform domtrip operations ...
  * // Document is automatically updated
  * </pre>
+ *
+ * <h2>Effective model building</h2>
+ *
+ * <p>Each {@link #apply} call pre-builds effective models for the whole reactor
+ * in a single {@code BUILD_PROJECT} pass via {@link #prebuildReactorModels}.
+ * This ensures that:
+ * <ul>
+ *   <li>Profile activation (file, property, condition) works correctly — not just
+ *       OS/JDK/activeByDefault profiles;</li>
+ *   <li>Maven 4 coordinate inference ({@code version}/{@code groupId} from reactor
+ *       siblings) works because {@code mappedSources} is populated for the whole
+ *       reactor before any individual POM is resolved;</li>
+ *   <li>Remote parent resolution shares a single model-builder session, so artifacts
+ *       fetched for one module are not re-fetched for siblings.</li>
+ * </ul>
+ *
+ * <p>The resulting {@code Map<Path, Model>} cache is stored in
+ * {@link #effectiveModelCache} and consulted by {@link #buildEffectiveModel}.
+ * For paths not in the cache (external parents reached during a parent-walk),
+ * a fallback {@code BUILD_EFFECTIVE} call is made on the same
+ * {@link ModelBuilder.ModelBuilderSession}, which still benefits from the
+ * already-populated {@code mappedSources}.</p>
+ *
+ * <p>Both the cache and the session are reset to {@code null} in the {@code finally}
+ * block of {@link #apply} so that singleton strategy instances do not leak state
+ * across invocations or test runs.</p>
  */
 public abstract class AbstractUpgradeStrategy implements UpgradeStrategy {
 
@@ -68,15 +93,38 @@ public abstract class AbstractUpgradeStrategy implements UpgradeStrategy {
      *
      * <p>When running outside a DI container (e.g. unit tests), this field is {@code null}
      * and {@link #getSession()} falls back to creating a session via
-     * {@link MvnupSessionHolder#createSession()}.
+     * {@link MvnupSessionHolder#createSession()}.</p>
      */
     @Inject
     @Named("mvnup")
     private Session session;
 
+    /**
+     * Cache of effective models pre-built by {@link #prebuildReactorModels}.
+     * Keys are the absolute, normalised POM paths from {@code pomMap}.
+     * Reset to {@code null} at the end of each {@link #apply} call.
+     */
+    private Map<Path, Model> effectiveModelCache;
+
+    /**
+     * Shared model-builder session kept alive for the duration of one {@link #apply}
+     * call. Created by {@link #prebuildReactorModels} (which uses it for the
+     * {@code BUILD_PROJECT} pass) and reused by the {@code BUILD_EFFECTIVE} fallback
+     * in {@link #buildEffectiveModel}. Reusing the same session means the
+     * {@code mappedSources} map accumulated during the reactor build is available for
+     * subsequent individual calls, so cross-module inference keeps working for any
+     * POM that was not part of the original reactor (e.g. an external parent).
+     * Reset to {@code null} at the end of each {@link #apply} call.
+     */
+    private ModelBuilder.ModelBuilderSession sharedModelBuilderSession;
+
     /**
      * Template method that handles common logging and error handling.
      * Subclasses implement the actual upgrade logic in doApply().
+     *
+     * <p>Before delegating to {@link #doApply}, pre-builds effective models for every
+     * POM in {@code pomMap} via a single {@code BUILD_PROJECT} reactor pass so that
+     * {@link #buildEffectiveModel} can serve from cache for the common case.</p>
      */
     @Override
     public final UpgradeResult apply(UpgradeContext context, Map<Path, Document> pomMap) {
@@ -84,6 +132,7 @@ public final UpgradeResult apply(UpgradeContext context, Map<Path, Document> pom
         context.indent();
 
         try {
+            prebuildReactorModels(context, pomMap.keySet());
             UpgradeResult result = doApply(context, pomMap);
 
             // Log summary
@@ -94,10 +143,89 @@ public final UpgradeResult apply(UpgradeContext context, Map<Path, Document> pom
             context.failure("Strategy execution failed: " + e.getMessage());
             return UpgradeResult.failure(pomMap.keySet(), Set.of());
         } finally {
+            effectiveModelCache = null;
+            sharedModelBuilderSession = null;
             context.unindent();
         }
     }
 
+    /**
+     * Pre-builds effective models for every POM in the reactor with a single
+     * {@code BUILD_PROJECT} pass and stores them in {@link #effectiveModelCache}.
+     *
+     * <p>{@code BUILD_PROJECT} is used because it:
+     * <ul>
+     *   <li>calls {@code loadFromRoot}, which populates {@code mappedSources} for the
+     *       whole reactor before any single effective model is assembled — this is what
+     *       makes Maven 4 coordinate inference work across modules;</li>
+     *   <li>applies full profile activation (file, property, condition) rather than
+     *       the reduced set used by {@code BUILD_CONSUMER};</li>
+     *   <li>produces child results (via {@code getChildren()}) when {@code recursive=true}
+     *       is set on the request, mapping 1-to-1 to the reactor modules — this lets the
+     *       cache be populated in a single pass without additional per-module requests;</li>
+     * </ul>
+     *
+     * <p>The root POM is identified as the shallowest (fewest name parts) path in
+     * {@code pomPaths}.</p>
+     *
+     * <p>If the build fails (e.g. the project has no network access and an external
+     * parent cannot be resolved), the cache is left empty and
+     * {@link #buildEffectiveModel} falls back to individual {@code BUILD_EFFECTIVE}
+     * calls.</p>
+     *
+     * @param context  the upgrade context (used for debug/warning logging)
+     * @param pomPaths the set of POM paths that make up the reactor
+     */
+    private void prebuildReactorModels(UpgradeContext context, Set<Path> pomPaths) {
+        if (pomPaths.isEmpty()) {
+            return;
+        }
+        Session s = getSession();
+        ModelBuilder modelBuilder = s.getService(ModelBuilder.class);
+        sharedModelBuilderSession = modelBuilder.newSession();
+
+        // Use the shallowest path as the root (fewest name elements).
+        Path rootPom = pomPaths.stream()
+                .min(java.util.Comparator.comparingInt(Path::getNameCount))
+                .orElseThrow();
+
+        context.debug("Pre-building reactor effective models from root: " + rootPom);
+
+        try {
+            ModelBuilderRequest request = ModelBuilderRequest.builder()
+                    .session(s)
+                    .source(Sources.buildSource(rootPom))
+                    .requestType(ModelBuilderRequest.RequestType.BUILD_PROJECT)
+                    .recursive(true)
+                    .build();
+
+            ModelBuilderResult result = sharedModelBuilderSession.build(request);
+
+            // Walk the result tree and populate the cache.
+            Map<Path, Model> cache = new HashMap<>();
+            allResults(result).forEach(r -> {
+                Path path = r.getSource().getPath();
+                if (path != null) {
+                    cache.put(path.toAbsolutePath().normalize(), r.getEffectiveModel());
+                }
+            });
+            effectiveModelCache = cache;
+            context.debug("Reactor pre-build complete: cached " + cache.size() + " effective model(s)");
+
+        } catch (Exception e) {
+            context.warning("Reactor pre-build failed, falling back to per-POM resolution: " + e.getMessage());
+            context.debug("Reactor pre-build exception detail: " + e);
+            effectiveModelCache = new HashMap<>();
+        }
+    }
+
+    /**
+     * Recursively flattens a {@link ModelBuilderResult} tree (root + all descendants).
+     */
+    private static Stream<ModelBuilderResult> allResults(ModelBuilderResult root) {
+        return Stream.concat(Stream.of(root), root.getChildren().stream().flatMap(AbstractUpgradeStrategy::allResults));
+    }
+
     /**
      * Subclasses implement the actual upgrade logic here.
      *
@@ -275,28 +403,6 @@ protected static String remoteResolutionUnsupportedReason(UpgradeContext context
         return null;
     }
 
-    protected Path createTempProjectStructure(UpgradeContext context, Map<Path, Document> pomMap) throws Exception {
-        Path tempDir = Files.createTempDirectory("mvnup-project-");
-        context.debug("Created temp project directory: " + tempDir);
-
-        Path commonRoot = findCommonRoot(pomMap.keySet());
-        context.debug("Common root: " + commonRoot);
-
-        for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
-            Path originalPath = entry.getKey();
-            Document document = entry.getValue();
-
-            Path relativePath = commonRoot.relativize(originalPath);
-            Path tempPomPath = tempDir.resolve(relativePath);
-
-            Files.createDirectories(tempPomPath.getParent());
-            Files.writeString(tempPomPath, document.toXml());
-            context.debug("Wrote POM to temp location: " + tempPomPath);
-        }
-
-        return tempDir;
-    }
-
     protected Path findCommonRoot(Set<Path> pomPaths) {
         Path commonRoot = null;
         for (Path pomPath : pomPaths) {
@@ -318,29 +424,55 @@ protected Path findCommonRoot(Set<Path> pomPaths) {
         return commonRoot;
     }
 
-    protected void cleanupTempDirectory(Path tempDir) {
-        try {
-            Files.walk(tempDir)
-                    .sorted(Comparator.reverseOrder())
-                    .map(Path::toFile)
-                    .forEach(File::delete);
-        } catch (Exception e) {
-            // Best effort cleanup
+    /**
+     * Returns the effective model for the given POM path.
+     *
+     * <p>Consults {@link #effectiveModelCache} first (populated by the {@code BUILD_PROJECT}
+     * reactor pass in {@link #prebuildReactorModels}). If the path is not in the cache
+     * (e.g. an external parent that was not part of the reactor), falls back to a
+     * {@code BUILD_EFFECTIVE} call on {@link #sharedModelBuilderSession}, which still
+     * benefits from the {@code mappedSources} populated during the reactor build.</p>
+     *
+     * @param context the upgrade context (used for debug logging)
+     * @param pomPath the path to the POM file
+     * @return the effective model, never {@code null}
+     */
+    protected Model buildEffectiveModel(UpgradeContext context, Path pomPath) {
+        Path key = pomPath.toAbsolutePath().normalize();
+
+        // Fast path: reactor pre-build already has this model.
+        Map<Path, Model> cache = effectiveModelCache;
+        if (cache != null) {
+            Model cached = cache.get(key);
+            if (cached != null) {
+                context.debug("Effective model cache hit: " + pomPath);
+                return cached;
+            }
         }
-    }
 
-    protected org.apache.maven.api.model.Model buildEffectiveModel(UpgradeContext context, Path pomPath) {
-        Session session = getSession();
-        ModelBuilder modelBuilder = session.getService(ModelBuilder.class);
+        // Fallback: individual BUILD_EFFECTIVE on the shared session (inherits mappedSources).
+        context.debug("Effective model cache miss, building individually: " + pomPath);
+        Session s = getSession();
+        ModelBuilder modelBuilder = s.getService(ModelBuilder.class);
+
+        if (sharedModelBuilderSession == null) {
+            sharedModelBuilderSession = modelBuilder.newSession();
+        }
 
         ModelBuilderRequest request = ModelBuilderRequest.builder()
-                .session(session)
+                .session(s)
                 .source(Sources.buildSource(pomPath))
                 .requestType(ModelBuilderRequest.RequestType.BUILD_EFFECTIVE)
-                .recursive(false)
                 .build();
 
-        ModelBuilderResult result = modelBuilder.newSession().build(request);
-        return result.getEffectiveModel();
+        ModelBuilderResult result = sharedModelBuilderSession.build(request);
+        Model model = result.getEffectiveModel();
+
+        // Populate cache for potential subsequent calls to the same path.
+        if (cache != null) {
+            cache.put(key, model);
+        }
+
+        return model;
     }
 }
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategy.java
index b8e782bb3a..4ecda47dec 100644
--- a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategy.java
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategy.java
@@ -226,18 +226,13 @@ public UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap)
         Set<Path> errorPoms = new HashSet<>();
 
         try {
-            // Phase 1: Write all modifications to temp directory (keeping project structure)
-            Path tempDir = createTempProjectStructure(context, pomMap);
-
-            // Phase 2: For each POM, build effective model using the session and analyze plugins.
-            // Skip when the operator's settings declare a repository posture the standalone
-            // resolver cannot honor (mirrors, proxies, offline): resolving outside that
-            // posture would bypass the operator's configuration, so the remote-model-dependent
-            // analysis is skipped instead.
+            // Analyze plugins using effective models built from the original POMs.
+            // PluginUpgradeStrategy runs first (@Priority(10)), so pomMap is identical
+            // to the on-disk project; no temporary copy is needed.
             PluginAnalysisResults analysisResults;
             String unsupportedReason = remoteResolutionUnsupportedReason(context);
             if (unsupportedReason == null) {
-                analysisResults = analyzePluginsUsingEffectiveModels(context, pomMap, tempDir);
+                analysisResults = analyzePluginsUsingEffectiveModels(context, pomMap);
             } else {
                 context.warning("Skipping effective-model plugin analysis: " + unsupportedReason);
                 analysisResults = new PluginAnalysisResults(Map.of(), Map.of());
@@ -294,11 +289,8 @@ public UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap)
                 }
             }
 
-            // Clean up temp directory
-            cleanupTempDirectory(tempDir);
-
         } catch (Exception e) {
-            context.failure("Failed to create temp project structure: " + e.getMessage());
+            context.failure("Failed to analyze plugins: " + e.getMessage());
             // Mark all POMs as errors
             errorPoms.addAll(pomMap.keySet());
         }
@@ -568,12 +560,28 @@ private boolean upgradePropertyVersion(
             return false; // Found in current POM, no upgrade needed
         }
 
-        // Property not in current POM - search other POMs in the project (e.g., parent POM)
+        // Property not in current POM - search other POMs in the project (potential parents only).
+        // Restrict to POMs whose path is an ancestor directory of the current POM to avoid
+        // mutating sibling or child POMs that happen to define the same property.
+        Path currentPomPath = pomMap.entrySet().stream()
+                .filter(e -> e.getValue() == pomDocument)
+                .map(Map.Entry::getKey)
+                .findFirst()
+                .orElse(null);
+        Path currentDir = currentPomPath != null ? currentPomPath.getParent() : null;
+
         for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
             Document otherDoc = entry.getValue();
             if (otherDoc == pomDocument) {
                 continue; // Skip the current POM, already checked
             }
+            // Only search POMs in ancestor directories (potential Maven parents), not siblings/children.
+            if (currentDir != null) {
+                Path candidateDir = entry.getKey().getParent();
+                if (candidateDir == null || !currentDir.startsWith(candidateDir)) {
+                    continue;
+                }
+            }
             if (upgradePropertyInDocument(otherDoc, propertyName, upgrade, sectionName, context)) {
                 return true;
             }
@@ -804,7 +812,7 @@ public static List<PluginUpgrade> getPluginUpgrades() {
      * plugins needing pluginManagement entries and plugins needing direct build/plugins overrides.
      */
     private PluginAnalysisResults analyzePluginsUsingEffectiveModels(
-            UpgradeContext context, Map<Path, Document> pomMap, Path tempDir) {
+            UpgradeContext context, Map<Path, Document> pomMap) {
         Map<Path, Set<String>> managementResult = new HashMap<>();
         Map<Path, Set<String>> directOverrideResult = new HashMap<>();
         Map<String, PluginUpgrade> basePluginUpgrades = getPluginUpgradesAsMap();
@@ -828,16 +836,11 @@ private PluginAnalysisResults analyzePluginsUsingEffectiveModels(
             Path originalPomPath = entry.getKey();
 
             try {
-                // Find the corresponding temp POM path
-                Path commonRoot = findCommonRoot(pomMap.keySet());
-                Path relativePath = commonRoot.relativize(originalPomPath);
-                Path tempPomPath = tempDir.resolve(relativePath);
-
                 // Per-module check: if this POM or any of its local parent POMs
                 // has shade-plugin with custom transformers, exclude shade-plugin
                 // from upgrades for this module only
                 Map<String, PluginUpgrade> pluginUpgrades = basePluginUpgrades;
-                if (hasCustomTransformersInPomOrParents(context, originalPomPath, pomMap, tempDir, commonRoot)) {
+                if (hasCustomTransformersInPomOrParents(context, originalPomPath, pomMap)) {
                     pluginUpgrades = new HashMap<>(basePluginUpgrades);
                     pluginUpgrades.remove(shadePluginKey);
                     context.warning("Skipping maven-shade-plugin in effective-model analysis for " + originalPomPath
@@ -846,11 +849,10 @@ private PluginAnalysisResults analyzePluginsUsingEffectiveModels(
 
                 // Build effective model using Maven 4 API
                 PluginAnalysis analysis =
-                        analyzeEffectiveModelForPlugins(context, tempPomPath, pluginUpgrades, projectJdk);
+                        analyzeEffectiveModelForPlugins(context, originalPomPath, pluginUpgrades, projectJdk);
 
                 // Determine where to add plugin management (last local parent)
-                Path targetPom =
-                        findLastLocalParentForPluginManagement(context, tempPomPath, pomMap, tempDir, commonRoot);
+                Path targetPom = findLastLocalParentForPluginManagement(context, originalPomPath, pomMap);
 
                 if (targetPom != null) {
                     managementResult
@@ -884,7 +886,7 @@ private PluginAnalysisResults analyzePluginsUsingEffectiveModels(
      * This is a per-module check, unlike a global check across all POMs.
      */
     private boolean hasCustomTransformersInPomOrParents(
-            UpgradeContext context, Path pomPath, Map<Path, Document> pomMap, Path tempDir, Path commonRoot) {
+            UpgradeContext context, Path pomPath, Map<Path, Document> pomMap) {
         // Check the current POM
         Document doc = pomMap.get(pomPath);
         if (doc != null && hasCustomTransformersInDocument(doc)) {
@@ -894,8 +896,7 @@ private boolean hasCustomTransformersInPomOrParents(
         // Walk up the parent hierarchy within the local pomMap
         if (doc != null) {
             try {
-                Path tempPomPath = tempDir.resolve(commonRoot.relativize(pomPath));
-                Model effectiveModel = buildEffectiveModel(context, tempPomPath);
+                Model effectiveModel = buildEffectiveModel(context, pomPath);
                 Model currentModel = effectiveModel;
 
                 while (currentModel.getParent() != null) {
@@ -906,8 +907,7 @@ private boolean hasCustomTransformersInPomOrParents(
                         if (parentDoc != null && hasCustomTransformersInDocument(parentDoc)) {
                             return true;
                         }
-                        Path parentTempPath = tempDir.resolve(commonRoot.relativize(parentPath));
-                        currentModel = buildEffectiveModel(context, parentTempPath);
+                        currentModel = buildEffectiveModel(context, parentPath);
                     } else {
                         break;
                     }
@@ -969,8 +969,8 @@ private Map<String, PluginUpgrade> getPluginUpgradesAsMap() {
     }
 
     private PluginAnalysis analyzeEffectiveModelForPlugins(
-            UpgradeContext context, Path tempPomPath, Map<String, PluginUpgrade> pluginUpgrades, int projectJdk) {
-        Model effectiveModel = buildEffectiveModel(context, tempPomPath);
+            UpgradeContext context, Path pomPath, Map<String, PluginUpgrade> pluginUpgrades, int projectJdk) {
+        Model effectiveModel = buildEffectiveModel(context, pomPath);
         return analyzePluginsFromEffectiveModel(context, effectiveModel, pluginUpgrades, projectJdk);
     }
 
@@ -1085,16 +1085,12 @@ private String getPluginKey(Plugin plugin) {
      * that's the target.
      */
     private Path findLastLocalParentForPluginManagement(
-            UpgradeContext context, Path tempPomPath, Map<Path, Document> pomMap, Path tempDir, Path commonRoot) {
-
-        Model effectiveModel = buildEffectiveModel(context, tempPomPath);
+            UpgradeContext context, Path pomPath, Map<Path, Document> pomMap) {
 
-        // Convert the temp path back to the original path
-        Path relativePath = tempDir.relativize(tempPomPath);
-        Path currentOriginalPath = commonRoot.resolve(relativePath);
+        Model effectiveModel = buildEffectiveModel(context, pomPath);
 
         // Start with current POM as the candidate
-        Path lastLocalParent = currentOriginalPath;
+        Path lastLocalParent = pomPath;
 
         // Walk up the parent hierarchy
         Model currentModel = effectiveModel;
@@ -1107,15 +1103,14 @@ private Path findLastLocalParentForPluginManagement(
                 // Parent is local, so it becomes our new candidate
                 lastLocalParent = parentPath;
 
-                Path parentTempPath = tempDir.resolve(commonRoot.relativize(parentPath));
-                currentModel = buildEffectiveModel(context, parentTempPath);
+                currentModel = buildEffectiveModel(context, parentPath);
             } else {
                 // Parent is external, stop here
                 break;
             }
         }
 
-        context.debug("Last local parent for " + currentOriginalPath + " is " + lastLocalParent);
+        context.debug("Last local parent for " + pomPath + " is " + lastLocalParent);
         return lastLocalParent;
     }
 
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/AbstractUpgradeStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/AbstractUpgradeStrategyTest.java
new file mode 100644
index 0000000000..e75f171d50
--- /dev/null
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/AbstractUpgradeStrategyTest.java
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+
+import eu.maveniverse.domtrip.Document;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests for {@link AbstractUpgradeStrategy} — in particular the reactor
+ * pre-build logic introduced to fix #13190.
+ */
+@DisplayName("AbstractUpgradeStrategy")
+class AbstractUpgradeStrategyTest {
+
+    /** Concrete strategy used to exercise {@code AbstractUpgradeStrategy.apply()}. */
+    private PluginUpgradeStrategy strategy;
+
+    @BeforeEach
+    void setUp() {
+        strategy = new PluginUpgradeStrategy();
+    }
+
+    /**
+     * Regression test for #13190.
+     *
+     * <p>Before the fix, {@code buildEffectiveModel} created a fresh
+     * {@code ModelBuilderSession} per POM with {@code BUILD_EFFECTIVE}. A fresh
+     * session has an empty {@code mappedSources} map, so Maven 4 coordinate
+     * inference (inferring a child {@code <version>} / {@code <groupId>} from
+     * its reactor parent) silently returns {@code null}. Strict effective-model
+     * validation then cascades {@code "version is missing"} errors for every
+     * dependency that relied on inference.
+     *
+     * <p>The fix: {@link AbstractUpgradeStrategy#apply} calls
+     * {@code prebuildReactorModels} once with
+     * {@code BUILD_PROJECT + recursive=true} on the root POM. This populates
+     * {@code mappedSources} for the whole reactor before any effective model is
+     * assembled.  The resulting {@code Map<Path, Model>} cache is consulted by
+     * {@code buildEffectiveModel}; for cache misses (external parents) the same
+     * {@code ModelBuilderSession} is reused — which shares the populated map.
+     */
+    @Test
+    @DisplayName("apply() on a multi-module project succeeds without version-missing cascade (regression #13190)")
+    void applyOnMultiModuleProjectSucceedsWithoutVersionMissingCascade() throws Exception {
+        Path tempDir = Files.createTempDirectory("mvnup-prebuild-test-");
+        try {
+            Files.createDirectories(tempDir.resolve(".mvn"));
+
+            // Root POM — declares a child module
+            Path parentPom = tempDir.resolve("pom.xml");
+            Files.writeString(parentPom, """
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                      <modelVersion>4.0.0</modelVersion>
+                      <groupId>test.group</groupId>
+                      <artifactId>parent</artifactId>
+                      <version>1.0.0</version>
+                      <packaging>pom</packaging>
+                      <modules><module>child</module></modules>
+                    </project>
+                    """);
+
+            // Child POM — <version> intentionally omitted; must be inferred from
+            // the parent via mappedSources.  Without the fix this causes a
+            // "version is missing" cascade error during effective-model validation.
+            Path childDir = tempDir.resolve("child");
+            Files.createDirectories(childDir);
+            Path childPom = childDir.resolve("pom.xml");
+            Files.writeString(childPom, """
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                      <modelVersion>4.0.0</modelVersion>
+                      <parent>
+                        <groupId>test.group</groupId>
+                        <artifactId>parent</artifactId>
+                        <version>1.0.0</version>
+                      </parent>
+                      <artifactId>child</artifactId>
+                    </project>
+                    """);
+
+            Document parentDoc = Document.of(Files.readString(parentPom));
+            Document childDoc = Document.of(Files.readString(childPom));
+            Map<Path, Document> pomMap = Map.of(parentPom, parentDoc, childPom, childDoc);
+
+            UpgradeContext context = TestUtils.createMockContext(tempDir);
+            UpgradeResult result = strategy.apply(context, pomMap);
+
+            assertTrue(result.success(), "apply() must succeed — no version-missing cascade from inference");
+            assertTrue(result.errorPoms().isEmpty(), "No POM should be in the error set: " + result.errorPoms());
+        } finally {
+            try (var walk = Files.walk(tempDir)) {
+                walk.sorted(java.util.Comparator.reverseOrder())
+                        .map(Path::toFile)
+                        .forEach(java.io.File::delete);
+            }
+        }
+    }
+}
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategyTest.java
index d38ac663e9..176308eb9a 100644
--- a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategyTest.java
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategyTest.java
@@ -66,6 +66,10 @@ private UpgradeContext createMockContext() {
         return TestUtils.createMockContext();
     }
 
+    private UpgradeContext createMockContext(Path workingDirectory) {
+        return TestUtils.createMockContext(workingDirectory);
+    }
+
     private UpgradeContext createMockContext(UpgradeOptions options) {
         return TestUtils.createMockContext(options);
     }
@@ -223,8 +227,8 @@ void shouldUpgradeMilestoneVersionBelowRelease() throws Exception {
             assertTrue(result.modifiedCount() > 0, "Should have upgraded 3.0.0-M1 to 3.5.0");
 
             Editor editor = new Editor(document);
-            String version = editor.root()
-                    .path("build", "plugins", "plugin", "version")
+            Element root = editor.root();
+            String version = root.path("build", "plugins", "plugin", "version")
                     .map(Element::textContentTrimmed)
                     .orElse(null);
             assertEquals("3.5.0", version, "3.0.0-M1 should be upgraded to 3.5.0");
@@ -1164,51 +1168,63 @@ void shouldOverrideRemoteParentPluginViaPluginManagementWithComment() throws Exc
                     </project>
                     """;
 
-            Document document = Document.of(pomXml);
-            Path pomPath = Paths.get("/project/pom.xml").toAbsolutePath();
-            Map<Path, Document> pomMap = Map.of(pomPath, document);
+            Path tempDir = Files.createTempDirectory("mvnup-test-");
+            try {
+                Files.createDirectories(tempDir.resolve(".mvn"));
+                Path pomPath = tempDir.resolve("pom.xml");
+                Files.writeString(pomPath, pomXml);
+                Document document = Document.of(pomXml);
+                Map<Path, Document> pomMap = Map.of(pomPath, document);
 
-            UpgradeContext context = createMockContext();
-            UpgradeResult result = strategy.doApply(context, pomMap);
+                UpgradeContext context = createMockContext(tempDir);
+                UpgradeResult result = strategy.doApply(context, pomMap);
 
-            assertTrue(result.success(), "Strategy should succeed");
+                assertTrue(result.success(), "Strategy should succeed");
 
-            Editor editor = new Editor(document);
-            Element root = editor.root();
+                Editor editor = new Editor(document);
+                Element root = editor.root();
 
-            // Verify pluginManagement entry exists for enforcer
-            Element pmPlugins =
-                    root.path("build", "pluginManagement", "plugins").orElse(null);
-            assertNotNull(pmPlugins, "Should have pluginManagement/plugins");
-            boolean hasEnforcerInPM = pmPlugins
-                    .childElements("plugin")
-                    .anyMatch(p -> "maven-enforcer-plugin"
-                            .equals(p.childElement("artifactId")
-                                    .map(Element::textContentTrimmed)
-                                    .orElse("")));
-            assertTrue(hasEnforcerInPM, "Should have enforcer in pluginManagement");
-
-            String xml = DomUtils.toXml(document);
-            assertTrue(
-                    xml.contains("Override version inherited from parent"),
-                    "Should add comment explaining the override");
-            // Verify the comment is on its own line, not appended to the previous closing tag
-            assertFalse(xml.contains("</plugin><!--"), "Comment should be on its own line, not appended to </plugin>");
-
-            // Verify NO direct build/plugins entry for enforcer (PM override is sufficient)
-            Element buildPlugins = root.childElement("build")
-                    .flatMap(b -> b.childElement("plugins"))
-                    .orElse(null);
-            if (buildPlugins != null) {
-                boolean hasEnforcerInPlugins = buildPlugins
+                // Verify pluginManagement entry exists for enforcer
+                Element pmPlugins =
+                        root.path("build", "pluginManagement", "plugins").orElse(null);
+                assertNotNull(pmPlugins, "Should have pluginManagement/plugins");
+                boolean hasEnforcerInPM = pmPlugins
                         .childElements("plugin")
                         .anyMatch(p -> "maven-enforcer-plugin"
                                 .equals(p.childElement("artifactId")
                                         .map(Element::textContentTrimmed)
                                         .orElse("")));
+                assertTrue(hasEnforcerInPM, "Should have enforcer in pluginManagement");
+
+                String xml = DomUtils.toXml(document);
+                assertTrue(
+                        xml.contains("Override version inherited from parent"),
+                        "Should add comment explaining the override");
+                // Verify the comment is on its own line, not appended to the previous closing tag
                 assertFalse(
-                        hasEnforcerInPlugins,
-                        "Should NOT add enforcer in build/plugins when pluginManagement override suffices");
+                        xml.contains("</plugin><!--"), "Comment should be on its own line, not appended to </plugin>");
+
+                // Verify NO direct build/plugins entry for enforcer (PM override is sufficient)
+                Element buildPlugins = root.childElement("build")
+                        .flatMap(b -> b.childElement("plugins"))
+                        .orElse(null);
+                if (buildPlugins != null) {
+                    boolean hasEnforcerInPlugins = buildPlugins
+                            .childElements("plugin")
+                            .anyMatch(p -> "maven-enforcer-plugin"
+                                    .equals(p.childElement("artifactId")
+                                            .map(Element::textContentTrimmed)
+                                            .orElse("")));
+                    assertFalse(
+                            hasEnforcerInPlugins,
+                            "Should NOT add enforcer in build/plugins when pluginManagement override suffices");
+                }
+            } finally {
+                try (var walk = Files.walk(tempDir)) {
+                    walk.sorted(java.util.Comparator.reverseOrder())
+                            .map(Path::toFile)
+                            .forEach(java.io.File::delete);
+                }
             }
         }
 
@@ -1240,41 +1256,53 @@ void shouldNotDuplicatePluginInBuildPluginsWhenAlreadyDeclared() throws Exceptio
                     """;
 
             Document document = Document.of(pomXml);
-            Path pomPath = Paths.get("/project/pom.xml").toAbsolutePath();
-            Map<Path, Document> pomMap = Map.of(pomPath, document);
+            Path tempDir2 = Files.createTempDirectory("mvnup-test-");
+            try {
+                Files.createDirectories(tempDir2.resolve(".mvn"));
+                Path pomPath = tempDir2.resolve("pom.xml");
+                Files.writeString(pomPath, pomXml);
+                document = Document.of(pomXml);
+                Map<Path, Document> pomMap = Map.of(pomPath, document);
 
-            UpgradeContext context = createMockContext();
-            UpgradeResult result = strategy.doApply(context, pomMap);
+                UpgradeContext context = createMockContext(tempDir2);
+                UpgradeResult result = strategy.doApply(context, pomMap);
 
-            assertTrue(result.success(), "Strategy should succeed");
+                assertTrue(result.success(), "Strategy should succeed");
 
-            Editor editor = new Editor(document);
-            Element root = editor.root();
-            Element buildPlugins = root.childElement("build")
-                    .flatMap(b -> b.childElement("plugins"))
-                    .orElse(null);
-            assertNotNull(buildPlugins, "Should have build/plugins section");
-
-            long enforcerCount = buildPlugins
-                    .childElements("plugin")
-                    .filter(p -> "maven-enforcer-plugin"
-                            .equals(p.childElement("artifactId")
-                                    .map(Element::textContentTrimmed)
-                                    .orElse("")))
-                    .count();
-            assertEquals(1, enforcerCount, "Should have exactly one maven-enforcer-plugin in build/plugins");
-
-            String version = buildPlugins
-                    .childElements("plugin")
-                    .filter(p -> "maven-enforcer-plugin"
-                            .equals(p.childElement("artifactId")
-                                    .map(Element::textContentTrimmed)
-                                    .orElse("")))
-                    .findFirst()
-                    .flatMap(p -> p.childElement("version"))
-                    .map(Element::textContentTrimmed)
-                    .orElse(null);
-            assertEquals("3.5.0", version, "Existing enforcer-plugin version should be upgraded to 3.5.0");
+                Editor editor = new Editor(document);
+                Element root = editor.root();
+                Element buildPlugins = root.childElement("build")
+                        .flatMap(b -> b.childElement("plugins"))
+                        .orElse(null);
+                assertNotNull(buildPlugins, "Should have build/plugins section");
+
+                long enforcerCount = buildPlugins
+                        .childElements("plugin")
+                        .filter(p -> "maven-enforcer-plugin"
+                                .equals(p.childElement("artifactId")
+                                        .map(Element::textContentTrimmed)
+                                        .orElse("")))
+                        .count();
+                assertEquals(1, enforcerCount, "Should have exactly one maven-enforcer-plugin in build/plugins");
+
+                String version = buildPlugins
+                        .childElements("plugin")
+                        .filter(p -> "maven-enforcer-plugin"
+                                .equals(p.childElement("artifactId")
+                                        .map(Element::textContentTrimmed)
+                                        .orElse("")))
+                        .findFirst()
+                        .flatMap(p -> p.childElement("version"))
+                        .map(Element::textContentTrimmed)
+                        .orElse(null);
+                assertEquals("3.5.0", version, "Existing enforcer-plugin version should be upgraded to 3.5.0");
+            } finally {
+                try (var walk = Files.walk(tempDir2)) {
+                    walk.sorted(java.util.Comparator.reverseOrder())
+                            .map(Path::toFile)
+                            .forEach(java.io.File::delete);
+                }
+            }
         }
 
         @Test
@@ -1349,8 +1377,6 @@ class ErrorHandlingTests {
         @Test
         @DisplayName("should warn when effective model analysis fails for POM with unresolvable remote parent")
         void shouldWarnWhenEffectiveModelAnalysisFailsForUnresolvableRemoteParent() throws Exception {
-            // POM inherits from a remote parent that does not exist.
-            // The effective model analysis should warn (not silently swallow) the failure.
             String pomXml = """
                     <?xml version="1.0" encoding="UTF-8"?>
                     <project xmlns="http://maven.apache.org/POM/4.0.0">
@@ -1370,12 +1396,10 @@ void shouldWarnWhenEffectiveModelAnalysisFailsForUnresolvableRemoteParent() thro
             UpgradeContext context = createMockContext();
             UpgradeResult result = strategy.doApply(context, pomMap);
 
-            // Strategy should complete successfully even when effective model analysis fails
             assertNotNull(result, "Result should not be null");
             assertTrue(result.success(), "Strategy should succeed even when effective model analysis fails");
             assertTrue(result.processedPoms().contains(Paths.get("pom.xml")), "POM should be marked as processed");
 
-            // The warning should have been logged (not silently swallowed at debug level)
             verify(context.logger, atLeastOnce())
                     .warn(argThat(msg -> msg.contains("Failed to analyze effective model")));
         }