Improvements to dismissing a deployment

extensions/vscode/src/api/resources/ContentRecords.ts

@@ -145,4 +145,22 @@ export class ContentRecords {
       },
     );
   }
+
+  // Returns:
+  // 200 - success
+  // 404 - not found
+  // 500 - internal server error
+  cancelDeployment(deploymentName: string, dir: string, localId: string) {
+    const encodedName = encodeURIComponent(deploymentName);
+    const encodedLocalId = encodeURIComponent(localId);
+    return this.client.post<ContentRecord>(
+      `deployments/${encodedName}/cancel/${encodedLocalId}`,
+      {},
+      {
+        params: {
+          dir,
+        },
+      },
+    );
+  }
 }

extensions/vscode/src/api/types/contentRecords.ts

@@ -44,6 +44,8 @@ type ContentRecordRecord = {
   serverUrl: string;
   saveName: string;
   createdAt: string;
+  localId: string;
+  abortedAt: string;
   configurationName: string;
   type: ContentType;
   deploymentError: AgentError | null;

extensions/vscode/src/api/types/events.ts

@@ -1254,7 +1254,7 @@ export interface PublishFailure extends EventStreamMessage {
   data: {
     dashboardUrl: string;
     url: string;
-    canceled?: string; // not defined if not user cancelled. Value of "true" if true.
+    canceled?: string; // not defined if not user canceled. Value of "true" if true.
     // and other non-defined attributes
   };
   error: string; // translated internally

extensions/vscode/src/events.ts

@@ -76,6 +76,9 @@ export function displayEventStreamMessage(msg: EventStreamMessage): string {
     if (msg.data.dashboardUrl) {
       return `Deployment failed, click to view Connect logs: ${msg.data.dashboardUrl}`;
     }
+    if (msg.data.canceled === "true") {
+      return "Deployment dismissed";
+    }
     return "Deployment failed";
   }
   if (msg.error !== undefined) {
@@ -95,8 +98,8 @@ export class EventStream extends Readable implements Disposable {
   private messages: EventStreamMessage[] = [];
   // Map to store event callbacks
   private callbacks: Map<string, EventStreamRegistration[]> = new Map();
-  // Cancelled Event Streams - Suppressed when received
-  private cancelledLocalIDs: string[] = [];
+  // Canceled Event Streams - Suppressed when received
+  private canceledLocalIDs: string[] = [];
 
   /**
    * Creates a new instance of the EventStream class.
@@ -170,19 +173,25 @@ export class EventStream extends Readable implements Disposable {
    * @returns undefined
    */
   public suppressMessages(localId: string) {
-    this.cancelledLocalIDs.push(localId);
+    this.canceledLocalIDs.push(localId);
   }
 
   private processMessage(msg: EventStreamMessage) {
-    const localId = msg.data.localId;
-    if (localId && this.cancelledLocalIDs.includes(localId)) {
+    // Some log messages passed on from Connect include
+    // the localId using snake_case, rather than pascalCase.
+    // To filter correctly, we need to check for both.
+
+    const localId = msg.data.localId || msg.data.local_id;
+    if (localId && this.canceledLocalIDs.includes(localId)) {
       // suppress and ignore
       return;
     }
+
     // Trace message
-    // console.debug(
-    //   `eventSource trace: ${event.type}: ${JSON.stringify(event)}`,
-    // );
+    // Uncomment the following code if you want to dump every message to the
+    // console as it is received.
+    // console.debug(`eventSource trace: ${msg.type}: ${JSON.stringify(msg)}`);
+
     // Add the message to the messages array
     this.messages.push(msg);
     // Emit a 'message' event with the message as the payload

extensions/vscode/src/multiStepInputs/newCredential.ts

@@ -54,7 +54,7 @@ export async function newCredential(
       totalSteps: -1,
       data: {
         // each attribute is initialized to undefined
-        // to be returned when it has not been cancelled
+        // to be returned when it has not been canceled
         url: startingServerUrl, // eventual type is string
         apiKey: <string | undefined>undefined, // eventual type is string
         name: <string | undefined>undefined, // eventual type is string

extensions/vscode/src/multiStepInputs/newDeployment.ts

@@ -357,7 +357,7 @@ export async function newDeployment(
             title: "Select Entrypoint File (main file for your project)",
           });
           if (!fileUris || !fileUris[0]) {
-            // cancelled.
+            // canceled.
             continue;
           }
           const fileUri = fileUris[0];

extensions/vscode/src/multiStepInputs/selectNewOrExistingConfig.ts

@@ -245,7 +245,7 @@ export async function selectNewOrExistingConfig(
       totalSteps: -1,
       data: {
         // each attribute is initialized to undefined
-        // to be returned when it has not been cancelled to assist type guards
+        // to be returned when it has not been canceled to assist type guards
         // Note: We can't initialize existingConfigurationName to a specific initial
         // config, as we then wouldn't be able to detect if the user hit ESC to exit
         // the selection. :-(

extensions/vscode/src/state.ts

@@ -167,6 +167,26 @@ export class PublisherState implements Disposable {
     }
   }
 
+  updateContentRecord(
+    newValue: ContentRecord | PreContentRecord | PreContentRecordWithConfig,
+  ) {
+    const existingContentRecord = this.findContentRecord(
+      newValue.saveName,
+      newValue.projectDir,
+    );
+    if (existingContentRecord) {
+      const crIndex = this.contentRecords.findIndex(
+        (contentRecord) =>
+          contentRecord.deploymentPath === existingContentRecord.deploymentPath,
+      );
+      if (crIndex !== -1) {
+        this.contentRecords[crIndex] = newValue;
+      } else {
+        this.contentRecords.push(newValue);
+      }
+    }
+  }
+
   async getSelectedConfiguration() {
     const contentRecord = await this.getSelectedContentRecord();
     if (!contentRecord) {

extensions/vscode/src/test/unit-test-utils/factories.ts

@@ -43,6 +43,8 @@ export const preContentRecordFactory = Factory.define<PreContentRecord>(
     serverUrl: `https://connect-test-${sequence}/connect`,
     saveName: `Report ${sequence}`,
     createdAt: new Date().toISOString(),
+    localId: "",
+    abortedAt: "",
     configurationName: `report-GUD${sequence}`,
     type: ContentType.RMD,
     deploymentError: null,
@@ -67,6 +69,8 @@ export const contentRecordFactory = Factory.define<ContentRecord>(
     serverUrl: `https://connect-test-${sequence}/connect`,
     saveName: `Report ${sequence}`,
     createdAt: new Date().toISOString(),
+    localId: "",
+    abortedAt: "",
     deployedAt: new Date().toISOString(),
     configurationName: `report-GUD${sequence}`,
     type: ContentType.RMD,

extensions/vscode/src/views/deployProgress.ts

@@ -1,10 +1,28 @@
 // Copyright (C) 2024 by Posit Software, PBC.
 
 import { ProgressLocation, Uri, env, window } from "vscode";
-import { EventStreamMessage, eventMsgToString } from "src/api";
+import {
+  EventStreamMessage,
+  eventMsgToString,
+  useApi,
+  ContentRecord,
+  PreContentRecord,
+  PreContentRecordWithConfig,
+} from "src/api";
 import { EventStream, UnregisterCallback } from "src/events";
+import { getSummaryStringFromError } from "src/utils/errors";
 
-export function deployProject(localID: string, stream: EventStream) {
+type UpdateActiveContentRecordCB = (
+  contentRecord: ContentRecord | PreContentRecord | PreContentRecordWithConfig,
+) => void;
+
+export function deployProject(
+  deploymentName: string,
+  dir: string,
+  localID: string,
+  stream: EventStream,
+  updateActiveContentRecordCB: UpdateActiveContentRecordCB,
+) {
   window.withProgress(
     {
       location: ProgressLocation.Notification,
@@ -27,25 +45,44 @@ export function deployProject(localID: string, stream: EventStream) {
         registrations.forEach((cb) => cb.unregister());
       };
 
-      token.onCancellationRequested(() => {
+      token.onCancellationRequested(async () => {
+        const api = await useApi();
         streamID = "NEVER_A_VALID_STREAM";
         unregisterAll();
-        // inject a psuedo end of publishing event
-        stream.injectMessage({
-          type: "publish/failure",
-          time: Date.now().toString(),
-          data: {
-            dashboardUrl: "",
-            url: "",
-            // and other non-defined attributes
-            localId: localID,
-            cancelled: "true",
-            message:
-              "Deployment has been dismissed (but will continue to be processed on the Connect Server). Deployment status will be reset to the prior known state.",
-          },
-          error: "Deployment has been dismissed.",
-        });
-        stream.suppressMessages(localID);
+        try {
+          const response = await api.contentRecords.cancelDeployment(
+            deploymentName,
+            dir,
+            localID,
+          );
+
+          // update the UX locally
+          updateActiveContentRecordCB(response.data);
+
+          // we must have been successful...
+          // inject a psuedo end of publishing event
+          stream.injectMessage({
+            type: "publish/failure",
+            time: Date.now().toString(),
+            data: {
+              dashboardUrl: "",
+              url: "",
+              // and other non-defined attributes
+              localId: localID,
+              canceled: "true",
+              message:
+                "Deployment has been dismissed, but will continue to be processed on the Connect Server.",
+            },
+            error: "Deployment has been dismissed.",
+          });
+          stream.suppressMessages(localID);
+        } catch (error: unknown) {
+          const summary = getSummaryStringFromError(
+            "deployProject, token.onCancellationRequested",
+            error,
+          );
+          window.showErrorMessage(`Unable to dismiss deployment: ${summary}`);
+        }
         resolveCB();
       });
 

extensions/vscode/src/views/homeView.ts

@@ -36,6 +36,7 @@ import {
   useApi,
   AllContentRecordTypes,
   EnvironmentConfig,
+  PreContentRecordWithConfig,
 } from "src/api";
 import { EventStream } from "src/events";
 import { getPythonInterpreterPath, getRInterpreterPath } from "../utils/vscode";
@@ -208,7 +209,13 @@ export class HomeViewProvider implements WebviewViewProvider, Disposable {
         secrets,
         r,
       );
-      deployProject(response.data.localId, this.stream);
+      deployProject(
+        deploymentName,
+        projectDir,
+        response.data.localId,
+        this.stream,
+        this.updateActiveContentRecordLocally.bind(this),
+      );
     } catch (error: unknown) {
       // Most failures will occur on the event stream. These are the ones which
       // are immediately rejected as part of the API request to initiate deployment.
@@ -310,6 +317,19 @@ export class HomeViewProvider implements WebviewViewProvider, Disposable {
     }
   }
 
+  private updateActiveContentRecordLocally(
+    activeContentRecord:
+      | ContentRecord
+      | PreContentRecord
+      | PreContentRecordWithConfig,
+  ) {
+    // update our local state, so we don't wait on file refreshes
+    this.state.updateContentRecord(activeContentRecord);
+
+    // refresh the webview
+    this.updateWebViewViewContentRecords();
+  }
+
   private onPublishStart() {
     this.webviewConduit.sendMsg({
       kind: HostToWebviewMessageType.PUBLISH_START,
@@ -949,7 +969,7 @@ export class HomeViewProvider implements WebviewViewProvider, Disposable {
       activeConfig.configuration.environment,
     );
     if (name === undefined) {
-      // Cancelled by the user
+      // Canceled by the user
       return;
     }
 

extensions/vscode/src/views/logs.ts

@@ -41,6 +41,7 @@ enum LogStageStatus {
   inProgress,
   completed,
   failed,
+  canceled,
 }
 
 type LogStage = {
@@ -182,14 +183,17 @@ export class LogsTreeDataProvider implements TreeDataProvider<LogsTreeItem> {
     });
 
     this.stream.register("publish/failure", async (msg: EventStreamMessage) => {
-      this.publishingStage.status = LogStageStatus.failed;
+      const failedOrCanceledStatus = msg.data.canceled
+        ? LogStageStatus.canceled
+        : LogStageStatus.failed;
+      this.publishingStage.status = failedOrCanceledStatus;
       this.publishingStage.events.push(msg);
 
       this.stages.forEach((stage) => {
         if (stage.status === LogStageStatus.notStarted) {
           stage.status = LogStageStatus.neverStarted;
         } else if (stage.status === LogStageStatus.inProgress) {
-          stage.status = LogStageStatus.failed;
+          stage.status = failedOrCanceledStatus;
         }
       });
 
@@ -204,11 +208,19 @@ export class LogsTreeDataProvider implements TreeDataProvider<LogsTreeItem> {
         errorMessage = handleEventCodedError(msg);
       } else {
         errorMessage =
-          msg.data.cancelled === "true"
-            ? `Deployment cancelled: ${msg.data.message}`
+          msg.data.canceled === "true"
+            ? msg.data.message
             : `Deployment failed: ${msg.data.message}`;
       }
-      const selection = await window.showErrorMessage(errorMessage, ...options);
+      let selection: string | undefined;
+      if (msg.data.canceled === "true") {
+        selection = await window.showInformationMessage(
+          errorMessage,
+          ...options,
+        );
+      } else {
+        selection = await window.showErrorMessage(errorMessage, ...options);
+      }
       if (selection === showLogsOption) {
         await commands.executeCommand(Commands.Logs.Focus);
       } else if (selection === enhancedError?.buttonStr) {
@@ -259,7 +271,11 @@ export class LogsTreeDataProvider implements TreeDataProvider<LogsTreeItem> {
         (msg: EventStreamMessage) => {
           const stage = this.stages.get(stageName);
           if (stage) {
-            stage.status = LogStageStatus.failed;
+            if (msg.data.canceled === "true") {
+              stage.status = LogStageStatus.canceled;
+            } else {
+              stage.status = LogStageStatus.failed;
+            }
             stage.events.push(msg);
           }
           this.refresh();
@@ -413,6 +429,11 @@ export class LogsTreeStageItem extends TreeItem {
         this.iconPath = new ThemeIcon("error");
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
         break;
+      case LogStageStatus.canceled:
+        this.label = this.stage.inactiveLabel;
+        this.iconPath = new ThemeIcon("circle-slash");
+        this.collapsibleState = TreeItemCollapsibleState.Expanded;
+        break;
     }
   }
 }