cleaned up checking if the container is ready for connections logic

Author: Lauren Nathan

src/containerDeployment/dockerUtils.ts

@@ -411,21 +411,19 @@ export async function startDocker(): Promise<DockerCommandParams> {
     }
 }
 
-export function restartContainer(containerName: string): Promise<boolean> {
+export async function restartContainer(containerName: string): Promise<boolean> {
     sendActionEvent(TelemetryViews.ContainerDeployment, TelemetryActions.StartContainer);
 
-    return startDocker().then((isDockerStarted) => {
-        if (!isDockerStarted.success) return false;
+    await startDocker();
+    const isContainerRunning = await isDockerContainerRunning(containerName);
+    if (isContainerRunning) return true; // Container is already running
+    await execCommand(COMMANDS.START_CONTAINER(containerName));
+    const containerReadyResult = await checkIfContainerIsReadyForConnections(containerName);
 
-        return isDockerContainerRunning(containerName).then((containerRunning) => {
-            if (containerRunning) return true;
-
-            return execCommand(COMMANDS.START_CONTAINER(containerName))
-                .then(() => checkIfContainerIsReadyForConnections(containerName))
-                .then((result) => result.success)
-                .catch(() => false);
-        });
-    });
+    if (!containerReadyResult.success) {
+        return false;
+    }
+    return true;
 }
 
 /**
@@ -439,16 +437,39 @@ export async function checkIfContainerIsReadyForConnections(
     const intervalMs = 1000;
     const start = Date.now();
 
+    // We check the logs for the timestamp of the "Recovery is complete" message,
+    // because when a container is stopped and started, the logs are not cleared.
+    // Checking the timestamp ensures that the container is ready after it has been restarted,
+    // rather than returning a false positive from the previous run.
+    const TIMESTAMP_REGEX = /(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?)/;
+
     return new Promise((resolve) => {
         const interval = setInterval(async () => {
             try {
                 const logs = await execCommand(COMMANDS.CHECK_LOGS(containerName, platform()));
-                if (logs.includes(COMMANDS.CHECK_CONTAINER_READY)) {
-                    clearInterval(interval);
-                    return resolve({ success: true });
+                const lines = logs.split("\n");
+                const readyLine = lines.find((line) =>
+                    line.includes(COMMANDS.CHECK_CONTAINER_READY),
+                );
+
+                if (readyLine) {
+                    const match = readyLine.match(TIMESTAMP_REGEX);
+                    if (match) {
+                        const timestampStr = match[1];
+
+                        // Parse using Date constructor – replace space with 'T' to make it ISO-ish, adn add 'Z' for UTC
+                        const logTimestamp = new Date(timestampStr.replace(" ", "T") + "Z");
+
+                        const ageMs = new Date().getTime() - logTimestamp.getTime();
+
+                        if (ageMs >= 0 && ageMs <= timeoutMs) {
+                            clearInterval(interval);
+                            return resolve({ success: true });
+                        }
+                    }
                 }
             } catch {
-                // Ignore error and retry until timeout
+                // Ignore and retry
             }
 
             if (Date.now() - start > timeoutMs) {

src/controllers/mainController.ts

@@ -1209,7 +1209,14 @@ export default class MainController implements vscode.Disposable {
                         // doing it this way instead of directly calling startContainer
                         // allows for the object explorer item loading UI to show
                         this._objectExplorerProvider.deleteChildrenCache(node);
-                        await this._objectExplorerProvider.refresh(node);
+                        await this._objectExplorerProvider.setNodeLoading(node);
+                        this._objectExplorerProvider.refresh(node);
+                        await this.objectExplorerTree.reveal(node, {
+                            select: true,
+                            focus: true,
+                            expand: true,
+                        });
+
                         await this.connectionManager.connectionUI
                             .saveProfile(node.connectionProfile as IConnectionProfile)
                             .then(async () => {
@@ -1234,23 +1241,27 @@ export default class MainController implements vscode.Disposable {
                 Constants.cmdStopContainer,
                 async (node: TreeNodeInfo) => {
                     const containerName = node.connectionProfile.containerName;
-                    const stoppedSuccessfully = await stopContainer(
-                        node.connectionProfile.containerName,
-                    );
-                    vscode.window.showInformationMessage(
-                        stoppedSuccessfully
-                            ? LocalizedConstants.ContainerDeployment.stoppedContainerSucessfully(
-                                  containerName,
-                              )
-                            : LocalizedConstants.ContainerDeployment.failStopContainer(
-                                  containerName,
-                              ),
-                    );
-                    if (stoppedSuccessfully) {
-                        // Disconnect from the node
-                        await this._objectExplorerProvider.disconnectNode(node as ConnectionNode);
-                        return this._objectExplorerProvider.refresh(undefined);
-                    }
+
+                    await this._objectExplorerProvider.setNodeLoading(node);
+                    this._objectExplorerProvider.refresh(node);
+
+                    await stopContainer(containerName).then(async (stoppedSuccessfully) => {
+                        if (stoppedSuccessfully) {
+                            await this._objectExplorerProvider
+                                .disconnectNode(node as ConnectionNode)
+                                .then(() => this._objectExplorerProvider.refresh(undefined));
+                        }
+
+                        vscode.window.showInformationMessage(
+                            stoppedSuccessfully
+                                ? LocalizedConstants.ContainerDeployment.stoppedContainerSucessfully(
+                                      containerName,
+                                  )
+                                : LocalizedConstants.ContainerDeployment.failStopContainer(
+                                      containerName,
+                                  ),
+                        );
+                    });
                 },
             ),
         );

src/objectExplorer/objectExplorerProvider.ts

@@ -57,6 +57,10 @@ export class ObjectExplorerProvider implements vscode.TreeDataProvider<any> {
         }
     }
 
+    public async setNodeLoading(node: TreeNodeInfo): Promise<void> {
+        await this._objectExplorerService.setLoadingUiForNode(node);
+    }
+
     public async createSession(
         connectionCredentials?: IConnectionInfo,
     ): Promise<CreateSessionResult> {

src/objectExplorer/objectExplorerService.ts

@@ -436,6 +436,16 @@ export class ObjectExplorerService {
          * one blocked operation can delay the other.
          */
         void this.getOrCreateNodeChildrenWithSession(element);
+        return this.setLoadingUiForNode(element);
+    }
+
+    /**
+     * Sets a loading UI for the given node.
+     * This is used to show a loading spinner while the children are being fetched/ other node operations are being performed.
+     * @param element The node to set the loading UI for
+     * @returns A loading node that will be displayed in the tree
+     */
+    public async setLoadingUiForNode(element: TreeNodeInfo): Promise<vscode.TreeItem[]> {
         const loadingNode = new vscode.TreeItem(
             LocalizedConstants.ObjectExplorer.LoadingNodeLabel,
             vscode.TreeItemCollapsibleState.None,