Cross build for sbt 1.x and 2.x

.github/workflows/ci.yml

@@ -13,8 +13,8 @@ jobs:
       - uses: actions/checkout@v7
       - uses: actions/setup-java@v5
         with:
-          distribution: zulu
-          java-version: 8
+          distribution: temurin
+          java-version: 17
           cache: sbt
       - uses: sbt/setup-sbt@v1
       - name: Test

.gitignore

@@ -3,6 +3,7 @@ target-*
 __pycache__/
 docs/src/sphinx/version.py
 .bsp
+.claude
 .devcontainer
 .metals
 .vscode

actorLogging/src/main/scala/com/typesafe/dbuild/logging/ActorLogging.scala

@@ -1,18 +1,18 @@
 package com.typesafe.dbuild.logging
 
-import akka.actor.{ ActorRef, Actor, Props, PoisonPill, Terminated }
+import org.apache.pekko.actor.{ ActorRef, Actor, Props, PoisonPill, Terminated }
+import sbt.internal.util.StackTrace
 import sbt.io.IO
-import sbt.io.Path._
-import sbt.io.syntax._
+import sbt.io.Path.*
+import sbt.io.syntax.*
 import sbt.util.{ Level, LogEvent, Log, Trace, ControlEvent }
-import sbt.internal.util.StackTrace
 
 /** A command to the logging system to log a given event into a particular path. */
 case class LogCmd(path: String, evt: LogEvent, projName: String)
 
 /** A logger that sends LogCmds to an actor rather than doing anything directly. */
 class ActorLogger(nested: ActorRef, path: String = "root", val projName: String = "") extends Logger {
-import Level._
+import Level.*
   // TODO - Keep a reference of what's enabled locally...
   def newNestedLogger(name: String, projName: String = ""): Logger = {
     new ActorLogger(nested, path + "/" + name, projName)
@@ -163,10 +163,10 @@ class ChainedLoggerSupervisorActor extends Actor {
       val logger = context actorOf p
       context.watch(logger)
       loggers = logger +: loggers
-      sender ! logger
+      sender() ! logger
     case l: LogCmd => loggers foreach (_ forward l)
     case "exit" =>
-      terminationSender = sender
+      terminationSender = sender()
       loggers.foreach { _ ! "exit" }
     case Terminated(p) =>
       if (!(loggers.contains(p)))

actorProj/src/main/scala/com/typesafe/dbuild/project/build/BuildRunnerActor.scala

@@ -1,32 +1,32 @@
 package com.typesafe.dbuild.project.build
 
-import com.typesafe.dbuild.model._
 import com.typesafe.dbuild.logging.Logger
-import akka.actor.{ ActorRef, Actor, Props, PoisonPill, Terminated }
-import akka.util.Timeout
-import scala.concurrent.Await
-import scala.concurrent.duration._
+import Logger.prepareLogMsg
+import com.typesafe.dbuild.model.*
+import com.typesafe.dbuild.project.cleanup.Recycling.*
 import com.typesafe.dbuild.project.resolve.ProjectResolver
-import java.io.File
-import com.typesafe.dbuild.repo.core._
-import sbt.io.{ IO, DirectoryFilter }
-import sbt.io.Path._
-import sbt.io.syntax._
-import com.typesafe.dbuild.project.cleanup.Recycling._
-import com.typesafe.dbuild.repo.core.GlobalDirs.buildDir
 import com.typesafe.dbuild.project.{ BuildSystem, BuildData }
+import com.typesafe.dbuild.repo.core.*
+import com.typesafe.dbuild.repo.core.GlobalDirs.buildDir
 import com.typesafe.dbuild.utils.TrackedProcessBuilder
-import akka.pattern.ask
+import java.io.File
 import java.util.concurrent.TimeoutException
+import org.apache.pekko.actor.{ ActorRef, Actor, Props, PoisonPill, Terminated }
+import org.apache.pekko.pattern.ask
+import org.apache.pekko.util.Timeout
+import sbt.io.Path.*
+import sbt.io.syntax.*
+import sbt.io.{ IO, DirectoryFilter }
+import scala.concurrent.Await
+import scala.concurrent.duration.*
 import scala.util.{Success,Failure}
-import Logger.prepareLogMsg
 
 case class RunBuild(build: RepeatableProjectBuild, outProjects: Seq[Project], children: Seq[BuildOutcome], buildData: BuildData)
 
 class CleaningBuildActor extends Actor {
   def receive = {
     case target: File =>
-      IO.delete(buildDir(target).*(DirectoryFilter).get.filter(markedForDeletion))
+      IO.delete(buildDir(target).*(DirectoryFilter).get().filter(markedForDeletion))
       self ! PoisonPill
   }
 }
@@ -37,15 +37,15 @@ class BuildRunnerActor(builder: LocalBuildRunner, target: File, exp: CleanupExpi
   override def preStart() = {
     // Cleanup works in two stages; see ExtractorActor for details.
     // Note that cleanup is performed independently for the extraction and build directories
-    buildDir(target).*(DirectoryFilter).get.filter(upForDeletion(_, exp)).foreach(prepareForDeletion)
+    buildDir(target).*(DirectoryFilter).get().filter(upForDeletion(_, exp)).foreach(prepareForDeletion)
     // spawn the cleaning actor
     context.actorOf(Props(new CleaningBuildActor)) ! target
   }
 
   def receive = {
     case RunBuild(build, outProjects, children, buildData@BuildData(log, _)) =>
       log info ("--== Building %s ==--" format (build.config.name))
-      sender ! (try {
+      sender() ! (try {
         builder.checkCacheThenBuild(target, build, tracker, outProjects, children, buildData)
       } catch {
         case t:Throwable =>
@@ -61,7 +61,7 @@ class TimedBuildRunnerActor(builder: LocalBuildRunner, target: File,
   val realBuilder = context.actorOf(Props(new BuildRunnerActor(builder, target, exp, tracker)))
   def receive = {
     case msg@RunBuild(build, outProjects, children, buildData@BuildData(log, _)) =>
-      val originalSender = sender // need to copy, as we we'll use it later in a future (andThen)
+      val originalSender = sender() // need to copy, as we we'll use it later in a future (andThen)
       tracker.reset()
       val future1 = (realBuilder ? msg)(Timeout(buildDuration))
       val future2 = future1.andThen {
@@ -80,7 +80,7 @@ class TimedBuildRunnerActor(builder: LocalBuildRunner, target: File,
               log.error(timeoutMsg)
               originalSender ! new BuildFailed(build.config.name, children, timeoutMsg) with TimedOut
             case _ =>
-              originalSender ! akka.actor.Status.Failure(e)
+              originalSender ! org.apache.pekko.actor.Status.Failure(e)
           }
       } (scala.concurrent.ExecutionContext.Implicits.global)
 

actorProj/src/main/scala/com/typesafe/dbuild/project/dependencies/ExtractorActor.scala

@@ -1,35 +1,35 @@
 package com.typesafe.dbuild.project.dependencies
 
-import akka.actor.{ ActorRef, Actor, Props, PoisonPill, Terminated }
-import akka.util.Timeout
-import akka.pattern.ask
-import scala.concurrent.Await
-import scala.concurrent.duration._
-import com.typesafe.dbuild.model.{ ProjectBuildConfig, ExtractionConfig, ExtractionFailed, TimedOut }
-import _root_.java.io.File
-import sbt.io.Path._
-import sbt.io.syntax._
 import ExtractionDirs.projectExtractionDir
-import com.typesafe.dbuild.repo.core.GlobalDirs.extractionDir
-import com.typesafe.dbuild.model.CleanupExpirations
-import com.typesafe.dbuild.project.cleanup.Recycling._
-import sbt.io.{ IO, DirectoryFilter }
+import _root_.java.io.File
 import com.typesafe.dbuild.logging.Logger
 import Logger.prepareLogMsg
-import scala.util.{Success,Failure}
-import java.util.concurrent.TimeoutException
+import com.typesafe.dbuild.model.CleanupExpirations
+import com.typesafe.dbuild.model.{ ProjectBuildConfig, ExtractionConfig, ExtractionFailed, TimedOut }
+import com.typesafe.dbuild.project.cleanup.Recycling.*
+import com.typesafe.dbuild.repo.core.GlobalDirs.extractionDir
 import com.typesafe.dbuild.utils.TrackedProcessBuilder
+import java.util.concurrent.TimeoutException
+import org.apache.pekko.actor.{ ActorRef, Actor, Props, PoisonPill, Terminated }
+import org.apache.pekko.pattern.ask
+import org.apache.pekko.util.Timeout
+import sbt.io.Path.*
+import sbt.io.syntax.*
+import sbt.io.{ IO, DirectoryFilter }
+import scala.concurrent.Await
+import scala.concurrent.duration.*
+import scala.util.{Success,Failure}
 
 case class ExtractBuildDependencies(config: ExtractionConfig, uuidDir: String, log: Logger, debug: Boolean)
 
 class CleaningExtractionActor extends Actor {
   def receive = {
     case target: File =>
-      extractionDir(target).*(DirectoryFilter).get.foreach { d1 =>
+      extractionDir(target).*(DirectoryFilter).get().foreach { d1 =>
         if (markedForDeletion(d1))
           IO.delete(d1)
         else
-          IO.delete(projectExtractionDir(d1).*(DirectoryFilter).get.filter(markedForDeletion))
+          IO.delete(projectExtractionDir(d1).*(DirectoryFilter).get().filter(markedForDeletion))
       }
       self ! PoisonPill
   }
@@ -54,9 +54,9 @@ class ExtractorActor(e: Extractor, target: File, exp: CleanupExpirations, tracke
 
     // There are two levels in the hierarchy, so we mark for deletion first the nested
     // ones and, if all the content can be deleted, the outer one as well.
-    extractionDir(target).*(DirectoryFilter).get.foreach { d1 =>
+    extractionDir(target).*(DirectoryFilter).get().foreach { d1 =>
       if (!markedForDeletion(d1)) { // skip if already marked
-        val candidates = projectExtractionDir(d1).*(DirectoryFilter).get
+        val candidates = projectExtractionDir(d1).*(DirectoryFilter).get()
         val (delete, doNotDelete) = candidates.partition(upForDeletion(_, exp))
         if (doNotDelete.isEmpty) // everything can be deleted inside this dir, or there is
           prepareForDeletion(d1) // nothing left, so remove the dir
@@ -76,7 +76,7 @@ class ExtractorActor(e: Extractor, target: File, exp: CleanupExpirations, tracke
   def receive: Receive = {
     case ExtractBuildDependencies(build, uuidDir, log, debug) =>
       log info ("--== Extracting dependencies for %s ==--" format (build.buildConfig.name))
-      sender ! (try {
+      sender() ! (try {
         e.extract(extractionDir(target) / uuidDir, build, tracker, log, debug)
       } catch {
         case t:Throwable =>
@@ -92,7 +92,7 @@ class TimedExtractorActor(extractor: Extractor, target: File,
   val realExtractor = context.actorOf(Props(new ExtractorActor(extractor, target, exp, tracker)))
   def receive = {
     case msg@ExtractBuildDependencies(build, uuidDir, log, debug) =>
-      val originalSender = sender // need to copy, as we we'll use it later in a future (andThen)
+      val originalSender = sender() // need to copy, as we we'll use it later in a future (andThen)
       tracker.reset()
       val future1 = (realExtractor ? msg)(Timeout(extractionDuration))
       val future2 = future1.andThen {
@@ -111,7 +111,7 @@ class TimedExtractorActor(extractor: Extractor, target: File,
               log.error(timeoutMsg)
               originalSender ! new ExtractionFailed(build.buildConfig.name, Seq(), timeoutMsg) with TimedOut
             case _ =>
-              originalSender ! akka.actor.Status.Failure(e)
+              originalSender ! org.apache.pekko.actor.Status.Failure(e)
           }
       } (scala.concurrent.ExecutionContext.Implicits.global)