address comments

Author: andrewyuq

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLspService.kt

@@ -87,7 +87,6 @@ import java.net.URI
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
 import java.util.concurrent.Future
-import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.seconds
 
 // https://github.com/redhat-developer/lsp4ij/blob/main/src/main/java/com/redhat/devtools/lsp4ij/server/LSPProcessListener.java
@@ -180,31 +179,41 @@ class AmazonQLspService(private val project: Project, private val cs: CoroutineS
         heartbeatJob = cs.launch {
             while (isActive) {
                 delay(5.seconds) // Check every 5 seconds
-                checkConnectionStatus()
+                val shouldLoop = checkConnectionStatus()
+                if (!shouldLoop) {
+                    break
+                }
             }
         }
     }
 
-    private suspend fun checkConnectionStatus() {
+    private suspend fun checkConnectionStatus(): Boolean {
         try {
             val currentInstance = mutex.withLock { instance }.await()
 
             // Check if the launcher's Future (startListening) is done
             // If it's done, that means the connection has been terminated
-            if (currentInstance.launcherFuture.isDone) {
+            if (currentInstance.launcherFuture.isDone || true) {
                 LOG.debug { "LSP server connection terminated, checking restart limits" }
-                waitForRestartSlot()
+                val canRestart = checkForRemainingRestartAttempts()
+                if (!canRestart) {
+                    return false
+                }
                 LOG.debug { "Restarting LSP server" }
                 restart()
             } else {
                 LOG.debug { "LSP server is currently running" }
             }
         } catch (e: Exception) {
             LOG.debug(e) { "Connection status check failed, checking restart limits" }
-            waitForRestartSlot()
+            val canRestart = checkForRemainingRestartAttempts()
+            if (!canRestart) {
+                return false
+            }
             LOG.debug { "Restarting LSP server" }
             restart()
         }
+        return true
     }
 
     override fun dispose() {
@@ -235,7 +244,7 @@ class AmazonQLspService(private val project: Project, private val cs: CoroutineS
         instance = start()
     }
 
-    private suspend fun waitForRestartSlot(): Unit = restartMutex.withLock {
+    private suspend fun checkForRemainingRestartAttempts(): Boolean = restartMutex.withLock {
         val currentTime = System.currentTimeMillis()
 
         while (restartTimestamps.isNotEmpty() &&
@@ -246,21 +255,12 @@ class AmazonQLspService(private val project: Project, private val cs: CoroutineS
 
         if (restartTimestamps.size < MAX_RESTARTS) {
             restartTimestamps.addLast(currentTime)
-            return
+            return true
         }
 
-        val oldestTimestamp = restartTimestamps.first()
-        val waitTimeMs = (oldestTimestamp + RESTART_WINDOW_MS) - currentTime
-
-        LOG.info { "Rate limit reached for LSP server restarts. Waiting ${waitTimeMs}ms for next available slot." }
-
-        restartMutex.unlock()
-        delay(waitTimeMs.milliseconds)
+        LOG.info { "Rate limit reached for LSP server restarts. Stop attempting to restart." }
 
-        // After waiting, recursively call this function to check again
-        // (in case conditions changed while we were waiting)
-        waitForRestartSlot()
-        restartMutex.lock()
+        return false
     }
 
     suspend fun<T> execute(runnable: suspend AmazonQLspService.(AmazonQLanguageServer) -> T): T {
@@ -311,8 +311,7 @@ private class AmazonQServerInstance(private val project: Project, private val cs
         get() = launcher.remoteEndpoint
 
     @Suppress("ForbiddenVoid")
-    var launcherFuture: Future<Void>
-        private set
+    val launcherFuture: Future<Void>
     private val launcherHandler: KillableProcessHandler
     val initializeResult: Deferred<InitializeResult>