Merge pull request #564 from romanowski/bsp-recover

In case of error from bloop shout down bsp server

Author: romanowski

modules/build/src/main/scala/scala/build/bsp/BspImpl.scala

@@ -352,6 +352,7 @@ final class BspImpl(
       .create()
     val remoteClient = launcher.getRemoteProxy
     actualLocalClient.forwardToOpt = Some(remoteClient)
+    actualLocalServer.onConnectWithClient(actualLocalClient)
 
     for (targetId <- actualLocalServer.targetIds)
       inputs.flattened().foreach {

modules/build/src/main/scala/scala/build/bsp/BspServer.scala

@@ -1,8 +1,10 @@
 package scala.build.bsp
 
+import ch.epfl.scala.bsp4j.{BuildClient, LogMessageParams, MessageType}
 import ch.epfl.scala.{bsp4j => b}
 
-import java.util.concurrent.CompletableFuture
+import java.io.{PrintWriter, StringWriter}
+import java.util.concurrent.{CompletableFuture, TimeUnit}
 import java.{util => ju}
 
 import scala.build.Logger
@@ -11,6 +13,7 @@ import scala.build.internal.Constants
 import scala.build.options.Scope
 import scala.concurrent.{Future, Promise}
 import scala.jdk.CollectionConverters._
+import scala.util.Random
 
 class BspServer(
   bloopServer: b.BuildServer with b.ScalaBuildServer with b.JavaBuildServer with ScalaDebugServer,
@@ -21,11 +24,30 @@ class BspServer(
     with ScalaDebugServerForwardStubs
     with ScalaBuildServerForwardStubs with JavaBuildServerForwardStubs with HasGeneratedSources {
 
+  private var client: Option[BuildClient] = None
+
+  override def onConnectWithClient(client: BuildClient): Unit = this.client = Some(client)
+
   private var extraDependencySources: Seq[os.Path] = Nil
   def setExtraDependencySources(sourceJars: Seq[os.Path]): Unit = {
     extraDependencySources = sourceJars
   }
 
+  // Can we accept some errors in some circumstances?
+  override protected def onFatalError(throwable: Throwable, context: String): Unit = {
+    val sw = new StringWriter()
+    throwable.printStackTrace(new PrintWriter(sw))
+    val message =
+      s"Fatal error has occured within $context. Shutting down the server:\n ${sw.toString}"
+    System.err.println(message)
+    client.foreach(_.onBuildLogMessage(new LogMessageParams(MessageType.ERROR, message)))
+
+    // wait random bit before shutting down server to reduce risk of multiple scala-cli instances starting bloop at the same time
+    val timeout = Random.nextInt(400)
+    TimeUnit.MILLISECONDS.sleep(100 + timeout)
+    sys.exit(1)
+  }
+
   private def maybeUpdateProjectTargetUri(res: b.WorkspaceBuildTargetsResult): Unit =
     for {
       (_, n) <- projectNames.iterator

modules/build/src/main/scala/scala/build/bsp/BuildServerForwardStubs.scala

@@ -4,40 +4,82 @@ import ch.epfl.scala.bsp4j.{DependencyModulesParams, DependencyModulesResult}
 import ch.epfl.scala.{bsp4j => b}
 
 import java.util.concurrent.CompletableFuture
+import java.util.function.BiFunction
 
 trait BuildServerForwardStubs extends b.BuildServer {
   protected def forwardTo: b.BuildServer
+
+  protected def onFatalError(throwable: Throwable, context: String): Unit
+
+  def fatalExceptionHandler[T](methodName: String, params: Any*) = new BiFunction[T, Throwable, T] {
+    override def apply(maybeValue: T, maybeException: Throwable): T =
+      maybeException match {
+        case null =>
+          maybeValue
+        case error =>
+          val methodContext = s"bloop bsp server, method: $methodName"
+          val context =
+            if (params.isEmpty) methodContext
+            else
+              params.mkString(s"$methodContext, with params: ", ", ", "")
+          onFatalError(error, context)
+          throw error
+      }
+  }
+
   override def buildShutdown(): CompletableFuture[Object] =
-    forwardTo.buildShutdown()
+    forwardTo.buildShutdown().handleAsync(fatalExceptionHandler("buildShutdown"))
+
   override def buildTargetCleanCache(
     params: b.CleanCacheParams
   ): CompletableFuture[b.CleanCacheResult] =
     forwardTo.buildTargetCleanCache(params)
+      .handleAsync(fatalExceptionHandler("buildTargetCleanCache", params))
+
   override def buildTargetCompile(params: b.CompileParams): CompletableFuture[b.CompileResult] =
     forwardTo.buildTargetCompile(params)
+      .handleAsync(fatalExceptionHandler("buildTargetCompile", params))
+
   override def buildTargetDependencySources(
     params: b.DependencySourcesParams
   ): CompletableFuture[b.DependencySourcesResult] =
     forwardTo.buildTargetDependencySources(params)
+      .handleAsync(fatalExceptionHandler("buildTargetDependencySources", params))
+
   override def buildTargetInverseSources(
     params: b.InverseSourcesParams
   ): CompletableFuture[b.InverseSourcesResult] =
     forwardTo.buildTargetInverseSources(params)
+      .handleAsync(fatalExceptionHandler("buildTargetInverseSources", params))
+
   override def buildTargetResources(
     params: b.ResourcesParams
   ): CompletableFuture[b.ResourcesResult] =
     forwardTo.buildTargetResources(params)
+      .handleAsync(fatalExceptionHandler("buildTargetResources", params))
+
   override def buildTargetRun(params: b.RunParams): CompletableFuture[b.RunResult] =
     forwardTo.buildTargetRun(params)
+      .handleAsync(fatalExceptionHandler("buildTargetRun", params))
+
   override def buildTargetSources(params: b.SourcesParams): CompletableFuture[b.SourcesResult] =
     forwardTo.buildTargetSources(params)
+      .handleAsync(fatalExceptionHandler("buildTargetSources", params))
+
   override def buildTargetTest(params: b.TestParams): CompletableFuture[b.TestResult] =
     forwardTo.buildTargetTest(params)
+      .handleAsync(fatalExceptionHandler("buildTargetTest", params))
+
   override def workspaceBuildTargets(): CompletableFuture[b.WorkspaceBuildTargetsResult] =
     forwardTo.workspaceBuildTargets()
+      .handleAsync(fatalExceptionHandler("workspaceBuildTargets"))
+
   override def workspaceReload(): CompletableFuture[Object] =
     forwardTo.workspaceReload()
+      .handleAsync(fatalExceptionHandler("workspaceReload"))
+
   override def buildTargetDependencyModules(params: DependencyModulesParams)
     : CompletableFuture[DependencyModulesResult] =
     forwardTo.buildTargetDependencyModules(params)
+      .handleAsync(fatalExceptionHandler("buildTargetDependencyModules", params))
 }