Wait for workspace to stop before updating

It turns out if you try to send the update right after stopping it will
say a build is already in progress.

Author: code-asher

src/main/kotlin/com/coder/gateway/sdk/BaseCoderRestClient.kt

@@ -213,19 +213,16 @@ open class BaseCoderRestClient(
         return buildResponse.body()!!
     }
 
+    /**
+     * Start the workspace with the latest template version.  Best practice is
+     * to STOP a workspace before doing an update if it is started.
+     * 1. If the update changes parameters, the old template might be needed to
+     *    correctly STOP with the existing parameter values.
+     * 2. The agent gets a new ID and token on each START build.  Many template
+     *    authors are not diligent about making sure the agent gets restarted
+     *    with this information when we do two START builds in a row.
+     */
     fun updateWorkspace(workspace: Workspace): WorkspaceBuild {
-        // Best practice is to STOP a workspace before doing an update if it is
-        // started.
-        // 1. If the update changes parameters, the old template might be needed
-        //    to correctly STOP with the existing parameter values.
-        // 2. The agent gets a new ID and token on each START build.  Many
-        //    template authors are not diligent about making sure the agent gets
-        //    restarted with this information when we do two START builds in a
-        //    row.
-        if (workspace.latestBuild.transition == WorkspaceTransition.START) {
-            stopWorkspace(workspace)
-        }
-
         val template = template(workspace.templateID)
 
         val buildRequest =

src/main/kotlin/com/coder/gateway/views/steps/CoderWorkspacesStepView.kt

@@ -70,6 +70,7 @@ import java.net.ConnectException
 import java.net.SocketTimeoutException
 import java.net.URL
 import java.net.UnknownHostException
+import java.time.Duration
 import javax.net.ssl.SSLHandshakeException
 import javax.swing.Icon
 import javax.swing.JCheckBox
@@ -271,8 +272,47 @@ class CoderWorkspacesStepView(val setNextButtonEnabled: (Boolean) -> Unit) : Cod
                 cs.launch {
                     withContext(Dispatchers.IO) {
                         try {
-                            c.updateWorkspace(workspace)
-                            loadWorkspaces()
+                            // Stop the workspace first if it is running.
+                            if (workspace.latestBuild.status == WorkspaceStatus.RUNNING) {
+                                logger.info("Waiting for ${workspace.name} to stop before updating")
+                                c.stopWorkspace(workspace)
+                                loadWorkspaces()
+                                var elapsed = Duration.ofSeconds(0)
+                                val timeout = Duration.ofSeconds(1)
+                                val maxWait = Duration.ofMinutes(10)
+                                while (isActive) { // Wait for the workspace to fully stop.
+                                    delay(timeout.toMillis())
+                                    val found = tableOfWorkspaces.items.firstOrNull{ it.workspace.id == workspace.id }
+                                    when (val status = found?.workspace?.latestBuild?.status) {
+                                        WorkspaceStatus.PENDING, WorkspaceStatus.STOPPING, WorkspaceStatus.RUNNING -> {
+                                            logger.info("Still waiting for ${workspace.name} to stop before updating")
+                                        }
+                                        WorkspaceStatus.STARTING, WorkspaceStatus.FAILED,
+                                        WorkspaceStatus.CANCELING, WorkspaceStatus.CANCELED,
+                                        WorkspaceStatus.DELETING, WorkspaceStatus.DELETED -> {
+                                            logger.warn("Canceled ${workspace.name} update due to status change to $status")
+                                            break
+                                        }
+                                        null -> {
+                                            logger.warn("Canceled ${workspace.name} update because it no longer exists")
+                                            break
+                                        }
+                                        WorkspaceStatus.STOPPED -> {
+                                            logger.info("${workspace.name} has stopped; updating now")
+                                            c.updateWorkspace(workspace)
+                                            break
+                                        }
+                                    }
+                                    elapsed += timeout
+                                    if (elapsed > maxWait) {
+                                        logger.error("Canceled ${workspace.name} update because it took took longer than ${maxWait.toMinutes()} minutes to stop")
+                                        break
+                                    }
+                                }
+                            } else {
+                                c.updateWorkspace(workspace)
+                                loadWorkspaces()
+                            }
                         } catch (e: WorkspaceResponseException) {
                             logger.warn("Could not update workspace ${workspace.name}, reason: $e")
                         } catch (e: TemplateResponseException) {

src/test/kotlin/com/coder/gateway/sdk/BaseCoderRestClientTest.kt

@@ -235,26 +235,25 @@ class BaseCoderRestClientTest {
         })
 
         // Fails to stop a non-existent workspace.
-        val badWorkspace = DataGen.workspace("bad")
+        val badWorkspace = DataGen.workspace("bad", templates[0].id)
         val ex = assertFailsWith(
             exceptionClass = WorkspaceResponseException::class,
             block = { client.updateWorkspace(badWorkspace) })
-        assertEquals(listOf(Pair("stop", badWorkspace.id)), actions)
+        assertEquals(listOf(
+            Pair("get_template", badWorkspace.templateID),
+            Pair("update", badWorkspace.id)), actions)
         assertContains(ex.message.toString(), "The requested resource could not be found")
         actions.clear()
 
-        // When workspace is started it should stop first.
         with(workspaces[0]) {
             client.updateWorkspace(this)
             val expected = listOf(
-                Pair("stop", id),
                 Pair("get_template", templateID),
                 Pair("update", id))
             assertEquals(expected, actions)
             actions.clear()
         }
 
-        // When workspace is stopped it will not stop first.
         with(workspaces[1]) {
             client.updateWorkspace(this)
             val expected = listOf(