fix: stop workspace if server process was stopped (#23579)

Signed-off-by: Andre Dietisheim <[email protected]>

Author: adietish

src/main/kotlin/com/redhat/devtools/gateway/DevSpacesConnection.kt

@@ -18,9 +18,14 @@ import com.redhat.devtools.gateway.openshift.DevWorkspaces
 import com.redhat.devtools.gateway.openshift.Pods
 import com.redhat.devtools.gateway.server.RemoteIDEServer
 import io.kubernetes.client.openapi.ApiException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.io.Closeable
 import java.io.IOException
 import java.net.ServerSocket
 import java.net.URI
+import java.util.concurrent.TimeUnit
 
 class DevSpacesConnection(private val devSpacesContext: DevSpacesContext) {
     @Throws(Exception::class)
@@ -53,12 +58,11 @@ class DevSpacesConnection(private val devSpacesContext: DevSpacesContext) {
             ?: throw IOException("Could not connect, remote IDE is not ready. No join link present.")
 
         val pods = Pods(devSpacesContext.client)
-        // ✅ Dynamically find a free local port
         val localPort = findFreePort()
         val forwarder = pods.forward(remoteIdeServer.pod, localPort, 5990)
         pods.waitForForwardReady(localPort)
         val effectiveJoinLink = joinLink.replace(":5990", ":$localPort")
-        
+
         val client = LinkedClientManager
             .getInstance()
             .startNewClient(
@@ -69,30 +73,34 @@ class DevSpacesConnection(private val devSpacesContext: DevSpacesContext) {
                 false
             )
 
-        client.run {
-            lifetime.onTermination {
-                try {
-                    forwarder.close()
-                } catch (_: Exception) {
-                    // Ignore cleanup errors
-                }
-            }
-            lifetime.onTermination {
-                if (remoteIdeServer.waitServerTerminated())
-                    DevWorkspaces(devSpacesContext.client)
-                        .stop(
-                            devSpacesContext.devWorkspace.namespace,
-                            devSpacesContext.devWorkspace.name
-                        )
-                        .also { onDevWorkspaceStopped() }
-            }
-            lifetime.onTermination { devSpacesContext.isConnected = false }
-            lifetime.onTermination(onDisconnected)
+        client.clientClosed.advise(client.lifetime) {
+            onClientClosed(onDisconnected, remoteIdeServer, onDevWorkspaceStopped, forwarder)
         }
 
         return client
     }
 
+    private fun onClientClosed(
+        onDisconnected: () -> Unit,
+        remoteIdeServer: RemoteIDEServer,
+        onDevWorkspaceStopped: () -> Unit,
+        forwarder: Closeable
+    ) {
+        CoroutineScope(Dispatchers.IO).launch {
+            onDisconnected.invoke()
+            if (remoteIdeServer.waitServerTerminated()) {
+                DevWorkspaces(devSpacesContext.client)
+                    .stop(
+                        devSpacesContext.devWorkspace.namespace,
+                        devSpacesContext.devWorkspace.name
+                    )
+                    .also { onDevWorkspaceStopped() }
+            }
+            forwarder.close()
+            devSpacesContext.isConnected = false
+        }
+    }
+
     private fun findFreePort(): Int {
         ServerSocket(0).use { socket ->
             socket.reuseAddress = true

src/main/kotlin/com/redhat/devtools/gateway/openshift/Pods.kt

@@ -170,6 +170,7 @@ class Pods(private val client: ApiClient) {
                     logger.info("Attempt #${attempt + 1}: Connecting $localPort -> $remotePort...")
                     val portForward = PortForward(client)
                     forwardResult = portForward.forward(pod, listOf(remotePort))
+                    logger.info("forward successful: $localPort -> $remotePort...")
                     copyStreams(clientSocket, forwardResult, remotePort)
                     return
                 } catch (e: Exception) {

src/main/kotlin/com/redhat/devtools/gateway/server/RemoteIDEServer.kt

@@ -19,8 +19,10 @@ import com.redhat.devtools.gateway.DevSpacesContext
 import com.redhat.devtools.gateway.openshift.Pods
 import io.kubernetes.client.openapi.models.V1Container
 import io.kubernetes.client.openapi.models.V1Pod
-import org.bouncycastle.util.Arrays
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withTimeoutOrNull
 import java.io.IOException
+import kotlin.time.Duration.Companion.seconds
 
 /**
  * Represent an IDE server running in a CDE.
@@ -68,8 +70,8 @@ class RemoteIDEServer(private val devSpacesContext: DevSpacesContext) {
     }
 
     @Throws(IOException::class)
-    fun waitServerReady() {
-        doWaitServerState(true)
+    suspend fun waitServerReady() {
+        doWaitServerProjectExists(true)
             .also {
                 if (!it) throw IOException(
                     "Remote IDE server is not ready after $readyTimeout seconds.",
@@ -78,19 +80,38 @@ class RemoteIDEServer(private val devSpacesContext: DevSpacesContext) {
     }
 
     @Throws(IOException::class)
-    fun waitServerTerminated(): Boolean {
-        return doWaitServerState(false)
+    suspend fun waitServerTerminated(): Boolean {
+        return doWaitServerProjectExists(false)
     }
 
-    @Throws(IOException::class)
-    fun doWaitServerState(isReadyState: Boolean): Boolean {
-        return try {
-            val status = getStatus()
-            isReadyState == !Arrays.isNullOrEmpty(status.projects)
-        } catch (e: Exception) {
-            thisLogger().debug("Failed to check remote IDE server state.", e)
-            false
-        }
+    /**
+     * Waits for the server to have or not have projects according to the given parameter.
+     * Times out the wait if the expected state is not reached within 10 seconds.
+     *
+     * @param expected True if projects are expected, False otherwise,
+     * @return True if the expected state is achieved within the timeout, False otherwise.
+     */
+    private suspend fun doWaitServerProjectExists(expected: Boolean): Boolean {
+        val timeout = 10.seconds
+
+        return withTimeoutOrNull(timeout) {
+            while (true) {
+                val hasProjects = try {
+                    val status = getStatus()
+                    status.projects.isNotEmpty()
+                } catch (e: Exception) {
+                    thisLogger().debug("Failed to check remote IDE server state.", e)
+                    null
+                }
+
+                if (expected == hasProjects) {
+                    return@withTimeoutOrNull true
+                }
+
+                delay(500L)
+            }
+            true
+        } ?: false
     }
 
     @Throws(IOException::class)