Check sbt is alive and restart it if necessary

This commis adds a status bar that shows the status of sbt server, and a
timer that periodically checks that sbt server is still alive, starting
a new instance if necessary.

Author: Duhemm

sbt-dotty/src/dotty/tools/sbtplugin/DottyIDEPlugin.scala

@@ -269,6 +269,9 @@ object DottyIDEPlugin extends AutoPlugin {
     Command.process("runCode", state1)
   }
 
+  /** An sbt command that does nothing. We use it to check that sbt server is still alive. */
+  def nopCommand = Command.command("nop")(state => state)
+
   private def projectConfigTask(config: Configuration): Initialize[Task[Option[ProjectConfig]]] = Def.taskDyn {
     val depClasspath = Attributed.data((dependencyClasspath in config).value)
 
@@ -311,7 +314,7 @@ object DottyIDEPlugin extends AutoPlugin {
   )
 
   override def buildSettings: Seq[Setting[_]] = Seq(
-    commands ++= Seq(configureIDE, compileForIDE, launchIDE),
+    commands ++= Seq(configureIDE, compileForIDE, launchIDE, nopCommand),
 
     excludeFromIDE := false,
 

vscode-dotty/src/extension.ts

@@ -24,7 +24,16 @@ let outputChannel: vscode.OutputChannel
 export let client: LanguageClient
 
 /** The sbt process that may have been started by this extension */
-let sbtProcess: ChildProcess
+let sbtProcess: ChildProcess | undefined
+
+/** The status bar where the show the status of sbt server */
+let sbtStatusBar: vscode.StatusBarItem
+
+/** Interval in ms to check that sbt is alive */
+const sbtCheckIntervalMs = 10 * 1000
+
+/** A command that we use to check that sbt is still alive. */
+export const nopCommand = "nop"
 
 const sbtVersion = "1.2.3"
 const sbtArtifact = `org.scala-sbt:sbt-launch:${sbtVersion}`
@@ -96,11 +105,56 @@ export function activate(context: ExtensionContext) {
     }
 
     configuredProject
-      .then(_ => withProgress("Configuring Dotty IDE...", configureIDE(coursierPath)))
+      .then(_ => connectToSbt(coursierPath))
+      .then(sbt => withProgress("Configuring Dotty IDE...", configureIDE(sbt)))
       .then(_ => runLanguageServer(coursierPath, languageServerArtifactFile))
   }
 }
 
