[feature] implement experimental Bazel JVM target debugging through BSP

Merge-request: BAZEL-MR-563
Merged-by: Marcin Kocot <[email protected]>

Author: mrkocot

logger/src/main/kotlin/org/jetbrains/bsp/bazel/logger/BspClientTestNotifier.kt

@@ -15,14 +15,6 @@ import ch.epfl.scala.bsp4j.TestTask
 
 class BspClientTestNotifier {
   private lateinit var bspClient: BuildClient
-  private var originId: String? = null
-
-  fun withOriginId(originId: String?): BspClientTestNotifier {
-    val bspClientTestNotifier = BspClientTestNotifier()
-    bspClientTestNotifier.originId = originId
-    bspClientTestNotifier.bspClient = bspClient
-    return bspClientTestNotifier
-  }
 
   /**
    * Notifies the client about starting a single test or a test suite

server/src/main/kotlin/org/jetbrains/bsp/bazel/server/BazelBspServer.kt

@@ -56,6 +56,7 @@ class BazelBspServer(
             serverContainer.projectProvider,
             bazelRunner,
             workspaceContextProvider,
+            bspClientLogger,
             bspClientTestNotifier,
             bspState,
         )

server/src/main/kotlin/org/jetbrains/bsp/bazel/server/bsp/BspServerApi.java

@@ -49,10 +49,11 @@
 import ch.epfl.scala.bsp4j.WorkspaceBuildTargetsResult;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
-
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.bsp.bazel.server.sync.BazelBuildServer;
 import org.jetbrains.bsp.bazel.server.sync.ExecuteService;
 import org.jetbrains.bsp.bazel.server.sync.ProjectSyncService;
+import org.jetbrains.bsp.bazel.server.sync.RunWithDebugParams;
 import org.jetbrains.bsp.bazel.server.sync.WorkspaceDirectoriesResult;
 import org.jetbrains.bsp.bazel.server.sync.WorkspaceLibrariesResult;
 
@@ -164,6 +165,12 @@ public CompletableFuture<RunResult> buildTargetRun(RunParams params) {
     return runner.handleRequest("buildTargetRun", executeService::run, params);
   }
 
+  @NotNull
+  @Override
+  public CompletableFuture<RunResult> buildTargetRunWithDebug(@NotNull RunWithDebugParams params) {
+    return runner.handleRequest("buildTargetRunWithDebug", executeService::runWithDebug, params);
+  }
+
   @Override
   public CompletableFuture<CleanCacheResult> buildTargetCleanCache(CleanCacheParams params) {
     return runner.handleRequest("buildTargetCleanCache", executeService::clean, params);
@@ -242,6 +249,7 @@ public CompletableFuture<JvmTestEnvironmentResult> buildTargetJvmTestEnvironment
         "jvmTestEnvironment", projectSyncService::jvmTestEnvironment, params);
   }
 
+  @NotNull
   @Override
   public CompletableFuture<WorkspaceLibrariesResult> workspaceLibraries() {
     return runner.handleRequest("libraries", projectSyncService::workspaceBuildLibraries);

server/src/main/kotlin/org/jetbrains/bsp/bazel/server/sync/BazelBuildServer.kt

@@ -1,6 +1,8 @@
 package org.jetbrains.bsp.bazel.server.sync
 
 import ch.epfl.scala.bsp4j.BuildTargetIdentifier
+import ch.epfl.scala.bsp4j.RunParams
+import ch.epfl.scala.bsp4j.RunResult
 import org.eclipse.lsp4j.jsonrpc.services.JsonRequest
 import java.util.concurrent.CompletableFuture
 
@@ -24,10 +26,25 @@ data class WorkspaceDirectoriesResult(
   val excludedDirectories: List<DirectoryItem>,
 )
 
+data class RemoteDebugData(
+    val debugType: String,
+    val port: Int,
+)
+
+data class RunWithDebugParams(
+        val originId: String,
+        val runParams: RunParams,
+        val debug: RemoteDebugData?,
+)
+
+
 interface BazelBuildServer {
     @JsonRequest("workspace/libraries")
     fun workspaceLibraries(): CompletableFuture<WorkspaceLibrariesResult>
 
     @JsonRequest("workspace/directories")
     fun workspaceDirectories(): CompletableFuture<WorkspaceDirectoriesResult>
+
+    @JsonRequest("buildTarget/runWithDebug")
+    fun buildTargetRunWithDebug(params: RunWithDebugParams): CompletableFuture<RunResult>
 }

server/src/main/kotlin/org/jetbrains/bsp/bazel/server/sync/BspMappings.kt

@@ -28,6 +28,8 @@ object BspMappings {
 
     fun toBspUri(uri: BuildTargetIdentifier): String = uri.uri
 
+    fun toBspUri(module: Module): String = toBspUri(toBspId(module))
+
     fun getModules(project: Project, targets: List<BuildTargetIdentifier>): Set<Module> =
         toLabels(targets).mapNotNull(project::findModule).toSet()
 

server/src/main/kotlin/org/jetbrains/bsp/bazel/server/sync/DebugRunner.kt

@@ -0,0 +1,101 @@
+package org.jetbrains.bsp.bazel.server.sync
+
+import ch.epfl.scala.bsp4j.RunResult
+import ch.epfl.scala.bsp4j.StatusCode
+import org.eclipse.lsp4j.jsonrpc.CancelChecker
+import org.jetbrains.bsp.bazel.bazelrunner.BazelRunner
+import org.jetbrains.bsp.bazel.bazelrunner.params.BazelFlag
+import org.jetbrains.bsp.bazel.server.sync.model.Language
+import org.jetbrains.bsp.bazel.server.sync.model.Module
+
+class DebugRunner(
+    private val bazelRunner: BazelRunner,
+    private val errorMessageSender: (message: String, originId: String) -> Unit,
+) {
+    fun runWithDebug(cancelChecker: CancelChecker, params: RunWithDebugParams, moduleToRun: Module): RunResult {
+        val uri = BspMappings.toBspUri(moduleToRun)
+        val requestedDebugType = DebugType.fromDebugData(params.debug)
+        val debugArguments = generateRunArguments(requestedDebugType)
+        val requestIsValid = verifyDebugRequest(requestedDebugType, moduleToRun, params.originId)
+        return if (requestIsValid) {
+            runBazel(cancelChecker, params, uri, debugArguments)
+        } else {
+            RunResult(StatusCode.ERROR).apply { this.originId = params.originId }
+        }
+    }
+
+    private fun generateRunArguments(debugType: DebugType?): List<String> =
+            when (debugType) {
+                is DebugType.JDWP -> listOf(jdwpArgument(debugType.port))
+                else -> emptyList()
+            }
+
+    /**
+     * @return `true` if the run request is a valid debug request, or is not a debug request at all
+     */
+    private fun verifyDebugRequest (
+            debugType: DebugType?,
+            moduleToRun: Module,
+            originId: String,
+    ): Boolean =
+            when (debugType) {
+                null -> true  // not a debug request, nothing to check
+                is DebugType.JDWP -> {
+                    if (!moduleToRun.isJavaOrKotlin()) {
+                        errorMessageSender("JDWP debugging is only available for Java and Kotlin targets", originId)
+                        false
+                    } else true
+                }
+                is DebugType.UNKNOWN -> {
+                    errorMessageSender("\"${debugType.name}\" is not a supported debugging type", originId)
+                    false
+                }
+            }
+
+    // TODO [#BAZEL-721] - quite a naive predicate, but otherwise we'll need to have rule type info in Module instance
+    private fun Module.isJavaOrKotlin() = languages.contains(Language.JAVA) || languages.contains(Language.KOTLIN)
+
+    /**
+     * If `debugArguments` is empty, run task will be executed normally without any debugging options
+     */
+    private fun runBazel(
+            cancelChecker: CancelChecker,
+            params: RunWithDebugParams,
+            bspUri: String,
+            debugArguments: List<String>,
+    ): RunResult {
+        val bazelProcessResult =
+                bazelRunner.commandBuilder()
+                        .run()
+                        .withArguments(debugArguments)
+                        .withArgument(bspUri)
+                        .withArguments(params.runParams.arguments)
+                        .withFlag(BazelFlag.color(true))
+                        .executeBazelCommand(params.originId)
+                        .waitAndGetResult(cancelChecker)
+        return RunResult(bazelProcessResult.statusCode).apply { originId = params.originId }
+    }
+
+    private fun jdwpArgument(port: Int): String =
+            // all used options are defined in https://docs.oracle.com/javase/8/docs/technotes/guides/jpda/conninv.html#Invocation
+            "--jvmopt=\"-agentlib:jdwp=" +
+                    "transport=dt_socket," +
+                    "server=n," +
+                    "suspend=y," +
+                    "address=localhost:$port," +
+                    "\""
+}
+
+private sealed interface DebugType {
+    data class UNKNOWN(val name: String) : DebugType  // debug type unknown
+    data class JDWP(val port: Int) : DebugType  // used for Java and Kotlin
+
+    companion object {
+        fun fromDebugData(params: RemoteDebugData?): DebugType? =
+                when (params?.debugType?.lowercase()) {
+                    null -> null
+                    "jdwp" -> JDWP(params.port)
+                    else -> UNKNOWN(params.debugType)
+                }
+    }
+}

