Merge pull request #1716 from alexarchambault/restart-bloop-server-if-needed

alexarchambault · web-flow · commit 2db17f07b66d · 2023-01-16T10:40:51.000+01:00
Restart Bloop server if it exited
diff --git a/modules/build/src/main/scala/scala/build/Bloop.scala b/modules/build/src/main/scala/scala/build/Bloop.scala
@@ -6,9 +6,11 @@ import coursier.util.Task
 import dependency.parser.ModuleParser
 import dependency.{AnyDependency, DependencyLike, ScalaParameters, ScalaVersion}
 
-import java.io.File
+import java.io.{File, IOException}
 
+import scala.annotation.tailrec
 import scala.build.EitherCps.{either, value}
+import scala.build.bloop.BuildServer
 import scala.build.blooprifle.BloopRifleConfig
 import scala.build.errors.{BuildException, ModuleFormatError}
 import scala.build.internal.CsLoggerUtil._
@@ -17,33 +19,49 @@ import scala.jdk.CollectionConverters._
 
 object Bloop {
 
+  private object BrokenPipeInCauses {
+    @tailrec
+    def unapply(ex: Throwable): Option[IOException] =
+      ex match {
+        case null                                                           => None
+        case ex: IOException if ex.getMessage == "Broken pipe"              => Some(ex)
+        case ex: IOException if ex.getMessage == "Connection reset by peer" => Some(ex)
+        case _                                                              => unapply(ex.getCause)
+      }
+  }
+
   def compile(
     projectName: String,
-    bloopServer: bloop.BloopServer,
+    buildServer: BuildServer,
     logger: Logger,
     buildTargetsTimeout: FiniteDuration
-  ): Boolean = {
+  ): Either[Throwable, Boolean] =
+    try {
+      logger.debug("Listing BSP build targets")
+      val results = buildServer.workspaceBuildTargets()
+        .get(buildTargetsTimeout.length, buildTargetsTimeout.unit)
+      val buildTargetOpt = results.getTargets.asScala.find(_.getDisplayName == projectName)
 
-    logger.debug("Listing BSP build targets")
-    val results = bloopServer.server.workspaceBuildTargets()
-      .get(buildTargetsTimeout.length, buildTargetsTimeout.unit)
-    val buildTargetOpt = results.getTargets.asScala.find(_.getDisplayName == projectName)
-
-    val buildTarget = buildTargetOpt.getOrElse {
-      throw new Exception(
-        s"Expected to find project '$projectName' in build targets (only got ${results.getTargets.asScala.map("'" + _.getDisplayName + "'").mkString(", ")})"
-      )
-    }
+      val buildTarget = buildTargetOpt.getOrElse {
+        throw new Exception(
+          s"Expected to find project '$projectName' in build targets (only got ${results.getTargets.asScala.map("'" + _.getDisplayName + "'").mkString(", ")})"
+        )
+      }
 
-    logger.debug(s"Compiling $projectName with Bloop")
-    val compileRes = bloopServer.server.buildTargetCompile(
-      new bsp4j.CompileParams(List(buildTarget.getId).asJava)
-    ).get()
+      logger.debug(s"Compiling $projectName with Bloop")
+      val compileRes = buildServer.buildTargetCompile(
+        new bsp4j.CompileParams(List(buildTarget.getId).asJava)
+      ).get()
 
-    val success = compileRes.getStatusCode == bsp4j.StatusCode.OK
-    logger.debug(if (success) "Compilation succeeded" else "Compilation failed")
-    success
-  }
+      val success = compileRes.getStatusCode == bsp4j.StatusCode.OK
+      logger.debug(if (success) "Compilation succeeded" else "Compilation failed")
+      Right(success)
+    }
+    catch {
+      case ex @ BrokenPipeInCauses(e) =>
+        logger.debug(s"Caught $ex while exchanging with Bloop server, assuming Bloop server exited")
+        Left(ex)
+    }
 
   def bloopClassPath(
     dep: AnyDependency,
diff --git a/modules/build/src/main/scala/scala/build/bsp/BspImpl.scala b/modules/build/src/main/scala/scala/build/bsp/BspImpl.scala
@@ -362,18 +362,20 @@ final class BspImpl(
   ): BloopSession = {
     val logger       = reloadableOptions.logger
     val buildOptions = reloadableOptions.buildOptions
-    val bloopServer = BloopServer.buildServer(
-      reloadableOptions.bloopRifleConfig,
-      "scala-cli",
-      Constants.version,
-      (inputs.workspace / Constants.workspaceDirName).toNIO,
-      Build.classesRootDir(inputs.workspace, inputs.projectName).toNIO,
-      localClient,
-      threads.buildThreads.bloop,
-      logger.bloopRifleLogger
-    )
+    val createBloopServer =
+      () =>
+        BloopServer.buildServer(
+          reloadableOptions.bloopRifleConfig,
+          "scala-cli",
+          Constants.version,
+          (inputs.workspace / Constants.workspaceDirName).toNIO,
+          Build.classesRootDir(inputs.workspace, inputs.projectName).toNIO,
+          localClient,
+          threads.buildThreads.bloop,
+          logger.bloopRifleLogger
+        )
     val remoteServer = new BloopCompiler(
-      bloopServer,
+      createBloopServer,
       20.seconds,
       strictBloopJsonCheck = buildOptions.internal.strictBloopJsonCheckOrDefault
     )
diff --git a/modules/build/src/main/scala/scala/build/compiler/BloopCompiler.scala b/modules/build/src/main/scala/scala/build/compiler/BloopCompiler.scala
@@ -1,13 +1,19 @@
 package scala.build.compiler
 
+import scala.annotation.tailrec
 import scala.build.{Bloop, Logger, Position, Positioned, Project, bloop}
 import scala.concurrent.duration.FiniteDuration
 
 final class BloopCompiler(
-  val bloopServer: bloop.BloopServer,
+  createServer: () => bloop.BloopServer,
   buildTargetsTimeout: FiniteDuration,
   strictBloopJsonCheck: Boolean
 ) extends ScalaCompiler {
+  private var currentBloopServer: bloop.BloopServer =
+    createServer()
+  def bloopServer: bloop.BloopServer =
+    currentBloopServer
+
   def jvmVersion: Option[Positioned[Int]] =
     Some(
       Positioned(
@@ -25,8 +31,26 @@ final class BloopCompiler(
   def compile(
     project: Project,
     logger: Logger
-  ): Boolean =
-    Bloop.compile(project.projectName, bloopServer, logger, buildTargetsTimeout)
+  ): Boolean = {
+    @tailrec
+    def helper(remainingAttempts: Int): Boolean =
+      Bloop.compile(project.projectName, bloopServer.server, logger, buildTargetsTimeout) match {
+        case Right(res) => res
+        case Left(ex) =>
+          if (remainingAttempts > 1) {
+            logger.debug(s"Seems Bloop server exited (got $ex), trying to restart one")
+            currentBloopServer = createServer()
+            helper(remainingAttempts - 1)
+          }
+          else
+            throw new Exception(
+              "Seems compilation server exited, and wasn't able to restart one",
+              ex
+            )
+      }
+
+    helper(2)
+  }
 
   def shutdown(): Unit =
     bloopServer.shutdown()
diff --git a/modules/build/src/main/scala/scala/build/compiler/BloopCompilerMaker.scala b/modules/build/src/main/scala/scala/build/compiler/BloopCompilerMaker.scala
@@ -19,16 +19,18 @@ final class BloopCompilerMaker(
     buildClient: BuildClient,
     logger: Logger
   ): BloopCompiler = {
-    val buildServer = BloopServer.buildServer(
-      config,
-      "scala-cli",
-      Constants.version,
-      workspace.toNIO,
-      classesDir.toNIO,
-      buildClient,
-      threads,
-      logger.bloopRifleLogger
-    )
-    new BloopCompiler(buildServer, 20.seconds, strictBloopJsonCheck)
+    val createBuildServer =
+      () =>
+        BloopServer.buildServer(
+          config,
+          "scala-cli",
+          Constants.version,
+          workspace.toNIO,
+          classesDir.toNIO,
+          buildClient,
+          threads,
+          logger.bloopRifleLogger
+        )
+    new BloopCompiler(createBuildServer, 20.seconds, strictBloopJsonCheck)
   }
 }
diff --git a/modules/build/src/test/scala/scala/build/tests/markdown/MarkdownCodeWrapperTests.scala b/modules/build/src/test/scala/scala/build/tests/markdown/MarkdownCodeWrapperTests.scala
@@ -2,7 +2,6 @@ package scala.build.tests.markdown
 
 import scala.build.internal.markdown.{MarkdownCodeBlock, MarkdownCodeWrapper}
 import com.eed3si9n.expecty.Expecty.expect
-import os.RelPath
 
 import scala.build.Position
 import scala.build.errors.{BuildException, MarkdownUnclosedBackticksError}
diff --git a/modules/cli/src/main/scala/scala/cli/commands/dependencyupdate/DependencyUpdate.scala b/modules/cli/src/main/scala/scala/cli/commands/dependencyupdate/DependencyUpdate.scala
@@ -1,7 +1,6 @@
 package scala.cli.commands.dependencyupdate
 
 import caseapp.*
-import os.Path
 
 import scala.build.actionable.ActionableDependencyHandler
 import scala.build.actionable.ActionableDiagnostic.ActionableDependencyUpdateDiagnostic
@@ -102,7 +101,7 @@ object DependencyUpdate extends ScalaCommand[DependencyUpdateOptions] {
   }
 
   private def updateDependencies(
-    file: Path,
+    file: os.Path,
     diagnostics: Seq[(Position.File, ActionableDependencyUpdateDiagnostic)]
   ): String = {
     val fileContent   = os.read(file)
diff --git a/modules/integration/src/test/scala/scala/cli/integration/BloopTests.scala b/modules/integration/src/test/scala/scala/cli/integration/BloopTests.scala
@@ -1,13 +1,14 @@
 package scala.cli.integration
 
 import com.eed3si9n.expecty.Expecty.expect
-import os.proc
 
 import scala.cli.integration.util.BloopUtil
+import scala.concurrent.duration.Duration
+import scala.concurrent.{Await, ExecutionContext, Future}
 
 class BloopTests extends ScalaCliSuite {
 
-  def runScalaCli(args: String*): proc = os.proc(TestUtil.cli, args)
+  def runScalaCli(args: String*): os.proc = os.proc(TestUtil.cli, args)
 
   private lazy val bloopDaemonDir =
     BloopUtil.bloopDaemonDir(runScalaCli("directories").call().out.text())
@@ -139,4 +140,42 @@ class BloopTests extends ScalaCliSuite {
         .call(cwd = root / Constants.workspaceDirName)
     }
   }
+
+  test("Restart Bloop server while watching") {
+    TestUtil.withThreadPool("bloop-restart-test", 2) { pool =>
+      val timeout = Duration("20 seconds")
+      def readLine(stream: os.SubProcess.OutputStream): String = {
+        implicit val ec = ExecutionContext.fromExecutorService(pool)
+        val readLineF = Future {
+          stream.readLine()
+        }
+        Await.result(readLineF, timeout)
+      }
+      def content(message: String) =
+        s"""object Hello {
+           |  def main(args: Array[String]): Unit =
+           |    println("$message")
+           |}
+           |""".stripMargin
+      val sourcePath = os.rel / "Hello.scala"
+      val inputs = TestInputs(
+        sourcePath -> content("Hello")
+      )
+      inputs.fromRoot { root =>
+        val proc = os.proc(TestUtil.cli, "run", "-w", ".")
+          .spawn(cwd = root)
+        val firstLine = readLine(proc.stdout)
+        expect(firstLine == "Hello")
+
+        os.proc(TestUtil.cli, "bloop", "exit")
+          .call(cwd = root)
+
+        os.write.over(root / sourcePath, content("Foo"))
+        val secondLine = readLine(proc.stdout)
+        expect(secondLine == "Foo")
+
+        proc.destroy()
+      }
+    }
+  }
 }
diff --git a/modules/integration/src/test/scala/scala/cli/integration/BspTestDefinitions.scala b/modules/integration/src/test/scala/scala/cli/integration/BspTestDefinitions.scala
@@ -954,9 +954,8 @@ abstract class BspTestDefinitions(val scalaVersionOpt: Option[String])
   test("workspace/reload --dependency option") {
     val inputs = TestInputs(
       os.rel / "ReloadTest.scala" ->
-        s"""import os.pwd
-           |object ReloadTest {
-           |  println(pwd)
+        s"""object ReloadTest {
+           |  println(os.pwd)
            |}
            |""".stripMargin
     )
diff --git a/modules/integration/src/test/scala/scala/cli/integration/PublishTestDefinitions.scala b/modules/integration/src/test/scala/scala/cli/integration/PublishTestDefinitions.scala
@@ -1,7 +1,6 @@
 package scala.cli.integration
 
 import com.eed3si9n.expecty.Expecty.expect
-import os.RelPath
 
 import java.nio.file.Paths
 import java.util.zip.ZipFile
@@ -41,9 +40,9 @@ abstract class PublishTestDefinitions(val scalaVersionOpt: Option[String])
     val scalaSuffix: String =
       if (actualScalaVersion.startsWith("3.")) "_3"
       else "_" + actualScalaVersion.split('.').take(2).mkString(".")
-    val expectedArtifactsDir: RelPath =
+    val expectedArtifactsDir: os.RelPath =
       os.rel / "org" / "virtuslab" / "scalacli" / "test" / s"simple$scalaSuffix" / "0.2.0-SNAPSHOT"
-    val expectedJsArtifactsDir: RelPath =
+    val expectedJsArtifactsDir: os.RelPath =
       os.rel / "org" / "virtuslab" / "scalacli" / "test" / s"simple_sjs1$scalaSuffix" / "0.2.0-SNAPSHOT"
   }
 
diff --git a/modules/integration/src/test/scala/scala/cli/integration/TestUtil.scala b/modules/integration/src/test/scala/scala/cli/integration/TestUtil.scala
@@ -1,7 +1,5 @@
 package scala.cli.integration
 
-import os.{CommandResult, Path}
-
 import java.io.File
 import java.net.ServerSocket
 import java.util.Locale
@@ -78,6 +76,16 @@ object TestUtil {
 
   def threadPool(prefix: String, size: Int): ExecutorService =
     Executors.newFixedThreadPool(size, daemonThreadFactory(prefix))
+  def withThreadPool[T](prefix: String, size: Int)(f: ExecutorService => T): T = {
+    var pool: ExecutorService = null
+    try {
+      pool = threadPool(prefix, size)
+      f(pool)
+    }
+    finally
+      if (pool != null)
+        pool.shutdown()
+  }
 
   def scheduler(prefix: String): ScheduledExecutorService =
     Executors.newSingleThreadScheduledExecutor(daemonThreadFactory(prefix))
@@ -129,13 +137,13 @@ object TestUtil {
   def relPathStr(relPath: os.RelPath): String =
     (Seq.fill(relPath.ups)("..") ++ relPath.segments).mkString(File.separator)
 
-  def kill(pid: Int): CommandResult =
+  def kill(pid: Int): os.CommandResult =
     if (Properties.isWin)
       os.proc("taskkill", "/F", "/PID", pid).call()
     else
       os.proc("kill", pid).call()
 
-  def pwd: Path =
+  def pwd: os.Path =
     if (Properties.isWin)
       os.Path(os.pwd.toIO.getCanonicalFile)
     else
diff --git a/modules/options/src/main/scala/scala/build/Artifacts.scala b/modules/options/src/main/scala/scala/build/Artifacts.scala
@@ -6,7 +6,6 @@ import coursier.parse.RepositoryParser
 import coursier.util.Task
 import coursier.{Dependency => CsDependency, Fetch, Resolution, core => csCore, util => csUtil}
 import dependency.*
-import os.Path
 
 import java.net.URL
 
