feat(debug): better synchronization between test view and execution in intellij-client, part 2

Author: d-biehl

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/debugging/IRobotCodeDebugProtocolServer.kt

@@ -0,0 +1,12 @@
+package dev.robotcode.robotcode4ij.debugging
+
+import org.eclipse.lsp4j.debug.CancelArguments
+import org.eclipse.lsp4j.debug.services.IDebugProtocolServer
+import org.eclipse.lsp4j.jsonrpc.services.JsonRequest
+import java.util.concurrent.CompletableFuture
+
+interface IRobotCodeDebugProtocolServer: IDebugProtocolServer {
+    @JsonRequest("robot/sync") fun robotSync(): CompletableFuture<Void?>? {
+        throw UnsupportedOperationException()
+    }
+}

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/debugging/RobotCodeDebugProtocolClient.kt

@@ -2,6 +2,7 @@ package dev.robotcode.robotcode4ij.debugging
 
 import com.intellij.openapi.diagnostic.thisLogger
 import com.jetbrains.rd.util.reactive.Signal
+import kotlinx.coroutines.future.await
 import org.eclipse.lsp4j.debug.ExitedEventArguments
 import org.eclipse.lsp4j.debug.OutputEventArguments
 import org.eclipse.lsp4j.debug.StoppedEventArguments
