Merge pull request #32 from lstreckeisen/CMI-95-Improve-Language-Server-Command-error-handling

lstreckeisen · web-flow · commit 33009942bedf · 2025-05-21T18:01:48.000+02:00
Cmi 95 improve language server command error handling
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -44,7 +44,7 @@ intellijPlatform {
     pluginConfiguration {
         id = "org.contextmapper.intellij-plugin"
         name = "ContextMapper"
-        version = "0.3.0"
+        version = "0.3.1"
 
         productDescriptor {
         }
@@ -89,6 +89,7 @@ intellijPlatform {
 kotlin {
     compilerOptions {
         jvmTarget.set(JvmTarget.JVM_17)
+        allWarningsAsErrors = true
     }
 }
 
diff --git a/lsp/package.json b/lsp/package.json
@@ -2,6 +2,6 @@
   "name": "context-mapper-intellij-plugin",
   "private": true,
   "dependencies": {
-    "@lstreckeisen/context-mapper-language-server": "0.4.0"
+    "@lstreckeisen/context-mapper-language-server": "0.4.1"
   }
 }
diff --git a/src/main/kotlin/org/contextmapper/intellij/actions/PlantUMLAction.kt b/src/main/kotlin/org/contextmapper/intellij/actions/PlantUMLAction.kt
@@ -5,8 +5,10 @@ import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.vfs.LocalFileSystem
+import com.redhat.devtools.lsp4ij.LanguageServerManager
 import com.redhat.devtools.lsp4ij.commands.CommandExecutor
 import org.contextmapper.intellij.actions.generators.ContextMapperGenerator
+import org.contextmapper.intellij.actions.generators.HandledGeneratorException
 import org.contextmapper.intellij.utils.showErrorNotification
 import org.contextmapper.intellij.utils.showInfoNotification
 import org.eclipse.lsp4j.Command
@@ -15,7 +17,7 @@ import kotlin.io.path.Path
 private val logger = Logger.getInstance(PlantUMLAction::class.java)
 
 class PlantUMLAction : AnAction() {
-    private val generator = ContextMapperGenerator { context -> CommandExecutor.executeCommand(context) }
+    private val commandExecutor: LspCommandExecutor = { context -> CommandExecutor.executeCommand(context) }
 
     override fun actionPerformed(event: AnActionEvent) {
         val project = event.project
@@ -31,13 +33,16 @@ class PlantUMLAction : AnAction() {
         val commandArgs = listOf(file.path, outDir)
         val command = Command("Generate PlantUML Diagrams", PLANT_UML_GENERATOR_COMMAND, commandArgs)
 
+        val generator = ContextMapperGenerator(commandExecutor, LanguageServerManager.getInstance(project))
         generator.generate(project, command)
             .whenComplete { result, ex ->
                 if (ex != null || result.isFailure) {
+                    val resultError = result.exceptionOrNull()
                     val errorMessage =
-                        if (ex != null) {
+                        if (resultError == null) {
                             "An unexpected error occurred while generating PlantUML diagrams"
                         } else {
+                            if (resultError is HandledGeneratorException) return@whenComplete
                             result.exceptionOrNull()!!.message!!
                         }
 
@@ -51,8 +56,8 @@ class PlantUMLAction : AnAction() {
                     showInfoNotification(project, "No PlantUML diagrams were created")
                 } else {
                     showInfoNotification(project, "Successfully created ${generatedFiles.size} PlantUML diagram(s)")
+                    LocalFileSystem.getInstance().refresh(true)
                 }
-                LocalFileSystem.getInstance().refresh(true)
             }
     }
 }
diff --git a/src/main/kotlin/org/contextmapper/intellij/actions/generators/ContextMapperGenerator.kt b/src/main/kotlin/org/contextmapper/intellij/actions/generators/ContextMapperGenerator.kt
@@ -1,6 +1,8 @@
 package org.contextmapper.intellij.actions.generators
 
 import com.intellij.openapi.project.Project
+import com.redhat.devtools.lsp4ij.LanguageServerItem
+import com.redhat.devtools.lsp4ij.LanguageServerManager
 import com.redhat.devtools.lsp4ij.commands.CommandExecutor
 import com.redhat.devtools.lsp4ij.commands.LSPCommandContext
 import kotlinx.coroutines.CoroutineScope
@@ -9,19 +11,28 @@ import kotlinx.coroutines.launch
 import org.contextmapper.intellij.actions.LspCommandExecutor
 import org.contextmapper.intellij.utils.CONTEXT_MAPPER_SERVER_ID
 import org.eclipse.lsp4j.Command
+import org.eclipse.lsp4j.jsonrpc.ResponseErrorException
 import java.util.concurrent.CompletableFuture
 
 class ContextMapperGenerator(
-    private val commandExecutor: LspCommandExecutor
+    private val commandExecutor: LspCommandExecutor,
+    private val languageServerManager: LanguageServerManager
 ) {
     fun generate(
         project: Project,
         command: Command
     ): CompletableFuture<Result<GeneratorResult>> {
+        val future = CompletableFuture<Result<GeneratorResult>>()
+
         val context = LSPCommandContext(command, project)
-        context.preferredLanguageServerId = CONTEXT_MAPPER_SERVER_ID
 
-        val future = CompletableFuture<Result<GeneratorResult>>()
+        val languageServerResult = getLanguageServer()
+        if (languageServerResult.isFailure) {
+            future.complete(Result.failure(languageServerResult.exceptionOrNull()!!))
+            return future
+        }
+        context.preferredLanguageServerId = CONTEXT_MAPPER_SERVER_ID
+        context.preferredLanguageServer = languageServerResult.getOrNull()
 
         val response = commandExecutor(context)
         CoroutineScope(Dispatchers.IO).launch {
@@ -40,19 +51,12 @@ class ContextMapperGenerator(
             try {
                 val returnedValue = result.join()
 
-                val generatedFiles: List<String> =
-                    if (returnedValue is List<*>) {
-                        val files = returnedValue.filterIsInstance<String>()
-                        if (files.size != returnedValue.size) {
-                            future.complete(Result.failure(ContextMapperGeneratorException("Generator returned unexpected result type.")))
-                            return
-                        }
-                        files
-                    } else {
-                        future.complete(Result.failure(ContextMapperGeneratorException("Generator returned unexpected result type.")))
-                        return
-                    }
+                val generatedFilesResult = extractGeneratedFiles(returnedValue)
+                if (generatedFilesResult.isFailure) {
+                    future.complete(Result.failure(generatedFilesResult.exceptionOrNull()!!))
+                }
 
+                val generatedFiles = generatedFilesResult.getOrNull()!!
                 if (generatedFiles.isEmpty()) {
                     future.complete(Result.success(GeneratorResult(listOf())))
                 } else {
@@ -72,4 +76,41 @@ class ContextMapperGenerator(
             future.complete(Result.failure(ContextMapperGeneratorException("Generator failed without error")))
         }
     }
+
+    private fun getLanguageServer(): Result<LanguageServerItem?> {
+        return try {
+            val languageServer =
+                languageServerManager.getLanguageServer(CONTEXT_MAPPER_SERVER_ID)
+                    .join()
+            Result.success(languageServer)
+        } catch (ex: Exception) {
+            Result.failure(
+                ContextMapperGeneratorException(
+                    "Could not find language server instance.",
+                    ex,
+                ),
+            )
+        }
+    }
+
+    private fun extractGeneratedFiles(returnedValue: Any): Result<List<String>> {
+        when (returnedValue) {
+            is List<*> -> {
+                val files = returnedValue.filterIsInstance<String>()
+                if (files.size != returnedValue.size) {
+                    return Result.failure(ContextMapperGeneratorException("Generator returned unexpected result type."))
+                }
+                return Result.success(files)
+            }
+
+            is ResponseErrorException -> {
+                // ResponseErrors are already handled by LSP4IJ
+                return Result.failure(HandledGeneratorException())
+            }
+
+            else -> {
+                return Result.failure(ContextMapperGeneratorException("Generator returned unexpected result type."))
+            }
+        }
+    }
 }
diff --git a/src/main/kotlin/org/contextmapper/intellij/actions/generators/HandledGeneratorException.kt b/src/main/kotlin/org/contextmapper/intellij/actions/generators/HandledGeneratorException.kt
@@ -0,0 +1,3 @@
+package org.contextmapper.intellij.actions.generators
+
+class HandledGeneratorException : Exception()
diff --git a/src/test/kotlin/org/contextmapper/intellij/actions/generators/ContextMapperGeneratorTest.kt b/src/test/kotlin/org/contextmapper/intellij/actions/generators/ContextMapperGeneratorTest.kt
@@ -1,14 +1,17 @@
 package org.contextmapper.intellij.actions.generators
 
 import com.intellij.openapi.project.Project
+import com.redhat.devtools.lsp4ij.LanguageServerManager
 import com.redhat.devtools.lsp4ij.commands.CommandExecutor
 import com.redhat.devtools.lsp4ij.settings.UserDefinedLanguageServerSettings
 import io.mockk.CapturingSlot
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.slot
 import org.contextmapper.intellij.actions.LspCommandExecutor
+import org.contextmapper.intellij.utils.CONTEXT_MAPPER_SERVER_ID
 import org.eclipse.lsp4j.Command
+import org.eclipse.lsp4j.jsonrpc.ResponseErrorException
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNotNull
 import org.junit.jupiter.api.Assertions.assertTrue
@@ -20,13 +23,21 @@ class ContextMapperGeneratorTest() {
 
     private lateinit var successMessage: CapturingSlot<String>
     private lateinit var lspCommandExecutor: LspCommandExecutor
+    private lateinit var languageServerManager: LanguageServerManager
     private lateinit var project: Project
     private lateinit var generator: ContextMapperGenerator
 
     @BeforeEach
     fun setup() {
         successMessage = slot()
         lspCommandExecutor = mockk(relaxed = true)
+        languageServerManager =
+            mockk(relaxed = true) {
+                every { getLanguageServer(any()) } returns
+                    mockk {
+                        every { join() } returns mockk(relaxed = true)
+                    }
+            }
         project =
             mockk {
                 every { basePath } returns "/tmp"
@@ -35,7 +46,7 @@ class ContextMapperGeneratorTest() {
                         relaxed = true,
                     )
             }
-        generator = ContextMapperGenerator(lspCommandExecutor)
+        generator = ContextMapperGenerator(lspCommandExecutor, languageServerManager)
     }
 
     @Test
@@ -110,4 +121,39 @@ class ContextMapperGeneratorTest() {
         assertTrue(result.isFailure)
         assertTrue { result.exceptionOrNull() is ContextMapperGeneratorException }
     }
+
+    @Test
+    fun testFailedGenerationWithHandledException() {
+        every { lspCommandExecutor.invoke(any()) } returns
+            mockk<CommandExecutor.LSPCommandResponse> {
+                every { response } returns
+                    mockk {
+                        every { join() } returns mockk<ResponseErrorException>()
+                    }
+            }
+
+        val result =
+            generator.generate(project, command)
+                .join()
+
+        assertNotNull(result)
+        assertTrue { result.isFailure }
+        assertTrue { result.exceptionOrNull() is HandledGeneratorException }
+    }
+
+    @Test
+    fun testGeneratorWithMissingLanguageServer() {
+        every { languageServerManager.getLanguageServer(eq(CONTEXT_MAPPER_SERVER_ID)) } returns
+            mockk {
+                every { join() } throws RuntimeException()
+            }
+
+        val result =
+            generator.generate(project, command)
+                .join()
+
+        assertNotNull(result)
+        assertTrue { result.isFailure }
+        assertTrue { result.exceptionOrNull() is ContextMapperGeneratorException }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ intellijPlatform {`
`44`	`44`	`pluginConfiguration {`
`45`	`45`	`id = "org.contextmapper.intellij-plugin"`
`46`	`46`	`name = "ContextMapper"`
`47`		`- version = "0.3.0"`
	`47`	`+ version = "0.3.1"`
`48`	`48`
`49`	`49`	`productDescriptor {`
`50`	`50`	`}`
`@@ -89,6 +89,7 @@ intellijPlatform {`
`89`	`89`	`kotlin {`
`90`	`90`	`compilerOptions {`
`91`	`91`	`jvmTarget.set(JvmTarget.JVM_17)`
	`92`	`+ allWarningsAsErrors = true`
`92`	`93`	`}`
`93`	`94`	`}`
`94`	`95`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,6 @@`
`2`	`2`	`"name": "context-mapper-intellij-plugin",`
`3`	`3`	`"private": true,`
`4`	`4`	`"dependencies": {`
`5`		`- "@lstreckeisen/context-mapper-language-server": "0.4.0"`
	`5`	`+ "@lstreckeisen/context-mapper-language-server": "0.4.1"`
`6`	`6`	`}`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+package org.contextmapper.intellij.actions.generators`
	`2`	`+`
	`3`	`+class HandledGeneratorException : Exception()`