.

Author: lihaoyi

core/exec/src/mill/exec/Execution.scala

@@ -227,7 +227,6 @@ case class Execution(
         )
 
       val tracker = new Execution.LeaseTracker(indexToTerminal, interGroupDeps)
-      def onTerminalCompleted(t: Task[?]): Unit = tracker.onCompleted(t)
       try {
 
         def evaluateTerminals(
@@ -258,7 +257,7 @@ case class Execution(
                 .map(t => (t, failure))
                 .toMap
 
-              onTerminalCompleted(terminal)
+              tracker.onCompleted(terminal)
               futures(terminal) = Future.successful(
                 Some(GroupExecution.Results(
                   newResults = taskResults,
@@ -365,7 +364,7 @@ case class Execution(
                     nonFatal.setStackTrace(e.getStackTrace)
                     throw nonFatal
                 } finally {
-                  onTerminalCompleted(terminal)
+                  tracker.onCompleted(terminal)
                 }
               }
             }
@@ -388,8 +387,8 @@ case class Execution(
         val exclusiveResults = evaluateTerminals(leafExclusiveCommands, exclusive = true)
 
         // Set final header showing SUCCESS/FAILED status:
-        // - FAILED: show for any outermost execution with failures
-        // - SUCCESS: only show for the final requested depth
+        // - FAILED: show for any outermost execution with failures (meta-build failures terminate bootstrapping)
+        // - SUCCESS: only show for the final requested depth (depth 0 normally, or --meta-level if specified)
         val isOutermostExecution = executionNestingDepth.get() == 1
         val hasFailures = rootFailedCount.get() > 0
         val showFinalStatus = isOutermostExecution && (hasFailures || isFinalDepth)

core/internal/src/mill/internal/CrossThreadRwLock.scala

@@ -28,14 +28,9 @@ class CrossThreadRwLock(label: String) {
 
   private def waitingMessage(blocker: Option[HolderInfo]): String = blocker match {
     case Some(h) =>
-      s"Another Mill command in the current daemon is running '${h.command}' with PID ${h.pid}"
+      s"Another Mill command in the current daemon is running '${h.command}' task '$label' with PID ${h.pid}"
     case None =>
-      s"Another Mill command in the current daemon is using '$label'"
-  }
-
-  private def blockedSuffix(kind: LockKind): String = kind match {
-    case LockKind.Read => s" (blocked on reading from $label)"
-    case LockKind.Write => s" (blocked on writing to $label)"
+      s"Another Mill command in the current daemon is using task '$label'"
   }
 
   def acquire(
@@ -55,7 +50,7 @@ class CrossThreadRwLock(label: String) {
         Some(lease)
       } else if (noWait) {
         throw new Exception(
-          s"${waitingMessage(currentBlocker())}${blockedSuffix(kind)} and --no-wait was set, failing"
+          s"${waitingMessage(currentBlocker())} and --no-wait was set, failing"
         )
       } else {
         if (isWrite) waitingWriters += 1
@@ -66,9 +61,8 @@ class CrossThreadRwLock(label: String) {
     leaseOpt.getOrElse {
       val blocker = monitor.synchronized(currentBlocker())
       waitingErr.println(
-        s"${waitingMessage(blocker)}, waiting for it to be done... " +
-          s"(tail -F out/${DaemonFiles.millConsoleTail} to see its progress)" +
-          blockedSuffix(kind)
+        s"${waitingMessage(blocker)}, waiting for it " +
+          s"(tail -F out/${DaemonFiles.millConsoleTail} to see its progress)"
       )
 
       monitor.synchronized {

core/internal/src/mill/internal/LauncherOutFilesImpl.scala

@@ -11,37 +11,37 @@ private[mill] class LauncherOutFilesImpl(
     out: os.Path,
     activeCommandMessage: String,
     launcherPid: Long,
-    artifactState: LauncherArtifactState,
+    outFilesState: LauncherOutFilesState,
     private val runId: String
 ) extends LauncherOutFiles {
   import LauncherOutFilesImpl.*
 
-  private val runDir = out / LauncherArtifactState.runRootDirName / runId
+  private val runDir = out / LauncherOutFilesState.runRootDirName / runId
   override val consoleTail: java.nio.file.Path = (runDir / "mill-console-tail").toNIO
   override val profile: java.nio.file.Path = (runDir / OutFiles.millProfile).toNIO
   override val chromeProfile: java.nio.file.Path = (runDir / OutFiles.millChromeProfile).toNIO
   override val dependencyTree: java.nio.file.Path = (runDir / OutFiles.millDependencyTree).toNIO
   override val invalidationTree: java.nio.file.Path = (runDir / OutFiles.millInvalidationTree).toNIO
   private val closed = new AtomicBoolean(false)
 
-  private val publishedArtifacts = Seq(
-    PublishedArtifact(
+  private val publishedOutFiles = Seq(
+    PublishedOutFile(
       out / DaemonFiles.millConsoleTail,
       os.Path(consoleTail),
       copyFallback = false
     ),
-    PublishedArtifact(out / OutFiles.millProfile, os.Path(profile), copyFallback = true),
-    PublishedArtifact(
+    PublishedOutFile(out / OutFiles.millProfile, os.Path(profile), copyFallback = true),
+    PublishedOutFile(
       out / OutFiles.millChromeProfile,
       os.Path(chromeProfile),
       copyFallback = true
     ),
-    PublishedArtifact(
+    PublishedOutFile(
       out / OutFiles.millDependencyTree,
       os.Path(dependencyTree),
       copyFallback = true
     ),
-    PublishedArtifact(
+    PublishedOutFile(
       out / OutFiles.millInvalidationTree,
       os.Path(invalidationTree),
       copyFallback = true
@@ -55,29 +55,29 @@ private[mill] class LauncherOutFilesImpl(
   // for deletion, so the record must be visible before the directory exists.
   writeLauncherRunFile()
   os.makeDir.all(runDir)
-  cleanup(out, artifactState)
+  cleanup(out, outFilesState)
 
   override def publishLiveArtifacts(): Unit =
-    if (!closed.get()) publishLatest(publishedArtifacts.head, artifactState)
+    if (!closed.get()) publishLatest(publishedOutFiles.head, outFilesState)
 
   override def publishArtifacts(): Unit =
-    if (!closed.get()) publishedArtifacts.foreach(publishLatest(_, artifactState))
+    if (!closed.get()) publishedOutFiles.foreach(publishLatest(_, outFilesState))
 
   override def close(): Unit =
     if (closed.compareAndSet(false, true)) {
-      LauncherRecordStore.remove(out, runId)
-      cleanup(out, artifactState)
+      LauncherOutFilesRecordStore.remove(out, runId)
+      cleanup(out, outFilesState)
     }
 
   private def writeLauncherRunFile(): Unit =
-    LauncherRecordStore.write(out, runId, launcherPid, activeCommandMessage)
+    LauncherOutFilesRecordStore.write(out, runId, launcherPid, activeCommandMessage)
 }
 
 private[mill] object LauncherOutFilesImpl {
   private val maxRetainedRuns = 10
-  private case class PublishedArtifact(link: os.Path, target: os.Path, copyFallback: Boolean)
+  private case class PublishedOutFile(link: os.Path, target: os.Path, copyFallback: Boolean)
 
-  private val wellKnownArtifactLinks = Seq(
+  private val wellKnownOutFileLinks = Seq(
     os.RelPath(DaemonFiles.millConsoleTail),
     os.RelPath(OutFiles.millProfile),
     os.RelPath(OutFiles.millChromeProfile),
@@ -99,11 +99,11 @@ private[mill] object LauncherOutFilesImpl {
 
   private def cleanup(
       out: os.Path,
-      artifactState: LauncherArtifactState
+      outFilesState: LauncherOutFilesState
   ): Unit = {
     try {
-      val active = LauncherRecordStore.sweepActive(out).iterator.map(_.runId).toSet
-      val runRootDir = out / LauncherArtifactState.runRootDirName
+      val active = LauncherOutFilesRecordStore.sweepActive(out).iterator.map(_.runId).toSet
+      val runRootDir = out / LauncherOutFilesState.runRootDirName
       if (os.exists(runRootDir)) {
         val runDirs = os.list(runRootDir).filter(os.isDir(_))
         val eligible = runDirs.filterNot(d => active.contains(d.last)).sortBy(runDirSortKey)
@@ -114,9 +114,9 @@ private[mill] object LauncherOutFilesImpl {
         )
       }
 
-      wellKnownArtifactLinks.foreach { rel =>
+      wellKnownOutFileLinks.foreach { rel =>
         val link = out / rel
-        withArtifactLock(link, artifactState) {
+        withPublishedPathLock(link, outFilesState) {
           if (os.isLink(link) && !os.exists(link, followLinks = true)) {
             try os.remove(link)
             catch { case _: Throwable => () }
@@ -126,12 +126,12 @@ private[mill] object LauncherOutFilesImpl {
     } catch { case _: Throwable => () }
   }
 
-  private def withArtifactLock[T](
+  private def withPublishedPathLock[T](
       link: os.Path,
-      artifactState: LauncherArtifactState
+      outFilesState: LauncherOutFilesState
   )(body: => T): T = {
     val key = link.toNIO.toAbsolutePath.normalize.toString
-    artifactState.artifactLockFor(key).synchronized(body)
+    outFilesState.publishedPathLockFor(key).synchronized(body)
   }
 
   private def replaceAtomically(
@@ -159,40 +159,40 @@ private[mill] object LauncherOutFilesImpl {
   private def updateSymlink(
       link: os.Path,
       target: os.Path,
-      artifactState: LauncherArtifactState
+      outFilesState: LauncherOutFilesState
   ): Unit = {
     val rel = relativizeTarget(link, target)
     replaceAtomically(
       link,
-      s".${link.last}.tmp-${System.nanoTime()}-${artifactState.nextTmpSuffix()}"
+      s".${link.last}.tmp-${System.nanoTime()}-${outFilesState.nextTmpSuffix()}"
     )(tmp => os.symlink(tmp, rel))
   }
 
   private def replaceWithCopy(
       link: os.Path,
       target: os.Path,
-      artifactState: LauncherArtifactState
+      outFilesState: LauncherOutFilesState
   ): Unit = {
     replaceAtomically(
       link,
-      s".${link.last}.copy-${System.nanoTime()}-${artifactState.nextTmpSuffix()}"
+      s".${link.last}.copy-${System.nanoTime()}-${outFilesState.nextTmpSuffix()}"
     )(tmp => os.copy.over(target, tmp, createFolders = true))
   }
 
   private def publishLatest(
-      artifact: PublishedArtifact,
-      artifactState: LauncherArtifactState
+      outFile: PublishedOutFile,
+      outFilesState: LauncherOutFilesState
   ): Unit = {
-    withArtifactLock(artifact.link, artifactState) {
-      if (os.exists(artifact.target))
-        try updateSymlink(artifact.link, artifact.target, artifactState)
+    withPublishedPathLock(outFile.link, outFilesState) {
+      if (os.exists(outFile.target))
+        try updateSymlink(outFile.link, outFile.target, outFilesState)
         catch {
           case e: Throwable =>
             mill.api.Debug(
-              s"Failed to publish ${artifact.link.last} as a symlink: ${e.getClass.getSimpleName}: ${e.getMessage}"
+              s"Failed to publish ${outFile.link.last} as a symlink: ${e.getClass.getSimpleName}: ${e.getMessage}"
             )
-            if (artifact.copyFallback)
-              replaceWithCopy(artifact.link, artifact.target, artifactState)
+            if (outFile.copyFallback)
+              replaceWithCopy(outFile.link, outFile.target, outFilesState)
         }
     }
   }

…/mill/internal/LauncherRecordStore.scala …ternal/LauncherOutFilesRecordStore.scalacore/internal/src/mill/internal/LauncherRecordStore.scala renamed to core/internal/src/mill/internal/LauncherOutFilesRecordStore.scala core/internal/src/mill/internal/LauncherRecordStore.scala renamed to core/internal/src/mill/internal/LauncherOutFilesRecordStore.scala

@@ -4,7 +4,7 @@ import mill.constants.DaemonFiles
 
 import scala.jdk.OptionConverters.RichOptional
 
-private[mill] object LauncherRecordStore {
+private[mill] object LauncherOutFilesRecordStore {
   case class Record(runId: String, pid: Long, command: String)
 
   def path(out: os.Path, runId: String): os.Path =

…ill/internal/LauncherArtifactState.scala …ill/internal/LauncherOutFilesState.scalacore/internal/src/mill/internal/LauncherArtifactState.scala renamed to core/internal/src/mill/internal/LauncherOutFilesState.scala core/internal/src/mill/internal/LauncherArtifactState.scala renamed to core/internal/src/mill/internal/LauncherOutFilesState.scala

@@ -5,8 +5,8 @@ import mill.constants.DaemonFiles
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicLong
 
-private[mill] class LauncherArtifactState {
-  private val artifactLocks = new ConcurrentHashMap[String, AnyRef]()
+private[mill] class LauncherOutFilesState {
+  private val publishedPathLocks = new ConcurrentHashMap[String, AnyRef]()
   private val runIdCounter = new AtomicLong(0L)
   private val tmpNameCounter = new AtomicLong(0L)
   // The PR design allows a MillNoDaemonMain process to share `out/` with a
@@ -15,15 +15,15 @@ private[mill] class LauncherArtifactState {
   // run directories and launcher record files cannot collide across processes.
   private val pid: Long = ProcessHandle.current().pid()
 
-  def artifactLockFor(normalizedAbsolutePath: String): AnyRef =
-    artifactLocks.computeIfAbsent(normalizedAbsolutePath, _ => new Object)
+  def publishedPathLockFor(normalizedAbsolutePath: String): AnyRef =
+    publishedPathLocks.computeIfAbsent(normalizedAbsolutePath, _ => new Object)
 
   def nextRunId(): String =
     s"${System.currentTimeMillis()}-$pid-${runIdCounter.getAndIncrement()}"
 
   def nextTmpSuffix(): Long = tmpNameCounter.getAndIncrement()
 }
 
-private[mill] object LauncherArtifactState {
+private[mill] object LauncherOutFilesState {
   val runRootDirName = DaemonFiles.millRun
 }

core/internal/test/src/mill/internal/CrossThreadRwLockTests.scala

@@ -287,8 +287,9 @@ object CrossThreadRwLockTests extends TestSuite {
       assertEventually(waitingBytes.size() > 0)
       val msg = waitingBytes.toString
       assert(msg.contains("'blockerTask'"))
+      assert(msg.contains("task 'holder-naming'"))
       assert(msg.contains("PID 9876"))
-      assert(msg.contains("waiting for it to be done..."))
+      assert(msg.contains("waiting for it (tail -F out/mill-console-tail to see its progress)"))
 
       firstLease.close()
       assert(secondAcquired.await(5, TimeUnit.SECONDS))
@@ -346,6 +347,7 @@ object CrossThreadRwLockTests extends TestSuite {
           case e: Exception => e
         }
       assert(ex.getMessage.contains("'blockerCmd'"))
+      assert(ex.getMessage.contains("task 'no-wait'"))
       assert(ex.getMessage.contains("PID 7777"))
       assert(ex.getMessage.contains("--no-wait"))
 
@@ -376,6 +378,7 @@ object CrossThreadRwLockTests extends TestSuite {
       assertEventually(waitingBytes.size() > 0)
       val msg = waitingBytes.toString
       assert(msg.contains("'stillHoldingCmd'"))
+      assert(msg.contains("task 'stale-last-holder'"))
       assert(msg.contains("PID 1111"))
       assert(!msg.contains("'alreadyReleasedCmd'"))
       assert(!msg.contains("PID 2222"))

core/internal/test/src/mill/internal/LauncherOutFilesImplTests.scala

@@ -8,24 +8,24 @@ object LauncherOutFilesImplTests extends TestSuite {
     test("cleanupDoesNotDeleteJustFinishedRunWhenActiveRunsFillRetention") {
       val out = os.temp.dir(prefix = "mill-launcher-out-files")
       try {
-        val artifactState = new LauncherArtifactState
+        val outFilesState = new LauncherOutFilesState
         val pid = ProcessHandle.current().pid()
 
         for (i <- 0 until 10) {
           val runId = s"1000-$pid-$i"
-          LauncherRecordStore.write(out, runId, pid, s"active-$i")
-          os.makeDir.all(out / LauncherArtifactState.runRootDirName / runId)
+          LauncherOutFilesRecordStore.write(out, runId, pid, s"active-$i")
+          os.makeDir.all(out / LauncherOutFilesState.runRootDirName / runId)
         }
 
         val finishedRunId = s"2000-$pid-0"
         val outFiles = new LauncherOutFilesImpl(
           out = out,
           activeCommandMessage = "finished",
           launcherPid = pid,
-          artifactState = artifactState,
+          outFilesState = outFilesState,
           runId = finishedRunId
         )
-        val finishedRunDir = out / LauncherArtifactState.runRootDirName / finishedRunId
+        val finishedRunDir = out / LauncherOutFilesState.runRootDirName / finishedRunId
         os.write(os.Path(outFiles.profile), "[]", createFolders = true)
         outFiles.publishArtifacts()
         outFiles.close()
@@ -39,10 +39,10 @@ object LauncherOutFilesImplTests extends TestSuite {
       val out = os.temp.dir(prefix = "mill-launcher-records")
       try {
         val runId = "1000-123-0"
-        val record = LauncherRecordStore.path(out, runId)
+        val record = LauncherOutFilesRecordStore.path(out, runId)
         os.write.over(record, "{", createFolders = true)
 
-        val active = LauncherRecordStore.sweepActive(out)
+        val active = LauncherOutFilesRecordStore.sweepActive(out)
 
         assert(active.exists(_.runId == runId))
         assert(os.exists(record))