server/src/main/kotlin/org/jetbrains/bsp/bazel/server/sync/ExecuteService.kt

@@ -13,14 +13,14 @@ import ch.epfl.scala.bsp4j.TestParams
 import ch.epfl.scala.bsp4j.TestResult
 import ch.epfl.scala.bsp4j.TestStatus
 import ch.epfl.scala.bsp4j.TextDocumentIdentifier
-import io.grpc.Server
 import org.eclipse.lsp4j.jsonrpc.CancelChecker
 import org.eclipse.lsp4j.jsonrpc.ResponseErrorException
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseError
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseErrorCode
 import org.jetbrains.bsp.bazel.bazelrunner.BazelProcessResult
 import org.jetbrains.bsp.bazel.bazelrunner.BazelRunner
 import org.jetbrains.bsp.bazel.bazelrunner.params.BazelFlag
+import org.jetbrains.bsp.bazel.logger.BspClientLogger
 import org.jetbrains.bsp.bazel.logger.BspClientTestNotifier
 import org.jetbrains.bsp.bazel.server.bep.BepServer
 import org.jetbrains.bsp.bazel.server.bsp.managers.BazelBspCompilationManager
@@ -37,12 +37,17 @@ class ExecuteService(
     private val projectProvider: ProjectProvider,
     private val bazelRunner: BazelRunner,
     private val workspaceContextProvider: WorkspaceContextProvider,
+    private val bspClientLogger: BspClientLogger,
     private val bspClientTestNotifier: BspClientTestNotifier,
     private val hasAnyProblems: Map<String, Set<TextDocumentIdentifier>>
 ) {
-    private fun <T> withBepServer(body : (BepReader) -> T) :T {
+    private val debugRunner = DebugRunner(bazelRunner) { message, originId ->
+        bspClientLogger.withOriginId(originId).error(message)
+    }
+
+    private fun <T> withBepServer(body : (BepReader) -> T): T {
         val server = BepServer.newBepServer(compilationManager.client, compilationManager.workspaceRoot, hasAnyProblems, Optional.empty())
-        val bepReader = BepReader(server);
+        val bepReader = BepReader(server)
         return body(bepReader)
     }
 
@@ -95,16 +100,7 @@ class ExecuteService(
 
     fun run(cancelChecker: CancelChecker, params: RunParams): RunResult {
         val targets = selectTargets(cancelChecker, listOf(params.target))
-        if (targets.isEmpty()) {
-            throw ResponseErrorException(
-                ResponseError(
-                    ResponseErrorCode.InvalidRequest,
-                    "No supported target found for " + params.target.uri,
-                    null
-                )
-            )
-        }
-        val bspId = targets.single()
+        val bspId = targets.singleOrResponseError(params.target)
         val result = build(cancelChecker, targets, params.originId)
         if (result.isNotSuccess) {
             return RunResult(result.statusCode)
@@ -120,6 +116,18 @@ class ExecuteService(
         return RunResult(bazelProcessResult.statusCode).apply { originId = originId }
     }
 
+    fun runWithDebug(cancelChecker: CancelChecker, params: RunWithDebugParams): RunResult {
+        val modules = selectModules(cancelChecker, listOf(params.runParams.target))
+        val singleModule = modules.singleOrResponseError(params.runParams.target)
+        val bspId = toBspId(singleModule)
+        val result = build(cancelChecker, listOf(bspId), params.originId)
+        if (result.isNotSuccess) {
+            return RunResult(result.statusCode)
+        }
+        return debugRunner.runWithDebug(cancelChecker, params, singleModule)
+    }
+
+    @Suppress("UNUSED_PARAMETER")  // params is used by BspRequestsRunner.handleRequest
     fun clean(cancelChecker: CancelChecker, params: CleanCacheParams?): CleanCacheResult {
         withBepServer { bepReader ->
             bazelRunner.commandBuilder().clean()
@@ -137,11 +145,13 @@ class ExecuteService(
         ).processResult
     }
 
-    private fun selectTargets(cancelChecker: CancelChecker, targets: List<BuildTargetIdentifier>): List<BuildTargetIdentifier> {
+    private fun selectTargets(cancelChecker: CancelChecker, targets: List<BuildTargetIdentifier>): List<BuildTargetIdentifier> =
+            selectModules(cancelChecker, targets).map { toBspId(it) }
+
+    private fun selectModules(cancelChecker: CancelChecker, targets: List<BuildTargetIdentifier>): List<Module> {
         val project = projectProvider.get(cancelChecker)
         val modules = BspMappings.getModules(project, targets)
-        val modulesToBuild = modules.filter { isBuildable(it) }
-        return modulesToBuild.map(::toBspId)
+        return modules.filter { isBuildable(it) }
     }
 
     private fun isBuildable(m: Module): Boolean =
@@ -153,3 +163,17 @@ class ExecuteService(
                 workspaceContextProvider.currentWorkspaceContext().buildManualTargets.value)
 
 }
+
+private fun <T> List<T>.singleOrResponseError(
+    requestedTarget: BuildTargetIdentifier,
+): T =
+    when {
+        this.isEmpty() -> throwResponseError("No supported target found for ${requestedTarget.uri}")
+        this.size == 1 -> this.single()
+        else -> throwResponseError("More than one supported target found for ${requestedTarget.uri}")
+    }
+
+private fun throwResponseError(message: String, data: Any? = null): Nothing =
+    throw ResponseErrorException(
+        ResponseError(ResponseErrorCode.InvalidRequest, message, data)
+    )