Retry creating Bloop connection when multiple processes are trying it at the same time

Author: Gedochao

modules/build/src/main/scala/scala/build/compiler/BloopCompilerMaker.scala

@@ -3,11 +3,11 @@ package scala.build.compiler
 import bloop.rifle.{BloopRifleConfig, BloopServer, BloopThreads}
 import ch.epfl.scala.bsp4j.BuildClient
 
-import scala.build.Logger
 import scala.build.errors.{BuildException, FetchingDependenciesError, Severity}
 import scala.build.internal.Constants
 import scala.build.internal.util.WarningMessages
 import scala.build.options.BuildOptions
+import scala.build.{Logger, retry}
 import scala.concurrent.duration.DurationInt
 import scala.util.Try
 
@@ -35,34 +35,36 @@ final class BloopCompilerMaker(
           buildOptions
         )
       case Right(config) =>
-        val createBuildServer =
-          () =>
-            BloopServer.buildServer(
-              config,
-              "scala-cli",
-              Constants.version,
-              workspace.toNIO,
-              classesDir.toNIO,
-              buildClient,
-              threads,
-              logger.bloopRifleLogger
-            )
+        retry()(logger) {
+          val createBuildServer =
+            () =>
+              BloopServer.buildServer(
+                config,
+                "scala-cli",
+                Constants.version,
+                workspace.toNIO,
+                classesDir.toNIO,
+                buildClient,
+                threads,
+                logger.bloopRifleLogger
+              )
 
-        val res = Try(new BloopCompiler(createBuildServer, 20.seconds, strictBloopJsonCheck))
-          .toEither
-          .left.flatMap {
-            case e if offline =>
-              e.getCause match
-                case _: FetchingDependenciesError =>
-                  logger.diagnostic(
-                    WarningMessages.offlineModeBloopNotFound,
-                    Severity.Warning
-                  )
-                  SimpleScalaCompilerMaker("java", Nil)
-                    .create(workspace, classesDir, buildClient, logger, buildOptions)
-                case _ => Left(e)
-            case e => Left(e)
-          }.fold(t => throw t, identity)
-        Right(res)
+          val res = Try(new BloopCompiler(createBuildServer, 20.seconds, strictBloopJsonCheck))
+            .toEither
+            .left.flatMap {
+              case e if offline =>
+                e.getCause match
+                  case _: FetchingDependenciesError =>
+                    logger.diagnostic(
+                      WarningMessages.offlineModeBloopNotFound,
+                      Severity.Warning
+                    )
+                    SimpleScalaCompilerMaker("java", Nil)
+                      .create(workspace, classesDir, buildClient, logger, buildOptions)
+                  case _ => Left(e)
+              case e => Left(e)
+            }.fold(t => throw t, identity)
+          Right(res)
+        }
       case Left(ex) => Left(ex)
 }

modules/integration/src/test/scala/scala/cli/integration/RunTestDefinitions.scala

@@ -2312,12 +2312,17 @@ abstract class RunTestDefinitions
       os.rel / "raw.scala" -> """object Main { def main(args: Array[String]) = println(args.mkString(" ")) }"""
     )
     testInputs = TestInputs(input -> code)
+    shouldRestartBloop <- Seq(true, false)
+    restartBloopString = if (shouldRestartBloop) "with" else "without"
   }
-    test(s"run several instances of $input in parallel") {
+    test(s"run several instances of $input in parallel ($restartBloopString restarting Bloop)") {
       testInputs.fromRoot {
         root =>
+          if (shouldRestartBloop)
+            os.proc(TestUtil.cli, "bloop", "exit", "--power")
+              .call(cwd = root)
           val processes: Seq[(SubProcess, Int)] =
-            (0 to 20).map { i =>
+            (0 to 8).map { i =>
               os.proc(
                 TestUtil.cli,
                 "run",