fix(maven): write output after each task in batch mode to ensure correct files are cached (#34400)

MaxKless · claude · web-flow · commit 18bfb0bc4ae8 · 2026-02-18T11:22:18.000-05:00
## Current Behavior
When running in maven 4 batch mode, the build state is recorded only
after the full batch is done.
This means that nx caching records the state of a task before build
state is recorded to disk.
When running another maven task that depends on this partially recorded
cache, the build state file is missing and we get errors.

## Expected Behavior
build state should be recorded after every task is done and before nx
caching can kick in. This way we can ensure that nx cache is correct.

---------

Co-authored-by: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/e2e/maven/src/maven-batch-v4.test.ts b/e2e/maven/src/maven-batch-v4.test.ts
@@ -48,7 +48,26 @@ wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-w
     );
   });
 
+  it('should install successfully after restoring cached package outputs', () => {
+    // Step 1: Clean target directories to simulate a clean CI checkout
+    runCLI('run-many -t clean');
+
+    // Step 2: Run package in batch mode — cache hit restores outputs (including nx-build-state.json)
+    runBatchCLI('run-many -t package');
+    checkFilesExist(
+      'app/target/app-1.0.0-SNAPSHOT.jar',
+      'lib/target/lib-1.0.0-SNAPSHOT.jar',
+      'utils/target/utils-1.0.0-SNAPSHOT.jar'
+    );
+
+    // Step 3: Run install in batch mode — this requires build state from the package phase
+    // to know about the main artifact.
+    runBatchCLI('run-many -t install');
+  });
+
   it('should fail when unit test fails', () => {
+    // TODO: remove once batch mode dependentTaskOutputs is fixed
+    runCLI('reset');
     // Add a failing unit test
     updateFile(
       'app/src/test/java/com/example/app/AppApplicationTests.java',
diff --git a/packages/maven/batch-runner-adapters/maven3/src/main/kotlin/dev/nx/maven/adapter/maven3/NxMaven3.kt b/packages/maven/batch-runner-adapters/maven3/src/main/kotlin/dev/nx/maven/adapter/maven3/NxMaven3.kt
@@ -34,6 +34,9 @@ class NxMaven3(
     @Volatile private var cachedProjectGraph: ProjectDependencyGraph? = null
     @Volatile private var cachedRepositorySession: RepositorySystemSession? = null
 
+    /** Indexed lookup: "groupId:artifactId" → MavenProject. Built once in setupGraphCache(). */
+    @Volatile private var projectBySelector: Map<String, MavenProject> = emptyMap()
+
     init {
         if (System.getProperty("org.slf4j.simpleLogger.defaultLogLevel") == null) {
             System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "info")
@@ -93,6 +96,7 @@ class NxMaven3(
                 return
             }
             cachedProjectGraph = graph
+            projectBySelector = graph.allProjects.associateBy { "${it.groupId}:${it.artifactId}" }
 
             session.projects = graph.sortedProjects
             session.allProjects = graph.allProjects
@@ -168,11 +172,9 @@ class NxMaven3(
         session.projectDependencyGraph = graph
 
         val selectedProjects = if (request.selectedProjects.isNotEmpty()) {
-            graph.allProjects.filter { project ->
-                request.selectedProjects.any { selector ->
-                    "${project.groupId}:${project.artifactId}" == selector ||
-                    project.artifactId == selector
-                }
+            request.selectedProjects.mapNotNull { selector ->
+                projectBySelector[selector]
+                    ?: graph.allProjects.find { it.artifactId == selector }
             }
         } else {
             graph.allProjects.filter { it.file?.absolutePath == request.pom?.absolutePath }
@@ -190,14 +192,13 @@ class NxMaven3(
     }
 
     fun recordBuildStates(projectSelectors: Set<String>) {
-        val graph = cachedProjectGraph ?: return
+        if (cachedProjectGraph == null) return
 
         projectSelectors.forEach { selector ->
-            graph.allProjects.find { "${it.groupId}:${it.artifactId}" == selector }
-                ?.let { project ->
-                    try { BuildStateManager.recordBuildState(project) }
-                    catch (_: Exception) { }
-                }
+            projectBySelector[selector]?.let { project ->
+                try { BuildStateManager.recordBuildState(project) }
+                catch (_: Exception) { }
+            }
         }
     }
 }
diff --git a/packages/maven/batch-runner-adapters/maven4/src/main/kotlin/dev/nx/maven/adapter/maven4/NxMaven.kt b/packages/maven/batch-runner-adapters/maven4/src/main/kotlin/dev/nx/maven/adapter/maven4/NxMaven.kt
@@ -66,7 +66,11 @@ class NxMaven(
   private val executionCount = AtomicInteger(0)
 
   @Volatile
-  private var cachedProjectGraph: ProjectDependencyGraph? = null  // ProjectDependencyGraph
+  private var cachedProjectGraph: ProjectDependencyGraph? = null
+
+  /** Indexed lookup: "groupId:artifactId" → MavenProject. Built once in setupGraphCache(). */
+  @Volatile
+  private var projectBySelector: Map<String, MavenProject> = emptyMap()
 
   @Volatile
   private var cachedRepositorySession: RepositorySystemSession? = null
@@ -167,6 +171,7 @@ class NxMaven(
 
       val graph = graphResult.get()
       cachedProjectGraph = graph
+      projectBySelector = graph.allProjects.associateBy { "${it.groupId}:${it.artifactId}" }
 
       log.debug("   ✅ Graph cache setup complete with ${graph.allProjects.size} projects")
       graph.sortedProjects?.forEach { project ->
@@ -196,9 +201,9 @@ class NxMaven(
     session.projectDependencyGraph = graph
 
     // Find the selected project(s) to build
-    val selectedProjects = session.allProjects.filter {
-      "${it.groupId}:${it.artifactId}" == request.selectedProjects.firstOrNull()
-    }
+    val selectedProjects = listOfNotNull(
+      request.selectedProjects.firstOrNull()?.let { projectBySelector[it] }
+    )
 
     // session.projects controls what lifecycleStarter builds - keep it to selected projects only
     session.projects = selectedProjects
@@ -355,10 +360,7 @@ class NxMaven(
     var failedCount = 0
 
     projectSelectors.forEach { selector ->
-      // Find matching project in the cached graph
-      val project = cachedProjectGraph!!.allProjects.find { p ->
-        "${p.groupId}:${p.artifactId}" == selector
-      }
+      val project = projectBySelector[selector]
 
       if (project != null) {
         try {
diff --git a/packages/maven/batch-runner/src/main/kotlin/dev/nx/maven/runner/MavenInvokerRunner.kt b/packages/maven/batch-runner/src/main/kotlin/dev/nx/maven/runner/MavenInvokerRunner.kt
@@ -85,6 +85,11 @@ class MavenInvokerRunner(private val workspaceRoot: File, private val options: M
 
             val result = executeSingleTask(taskId, results)
 
+            // Record build state for all batch projects BEFORE emitting result.
+            // emitResult() triggers Nx to cache task outputs, so nx-build-state.json
+            // must be written first to ensure the cached outputs include fresh build state.
+            recordBuildStatesForBatchProjects(taskId)
+
             // Emit result to stderr for streaming to Nx
             emitResult(taskId, result)
 
@@ -132,9 +137,6 @@ class MavenInvokerRunner(private val workspaceRoot: File, private val options: M
 
       // Wait for all tasks to complete
       completionLatch.await()
-
-      // Record build states for all projects that had tasks executed
-      recordBuildStatesForExecutedTasks()
     } finally {
       // Threads are daemon threads, so they won't prevent JVM exit
       // Just try to shutdown gracefully without waiting
@@ -149,28 +151,29 @@ class MavenInvokerRunner(private val workspaceRoot: File, private val options: M
     return results.toMap()
   }
 
+  /** All unique project selectors in the batch, computed once. */
+  private val allBatchProjectSelectors: Set<String> by lazy {
+    options.taskGraph?.tasks?.values
+      ?.map { it.target.project }
+      ?.toSet() ?: emptySet()
+  }
+
   /**
-   * Record build states for all unique projects that had tasks executed.
-   * This is called after all tasks complete to save the build state for future batches.
+   * Record build state for all projects in the batch.
+   * Called after each task execution but before emitting the result to Nx,
+   * ensuring nx-build-state.json is up-to-date when Nx caches the task's outputs.
+   *
+   * We record ALL batch projects (not just the current task's project) because
+   * a task in projectA can modify the Maven session state of projectB
+   * (e.g., adding source roots or classpath entries). The lastWrittenState cache
+   * in BuildStateRecorder ensures we only perform file I/O for projects whose
+   * state actually changed.
    */
-  private fun recordBuildStatesForExecutedTasks() {
+  private fun recordBuildStatesForBatchProjects(taskId: String) {
     try {
-      // Extract unique project selectors from executed tasks
-      val uniqueProjectSelectors = options.taskGraph?.tasks?.values
-        ?.map { it.target.project }
-        ?.toSet() ?: emptySet()
-
-      if (uniqueProjectSelectors.isEmpty()) {
-        log.debug("No projects to record build states for")
-        return
-      }
-
-      log.debug("Preparing to record build states for ${uniqueProjectSelectors.size} unique projects")
-      log.debug("Projects: ${uniqueProjectSelectors.joinToString(", ")}")
-
-      (mavenExecutor as? ResidentMavenExecutor)?.recordBuildStates(uniqueProjectSelectors)
+      (mavenExecutor as? ResidentMavenExecutor)?.recordBuildStates(allBatchProjectSelectors)
     } catch (e: Exception) {
-      log.error("Error recording build states: ${e.message}", e)
+      log.error("Error recording build states after task $taskId: ${e.message}", e)
     }
   }
 
diff --git a/packages/maven/shared/src/main/kotlin/dev/nx/maven/adapter/AdapterInvoker.kt b/packages/maven/shared/src/main/kotlin/dev/nx/maven/adapter/AdapterInvoker.kt
@@ -30,7 +30,9 @@ interface AdapterInvoker : AutoCloseable {
 
     /**
      * Record build states for the specified projects.
-     * Called after batch execution to save state for future runs.
+     * Called after each task completes (for all batch projects) to save state
+     * before Nx caches outputs. Cross-project state mutations are captured
+     * because all batch projects are recorded, not just the current task's project.
      *
      * @param projectSelectors Project selectors (e.g., "groupId:artifactId")
      */
diff --git a/packages/maven/shared/src/main/kotlin/dev/nx/maven/shared/BuildStateRecorder.kt b/packages/maven/shared/src/main/kotlin/dev/nx/maven/shared/BuildStateRecorder.kt
@@ -7,6 +7,7 @@ import org.apache.maven.project.MavenProject
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import java.io.File
+import java.util.concurrent.ConcurrentHashMap
 
 /**
  * Utility for recording build state from Maven projects.
@@ -16,39 +17,69 @@ object BuildStateRecorder {
     private val log: Logger = LoggerFactory.getLogger(BuildStateRecorder::class.java)
     private val gson = GsonBuilder().setPrettyPrinting().create()
 
+    /**
+     * Cache of the last-written BuildState per project (keyed by "groupId:artifactId").
+     * Used to skip redundant JSON serialization and file I/O when the state hasn't changed.
+     */
+    private val lastWrittenState = ConcurrentHashMap<String, BuildState>()
+
+    /**
+     * Cache of canonicalized path mappings to avoid repeated filesystem syscalls.
+     * Key: absolute path, Value: relative path from project root.
+     * File.canonicalPath is a syscall that resolves symlinks — caching it avoids
+     * hundreds of redundant syscalls per recording (especially for classpath entries
+     * pointing to ~/.m2/repository).
+     */
+    private val canonicalPathCache = ConcurrentHashMap<Pair<String, String>, String>()
+
+    private fun toRelativePathCached(absolutePath: String, projectRoot: File): String {
+        val rootPath = projectRoot.absolutePath
+        val key = Pair(absolutePath, rootPath)
+        return canonicalPathCache.getOrPut(key) {
+            PathUtils.toRelativePath(absolutePath, projectRoot, log)
+        }
+    }
+
+    private fun toRelativePathsCached(absolutePaths: Set<String>, projectRoot: File): Set<String> {
+        return absolutePaths.map { toRelativePathCached(it, projectRoot) }.toSet()
+    }
+
     /**
      * Record the build state of a Maven project to nx-build-state.json.
+     * Computes the full state every time for correctness, but skips the file write
+     * if the state is identical to what was last written.
      *
      * @param project The MavenProject to record
      * @throws Exception if recording fails
      */
     fun recordBuildState(project: MavenProject) {
+        val selector = "${project.groupId}:${project.artifactId}"
         val startTime = System.currentTimeMillis()
         log.debug("  Recording build state for ${project.groupId}:${project.artifactId}...")
         val basedir = project.basedir
 
         // Capture compile source roots
         val compileSourceRootsAbsolute = project.compileSourceRoots.toSet()
-        val compileSourceRoots = PathUtils.toRelativePaths(compileSourceRootsAbsolute, basedir, log)
+        val compileSourceRoots = toRelativePathsCached(compileSourceRootsAbsolute, basedir)
 
         // Capture test compile source roots
         val testCompileSourceRootsAbsolute = project.testCompileSourceRoots.toSet()
-        val testCompileSourceRoots = PathUtils.toRelativePaths(testCompileSourceRootsAbsolute, basedir, log)
+        val testCompileSourceRoots = toRelativePathsCached(testCompileSourceRootsAbsolute, basedir)
 
         // Capture resources
         val resourcesAbsolute = project.resources.map { (it as Resource).directory }.filter { it != null }.toSet()
-        val resources = PathUtils.toRelativePaths(resourcesAbsolute, basedir, log)
+        val resources = toRelativePathsCached(resourcesAbsolute, basedir)
 
         // Capture test resources
         val testResourcesAbsolute = project.testResources.map { (it as Resource).directory }.filter { it != null }.toSet()
-        val testResources = PathUtils.toRelativePaths(testResourcesAbsolute, basedir, log)
+        val testResources = toRelativePathsCached(testResourcesAbsolute, basedir)
 
         // Capture output directories
         val outputDirectory = project.build.outputDirectory?.let {
-            PathUtils.toRelativePath(it, basedir, log)
+            toRelativePathCached(it, basedir)
         }
         val testOutputDirectory = project.build.testOutputDirectory?.let {
-            PathUtils.toRelativePath(it, basedir, log)
+            toRelativePathCached(it, basedir)
         }
 
         // Capture classpaths
@@ -64,7 +95,7 @@ object BuildStateRecorder {
         val defaultPomFile = File(basedir, "pom.xml")
         val currentPomFile = project.file
         val pomFile = if (currentPomFile != null && currentPomFile.canonicalPath != defaultPomFile.canonicalPath) {
-            val relativePath = PathUtils.toRelativePath(currentPomFile.absolutePath, basedir, log)
+            val relativePath = toRelativePathCached(currentPomFile.absolutePath, basedir)
             log.info("Captured non-default pomFile: $relativePath (modified by a plugin like flatten-maven-plugin)")
             relativePath
         } else {
@@ -87,10 +118,19 @@ object BuildStateRecorder {
             pomFile = pomFile
         )
 
-        // Write to file
+        // Skip write if state is identical to what was last written
         val outputFile = File(project.build.directory, BUILD_STATE_FILE)
+        val lastState = lastWrittenState[selector]
+        if (lastState != null && lastState == buildState) {
+            val duration = System.currentTimeMillis() - startTime
+            log.debug("  Skipping write for $selector — state unchanged (took ${duration}ms)")
+            return
+        }
+
+        // Write to file
         outputFile.parentFile?.mkdirs()
         outputFile.writeText(gson.toJson(buildState))
+        lastWrittenState[selector] = buildState
 
         val duration = System.currentTimeMillis() - startTime
         log.debug("    Recorded to ${outputFile.absolutePath} (took ${duration}ms)")
@@ -107,14 +147,14 @@ object BuildStateRecorder {
             log.warn("Failed to capture $classpathType classpath: ${e.message}")
             emptySet<String>()
         }
-        return PathUtils.toRelativePaths(absolutePaths, basedir, log)
+        return toRelativePathsCached(absolutePaths, basedir)
     }
 
     private fun captureMainArtifact(project: MavenProject, basedir: File): ArtifactInfo? {
         val artifactFile = project.artifact?.file
         if (artifactFile != null && artifactFile.exists()) {
             return ArtifactInfo(
-                file = PathUtils.toRelativePath(artifactFile.absolutePath, basedir, log),
+                file = toRelativePathCached(artifactFile.absolutePath, basedir),
                 type = project.artifact.type,
                 classifier = project.artifact.classifier,
                 groupId = project.artifact.groupId,
@@ -144,7 +184,7 @@ object BuildStateRecorder {
                     null
                 }
                 else -> ArtifactInfo(
-                    file = PathUtils.toRelativePath(artifact.file.absolutePath, basedir, log),
+                    file = toRelativePathCached(artifact.file.absolutePath, basedir),
                     type = artifact.type,
                     classifier = artifact.classifier,
                     groupId = artifact.groupId,