@@ -142,6 +143,8 @@ data class RobotLogMessageEventArguments(
 )
 
 @Suppress("unused") class RobotCodeDebugProtocolClient : IDebugProtocolClient {
+    var server: IRobotCodeDebugProtocolServer? = null
+    
     var onStopped = Signal<StoppedEventArguments>()
     val onTerminated = Signal<TerminatedEventArguments?>()
     val onExited = Signal<ExitedEventArguments?>()
@@ -170,39 +173,46 @@ data class RobotLogMessageEventArguments(
         onStopped.fire(args)
     }
 
-    @JsonNotification("robotEnqueued") fun robotEnqueued(args: RobotEnqueuedArguments) {
+    @JsonNotification("robotEnqueued")  fun robotEnqueued(args: RobotEnqueuedArguments) {
         thisLogger().trace("robotEnqueued")
         onRobotEnqueued.fire(args)
+        server?.robotSync()
     }
 
     @JsonNotification("robotStarted") fun robotStarted(args: RobotExecutionEventArguments) {
         thisLogger().trace("robotStarted $args")
         onRobotStarted.fire(args)
+        server?.robotSync()
     }
 
     @JsonNotification("robotEnded") fun robotEnded(args: RobotExecutionEventArguments) {
         thisLogger().trace("robotEnded $args")
         onRobotEnded.fire(args)
+        server?.robotSync()
     }
 
     @JsonNotification("robotSetFailed") fun robotSetFailed(args: RobotExecutionEventArguments) {
         thisLogger().trace("robotSetFailed $args")
         onRobotSetFailed.fire(args)
+        server?.robotSync()
     }
 
     @JsonNotification("robotExited") fun robotExited(args: RobotExitedEventArguments) {
         thisLogger().trace("robotExited")
         onRobotExited.fire(args)
+        server?.robotSync()
     }
 
     @JsonNotification("robotLog") fun robotLog(args: RobotLogMessageEventArguments) {
         thisLogger().trace("robotLog")
         onRobotLog.fire(args)
+        server?.robotSync()
     }
 
     @JsonNotification("robotMessage") fun robotMessage(args: RobotLogMessageEventArguments) {
         thisLogger().trace("robotMessage")
         onRobotMessage.fire(args)
+        server?.robotSync()
     }
 
     override fun output(args: OutputEventArguments) {

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/execution/RobotCodeRunProfileState.kt

@@ -23,6 +23,7 @@ import com.intellij.openapi.util.Ref
 import com.jetbrains.rd.util.reactive.Signal
 import com.jetbrains.rd.util.reactive.adviseEternal
 import dev.robotcode.robotcode4ij.buildRobotCodeCommandLine
+import dev.robotcode.robotcode4ij.debugging.IRobotCodeDebugProtocolServer
 import dev.robotcode.robotcode4ij.debugging.RobotCodeDebugProgramRunner
 import dev.robotcode.robotcode4ij.debugging.RobotCodeDebugProtocolClient
 import dev.robotcode.robotcode4ij.utils.NetUtils.findFreePort
@@ -35,9 +36,7 @@ import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
 import org.eclipse.lsp4j.debug.ConfigurationDoneArguments
 import org.eclipse.lsp4j.debug.InitializeRequestArguments
-import org.eclipse.lsp4j.debug.launch.DSPLauncher
-import org.eclipse.lsp4j.debug.services.IDebugProtocolServer
-import org.eclipse.lsp4j.jsonrpc.Launcher
+import org.eclipse.lsp4j.jsonrpc.debug.DebugLauncher
 import java.net.Socket
 import java.net.SocketTimeoutException
 import kotlin.uuid.ExperimentalUuidApi
@@ -54,7 +53,7 @@ class RobotCodeRunProfileState(private val config: RobotCodeRunConfiguration, en
     }
 
     val debugClient = RobotCodeDebugProtocolClient()
-    lateinit var debugServer: IDebugProtocolServer
+    lateinit var debugServer: IRobotCodeDebugProtocolServer
     var isInitialized = false
         private set
     var isConfigurationDone = false
@@ -63,7 +62,6 @@ class RobotCodeRunProfileState(private val config: RobotCodeRunConfiguration, en
     val afterInitialize = Signal<Unit>()
     val afterConfigurationDone = Signal<Unit>()
 
-    
     init {
         debugClient.onTerminated.adviseEternal {
             if (socket.isConnected) socket.close()
@@ -142,8 +140,8 @@ class RobotCodeRunProfileState(private val config: RobotCodeRunConfiguration, en
                     consoleProperties.state = this
                 }
 
-                var splitterPropertyName = SMTestRunnerConnectionUtil.getSplitterPropertyName(TESTFRAMEWORK_NAME)
-                var consoleView = RobotCodeRunnerConsoleView(consoleProperties, splitterPropertyName)
+                val splitterPropertyName = SMTestRunnerConnectionUtil.getSplitterPropertyName(TESTFRAMEWORK_NAME)
+                val consoleView = RobotCodeRunnerConsoleView(consoleProperties, splitterPropertyName)
                 SMTestRunnerConnectionUtil.initConsoleView(consoleView, TESTFRAMEWORK_NAME)
                 consoleView.attachToProcess(processHandler)
                 consoleRef.set(consoleView)
@@ -192,17 +190,22 @@ class RobotCodeRunProfileState(private val config: RobotCodeRunConfiguration, en
     @OptIn(ExperimentalUuidApi::class) override fun startNotified(event: ProcessEvent) {
         runBlocking(Dispatchers.IO) {
 
-            var port = event.processHandler.getUserData(DEBUG_PORT) ?: throw CantRunException("No debug port found.")
+            val port = event.processHandler.getUserData(DEBUG_PORT) ?: throw CantRunException("No debug port found.")
 
             socket = tryConnectToServerWithTimeout("127.0.0.1", port, 10000, retryIntervalMillis = 100)
                 ?: throw CantRunException("Unable to establish connection to debug server.")
 
-            val launcher: Launcher<IDebugProtocolServer> =
-                DSPLauncher.createClientLauncher(debugClient, socket.getInputStream(), socket.getOutputStream())
+            val launcher = DebugLauncher.createLauncher(
+                debugClient,
+                IRobotCodeDebugProtocolServer::class.java,
+                socket.getInputStream(),
+                socket.getOutputStream()
+            );
 
             launcher.startListening()
 
             debugServer = launcher.remoteProxy
+            debugClient.server = debugServer
 
             val arguments = InitializeRequestArguments().apply {
                 clientID = Uuid.random().toString()

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/execution/RobotOutputToGeneralTestEventsConverter.kt

@@ -9,7 +9,6 @@ import com.intellij.util.Urls.newLocalFileUrl
 import com.intellij.util.Urls.newUrl
 import com.jetbrains.rd.util.lifetime.Lifetime
 import com.jetbrains.rd.util.reactive.adviseEternal
-import com.jetbrains.rd.util.threading.coroutines.adviseSuspend
 import dev.robotcode.robotcode4ij.debugging.RobotExecutionEventArguments
 import jetbrains.buildServer.messages.serviceMessages.ServiceMessage
 import jetbrains.buildServer.messages.serviceMessages.ServiceMessageVisitor
@@ -111,24 +110,11 @@ import org.eclipse.lsp4j.debug.OutputEventArgumentsCategory
             }
         }
 
-        consoleProperties.state?.debugClient?.onRobotStarted?.adviseSuspend(
-            Lifetime.Eternal,
-            myContext,
-            this::robotStarted
+        consoleProperties.state?.debugClient?.onRobotStarted?.advise(            Lifetime.Eternal,            this::robotStarted
         )
-        consoleProperties.state?.debugClient?.onRobotEnded?.adviseSuspend(Lifetime.Eternal, myContext, this::robotEnded)
+        consoleProperties.state?.debugClient?.onRobotEnded?.advise(Lifetime.Eternal, this::robotEnded)
 
-        // TODO: Implement this
-        // consoleProperties.state?.debugClient?.onRobotLog?.adviseEternal { args ->
-        //     val msg = ServiceMessageBuilder.testStdOut("blah")
-        //
-        //     msg.addAttribute("nodeId", args.itemId ?: "0").addAttribute(
-        //         "out", "[${args.level}] ${args.message}\n"
-        //     )
-        //     this.processServiceMessageFromRobot(msg)
-        // }
-        
-        consoleProperties.state?.debugClient?.onOutput?.adviseSuspend(Lifetime.Eternal, myContext) { args ->
+        consoleProperties.state?.debugClient?.onOutput?.advise(Lifetime.Eternal) { args ->
             val msg =
                 if (args.category == OutputEventArgumentsCategory.STDERR) ServiceMessageBuilder.testStdErr(args.category)
                 else ServiceMessageBuilder.testStdOut(args.category)