+/**
+ * Connect to sbt server (possibly by starting a new instance) and keep verifying that the
+ * connection is still alive. If it dies, restart sbt server.
+ */
+function connectToSbt(coursierPath: string): Thenable<rpc.MessageConnection> {
+  if (!sbtStatusBar) sbtStatusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right)
+  sbtStatusBar.text = "sbt server: connecting $(sync)"
+  sbtStatusBar.show()
+
+  return offeringToRetry(() => {
+    return withSbtInstance(outputChannel, coursierPath).then(connection => {
+      markSbtUp()
+      const interval = setInterval(() => checkSbt(interval, connection, coursierPath), sbtCheckIntervalMs)
+      return connection
+    })
+  }, "Couldn't connect to sbt server (see log for details)")
+}
+
+/** Mark sbt server as alive in the status bar */
+function markSbtUp(timeout?: NodeJS.Timer) {
+  sbtStatusBar.text = "sbt server: up $(check)"
+  if (timeout) clearTimeout(timeout)
+}
+
+/** Mark sbt server as dead and try to reconnect */
+function markSbtDownAndReconnect(coursierPath: string) {
+  sbtStatusBar.text = "sbt server: down $(x)"
+  if (sbtProcess) {
+    sbtProcess.kill()
+    sbtProcess = undefined
+  }
+  connectToSbt(coursierPath)
+}
+
+/** Check that sbt is alive, try to reconnect if it is dead. */
+function checkSbt(interval: NodeJS.Timer, connection: rpc.MessageConnection, coursierPath: string) {
+  sbtserver.tellSbt(outputChannel, connection, nopCommand)
+  .then(_ => markSbtUp(),
+    _ => {
+      clearInterval(interval)
+      markSbtDownAndReconnect(coursierPath)
+    })
+}
+
 export function deactivate() {
   // If sbt was started by this extension, kill the process.
   // FIXME: This will be a problem for other clients of this server.
@@ -123,33 +177,45 @@ function withProgress<T>(title: string, op: Thenable<T>): Thenable<T> {
 }
 
 /** Connect to an sbt server and run `configureIDE`. */
-function configureIDE(coursierPath: string): Thenable<sbtserver.ExecResult> {
-
-  function offeringToRetry(client: rpc.MessageConnection, command: string): Thenable<sbtserver.ExecResult> {
-    return sbtserver.tellSbt(outputChannel, client, command)
-      .then(success => Promise.resolve(success),
-        _ => {
-          outputChannel.show()
-          return vscode.window.showErrorMessage("IDE configuration failed (see logs for details)", "Retry?")
-            .then(retry => {
-              if (retry) return offeringToRetry(client, command)
-              else return Promise.reject()
-            })
-        })
+function configureIDE(sbt: rpc.MessageConnection): Thenable<sbtserver.ExecResult> {
+
+  const tellSbt = (command: string) => {
+    return () => sbtserver.tellSbt(outputChannel, sbt, command)
   }
 
-  return withSbtInstance(outputChannel, coursierPath)
-    .then(client => {
-      // `configureIDE` is a command, which means that upon failure, sbt won't tell us anything
-      // until sbt/sbt#4370 is fixed.
-      // We run `compile` and `test:compile` first because they're tasks (so we get feedback from sbt
-      // in case of failure), and we're pretty sure configureIDE will pass if they passed.
-      return offeringToRetry(client, "compile").then(_ => {
-        return offeringToRetry(client, "test:compile").then(_ => {
-          return offeringToRetry(client, "configureIDE")
-        })
-      })
+  const failMessage = "`configureIDE` failed (see log for details)"
+
+  // `configureIDE` is a command, which means that upon failure, sbt won't tell us anything
+  // until sbt/sbt#4370 is fixed.
+  // We run `compile` and `test:compile` first because they're tasks (so we get feedback from sbt
+  // in case of failure), and we're pretty sure configureIDE will pass if they passed.
+  return offeringToRetry(tellSbt("compile"), failMessage).then(_ => {
+    return offeringToRetry(tellSbt("test:compile"), failMessage).then(_ => {
+      return offeringToRetry(tellSbt("configureIDE"), failMessage)
     })
+  })
+}
+
+/**
+ * Present the user with a dialog to retry `op` after a failure, returns its result in case of
+ * success.
+ *
+ * @param op The operation to perform
+ * @param failMessage The message to display in the dialog offering to retry `op`.
+ * @return A promise that will either resolve to the result of `op`, or a dialog that will let
+ * the user retry the operation.
+ */
+function offeringToRetry<T>(op: () => Thenable<T>, failMessage: string): Thenable<T> {
+  return op()
+    .then(success => Promise.resolve(success),
+      _ => {
+        outputChannel.show()
+        return vscode.window.showErrorMessage(failMessage, "Retry?")
+          .then(retry => {
+            if (retry) return offeringToRetry(op, failMessage)
+            else return Promise.reject()
+          })
+      })
 }
 
 function runLanguageServer(coursierPath: string, languageServerArtifactFile: string) {
@@ -169,31 +235,35 @@ function runLanguageServer(coursierPath: string, languageServerArtifactFile: str
   })
 }
 
+function startNewSbtInstance(log: vscode.OutputChannel, coursierPath: string) {
+  fetchWithCoursier(coursierPath, sbtArtifact).then((sbtClasspath) => {
+    sbtProcess = cpp.spawn("java", [
+      "-Dsbt.log.noformat=true",
+      "-classpath", sbtClasspath,
+      "xsbt.boot.Boot"
+    ]).childProcess
+
+    // Close stdin, otherwise in case of error sbt will block waiting for the
+    // user input to reload or exit the build.
+    sbtProcess.stdin.end()
+
+    sbtProcess.stdout.on('data', data => {
+      log.append(data.toString())
+    })
+    sbtProcess.stderr.on('data', data => {
+      log.append(data.toString())
+    })
+  })
+}
+
 /**
  * Connects to an existing sbt server, or boots up one instance and connects to it.
  */
 function withSbtInstance(log: vscode.OutputChannel, coursierPath: string): Thenable<rpc.MessageConnection> {
   const serverSocketInfo = path.join(workspaceRoot, "project", "target", "active.json")
 
   if (!fs.existsSync(serverSocketInfo)) {
-    fetchWithCoursier(coursierPath, sbtArtifact).then((sbtClasspath) => {
-      sbtProcess = cpp.spawn("java", [
-        "-Dsbt.log.noformat=true",
-        "-classpath", sbtClasspath,
-        "xsbt.boot.Boot"
-      ]).childProcess
-
-      // Close stdin, otherwise in case of error sbt will block waiting for the
-      // user input to reload or exit the build.
-      sbtProcess.stdin.end()
-
-      sbtProcess.stdout.on('data', data => {
-        log.appendLine(data.toString())
-      })
-      sbtProcess.stderr.on('data', data => {
-        log.appendLine(data.toString())
-      })
-    })
+    startNewSbtInstance(log, coursierPath)
   }
 
   return sbtserver.connectToSbtServer(log)

vscode-dotty/src/sbt-server.ts

@@ -18,6 +18,8 @@ import * as rpc from 'vscode-jsonrpc'
 
 import * as vscode from 'vscode'
 
+import { nopCommand } from './extension'
+
 /** The result of successful `sbt/exec` call. */
 export interface ExecResult {
   status: string
@@ -43,45 +45,32 @@ class CommandLine {
  *
  * @return The result of executing `command`.
  */
-export function tellSbt(log: vscode.OutputChannel,
-                        connection: rpc.MessageConnection,
-                        command: string): Thenable<ExecResult> {
+export async function tellSbt(log: vscode.OutputChannel,
+                              connection: rpc.MessageConnection,
+                              command: string): Promise<ExecResult> {
   log.appendLine(`>>> ${command}`)
-  let req = new rpc.RequestType<CommandLine, ExecResult, any, any>("sbt/exec")
-  return connection.sendRequest(req, new CommandLine(command))
+  const req = new rpc.RequestType<CommandLine, ExecResult, any, any>("sbt/exec")
+  return await connection.sendRequest(req, new CommandLine(command))
 }
 
 /**
  * Attempts to connect to an sbt server running in this workspace.
  *
- * If connection fails, shows an error message and ask the user to retry.
- *
  * @param log Where to log messages between VSCode and sbt server.
  */
 export function connectToSbtServer(log: vscode.OutputChannel): Promise<rpc.MessageConnection> {
   return waitForServer().then(socket => {
-    if (socket) {
-      let connection = rpc.createMessageConnection(
-        new rpc.StreamMessageReader(socket),
-        new rpc.StreamMessageWriter(socket))
-
-      connection.listen()
-
-      connection.onNotification("window/logMessage", (params) => {
-        log.appendLine(`<<< [${messageTypeToString(params.type)}] ${params.message}`)
-      })
-
-      return connection
-    } else {
-      return vscode.window.showErrorMessage("Couldn't connect to sbt server.", "Retry?").then(answer => {
-        if (answer) {
-          return connectToSbtServer(log)
-        } else {
-          log.show()
-          return Promise.reject()
-        }
-      })
-    }
+    let connection = rpc.createMessageConnection(
+      new rpc.StreamMessageReader(socket),
+      new rpc.StreamMessageWriter(socket))
+
+    connection.listen()
+
+    connection.onNotification("window/logMessage", (params) => {
+      log.appendLine(`<<< [${messageTypeToString(params.type)}] ${params.message}`)
+    })
+
+    return tellSbt(log, connection, nopCommand).then(_ => connection)
   })
 }
 
@@ -111,8 +100,8 @@ function delay(ms: number) {
 	return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-async function waitForServer(): Promise<net.Socket | null> {
-  let socket: net.Socket | null = null
+async function waitForServer(): Promise<net.Socket> {
+  let socket: net.Socket
   return vscode.window.withProgress({
     location: vscode.ProgressLocation.Window,
     title: "Connecting to sbt server..."
@@ -125,8 +114,9 @@ async function waitForServer(): Promise<net.Socket | null> {
         await delay(1000);
       }
     }
-    return socket
-  }).then(_ => socket)
+    if (socket) return Promise.resolve(socket)
+    else return Promise.reject()
+  })
 }
 
 function messageTypeToString(messageType: number): string {