Compile asynchronously (intersystems-community#890)

Author: isc-bsaviano

src/api/index.ts

@@ -16,7 +16,7 @@ import {
   schemas,
   checkingConnection,
 } from "../extension";
-import { currentWorkspaceFolder, outputConsole } from "../utils";
+import { currentWorkspaceFolder, outputChannel, outputConsole } from "../utils";
 
 const DEFAULT_API_VERSION = 1;
 import * as Atelier from "./atelier";
@@ -252,6 +252,7 @@ export class AtelierAPI {
     if (minVersion > apiVersion) {
       return Promise.reject(`${path} not supported by API version ${apiVersion}`);
     }
+    const originalPath = path;
     if (minVersion && minVersion > 0) {
       path = `v${apiVersion}/${path}`;
     }
@@ -404,6 +405,18 @@ export class AtelierAPI {
         // The request errored out, but didn't give us an error string back
         throw { statusCode: response.status, message: response.statusText, errorText: "" };
       }
+
+      // Handle headers for the /work endpoints by storing the header values in the result object
+      if (originalPath && originalPath.endsWith("/work") && method == "POST") {
+        // This is a POST /work request, so we need to get the Location header
+        data.result.location = response.headers.get("Location");
+      } else if (originalPath && /^[^/]+\/work\/[^/]+$/.test(originalPath)) {
+        // This is a GET or DELETE /work request, so we need to check the Retry-After header
+        if (response.headers.has("Retry-After")) {
+          data.result.retryafter = response.headers.get("Retry-After");
+        }
+      }
+
       return data;
     } catch (error) {
       if (error.code === "ECONNREFUSED") {
@@ -594,4 +607,88 @@ export class AtelierAPI {
     };
     return this.request(1, "GET", `%SYS/cspapps/${this.ns || ""}`, null, params);
   }
+
+  // v1+
+  private queueAsync(request: any): Promise<Atelier.Response> {
+    return this.request(1, "POST", `${this.ns}/work`, request);
+  }
+
+  // v1+
+  private pollAsync(id: string): Promise<Atelier.Response> {
+    return this.request(1, "GET", `${this.ns}/work/${id}`);
+  }
+
+  // v1+
+  private cancelAsync(id: string): Promise<Atelier.Response> {
+    return this.request(1, "DELETE", `${this.ns}/work/${id}`);
+  }
+
+  /**
+   * Calls `cancelAsync()` repeatedly until the cancellation is confirmed.
+   * The wait time between requests is 1 second.
+   */
+  private async verifiedCancel(id: string): Promise<Atelier.Response> {
+    outputChannel.appendLine(
+      "\nWARNING: Compilation was cancelled. Partially-compiled documents may result in unexpected behavior."
+    );
+    let cancelResp = await this.cancelAsync(id);
+    while (cancelResp.result.retryafter) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, 1000);
+      });
+      cancelResp = await this.cancelAsync(id);
+    }
+    return cancelResp;
+  }
+
+  /**
+   * Recursive function that calls `pollAsync()` repeatedly until we get a result or the user cancels the request.
+   * The wait time between requests starts at 50ms and increases exponentially, with a max wait of 15 seconds.
+   */
+  private async getAsyncResult(id: string, wait: number, token: vscode.CancellationToken): Promise<Atelier.Response> {
+    const pollResp = await this.pollAsync(id);
+    if (token.isCancellationRequested) {
+      // The user cancelled the request, so cancel it on the server
+      return this.verifiedCancel(id);
+    }
+    if (pollResp.result.retryafter) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, wait);
+      });
+      if (token.isCancellationRequested) {
+        // The user cancelled the request, so cancel it on the server
+        return this.verifiedCancel(id);
+      }
+      return this.getAsyncResult(id, wait < 10000 ? wait ** 1.075 : 15000, token);
+    }
+    return pollResp;
+  }
+
+  /**
+   * Use the undocumented /work endpoints to compile `docs` asynchronously.
+   */
+  public async asyncCompile(
+    docs: string[],
+    token: vscode.CancellationToken,
+    flags?: string,
+    source = false
+  ): Promise<Atelier.Response> {
+    // Queue the compile request
+    return this.queueAsync({
+      request: "compile",
+      documents: docs.map((doc) => this.transformNameIfCsp(doc)),
+      source,
+      flags,
+    }).then((queueResp) => {
+      // Request was successfully queued, so get the ID
+      const id: string = queueResp.result.location;
+      if (token.isCancellationRequested) {
+        // The user cancelled the request, so cancel it on the server
+        return this.verifiedCancel(id);
+      }
+
+      // Poll until we get a result or the user cancels the request
+      return this.getAsyncResult(id, 50, token);
+    });
+  }
 }

src/commands/compile.ts

@@ -24,6 +24,7 @@ import {
 } from "../utils";
 import { PackageNode } from "../explorer/models/packageNode";
 import { NodeBase } from "../explorer/models/nodeBase";
+import { RootNode } from "../explorer/models/rootNode";
 
 async function compileFlags(): Promise<string> {
   const defaultFlags = config().compileFlags;
@@ -180,7 +181,7 @@ function updateOthers(others: string[], baseUri: vscode.Uri) {
         dotParts.length <= partsToConvert
           ? uri.path
           : dotParts.slice(0, partsToConvert).join("/") + "." + dotParts.slice(partsToConvert).join(".");
-      console.log(`updateOthers: uri.path=${uri.path} baseUri.path=${baseUri.path} correctPath=${correctPath}`);
+      //console.log(`updateOthers: uri.path=${uri.path} baseUri.path=${baseUri.path} correctPath=${correctPath}`);
       fileSystemProvider.fireFileChanged(uri.with({ path: correctPath }));
     } else {
       documentContentProvider.update(uri);
@@ -222,26 +223,27 @@ async function compile(docs: CurrentFile[], flags?: string): Promise<any> {
   return vscode.window
     .withProgress(
       {
-        cancellable: false,
+        cancellable: true,
         location: vscode.ProgressLocation.Notification,
         title: `Compiling: ${docs.length === 1 ? docs.map((el) => el.name).join(", ") : docs.length + " files"}`,
       },
-      () =>
+      (progress, token: vscode.CancellationToken) =>
         api
-          .actionCompile(
+          .asyncCompile(
             docs.map((el) => el.name),
+            token,
             flags
           )
           .then((data) => {
             const info = docs.length > 1 ? "" : `${docs[0].name}: `;
             if (data.status && data.status.errors && data.status.errors.length) {
               throw new Error(`${info}Compile error`);
             } else if (!config("suppressCompileMessages")) {
-              vscode.window.showInformationMessage(`${info}Compilation succeeded`, "Hide");
+              vscode.window.showInformationMessage(`${info}Compilation succeeded.`, "Dismiss");
             }
             return docs;
           })
-          .catch((error: Error) => {
+          .catch(() => {
             if (!config("suppressCompileErrorMessages")) {
               vscode.window
                 .showErrorMessage(
@@ -255,7 +257,7 @@ async function compile(docs: CurrentFile[], flags?: string): Promise<any> {
                   }
                 });
             }
-            // Even when compile failed we should still fetch server changes
+            // Always fetch server changes, even when compile failed or got cancelled
             return docs;
           })
     )
@@ -344,7 +346,7 @@ export async function namespaceCompile(askFlags = false): Promise<any> {
     throw new Error(`No Active Connection`);
   }
   const confirm = await vscode.window.showWarningMessage(
-    `Compiling all files in namespace '${api.ns}' might be expensive. Are you sure you want to proceed?`,
+    `Compiling all files in namespace ${api.ns} might be expensive. Are you sure you want to proceed?`,
     "Cancel",
     "Confirm"
   );
@@ -360,21 +362,40 @@ export async function namespaceCompile(askFlags = false): Promise<any> {
   }
   vscode.window.withProgress(
     {
-      cancellable: false,
+      cancellable: true,
       location: vscode.ProgressLocation.Notification,
-      title: `Compiling Namespace: ${api.ns}`,
+      title: `Compiling namespace ${api.ns}`,
     },
-    async () => {
-      const data = await api.actionCompile(fileTypes, flags);
-      if (data.status && data.status.errors && data.status.errors.length) {
-        // console.error(data.status.summary);
-        throw new Error(`Compiling Namespace: ${api.ns} Error`);
-      } else {
-        vscode.window.showInformationMessage(`Compiling Namespace: ${api.ns} Success`);
-      }
-      const file = currentFile();
-      return loadChanges([file]);
-    }
+    (progress, token: vscode.CancellationToken) =>
+      api
+        .asyncCompile(fileTypes, token, flags)
+        .then((data) => {
+          if (data.status && data.status.errors && data.status.errors.length) {
+            throw new Error(`Compiling Namespace: ${api.ns} Error`);
+          } else if (!config("suppressCompileMessages")) {
+            vscode.window.showInformationMessage(`Compiling namespace ${api.ns} succeeded.`, "Dismiss");
+          }
+        })
+        .catch(() => {
+          if (!config("suppressCompileErrorMessages")) {
+            vscode.window
+              .showErrorMessage(
+                `Compiling namespace ${api.ns} failed. Check 'ObjectScript' output channel for details.`,
+                "Show",
+                "Dismiss"
+              )
+              .then((action) => {
+                if (action === "Show") {
+                  outputChannel.show(true);
+                }
+              });
+          }
+        })
+        .then(() => {
+          // Always fetch server changes, even when compile failed or got cancelled
+          const file = currentFile();
+          return loadChanges([file]);
+        })
   );
 }
 
@@ -442,9 +463,43 @@ export async function compileExplorerItems(nodes: NodeBase[]): Promise<any> {
           docs.push(node.fullName + ".*.cls");
           break;
       }
+    } else if (node instanceof RootNode && node.contextValue === "dataNode:cspApplication") {
+      docs.push(node.fullName + "/*");
     } else {
       docs.push(node.fullName);
     }
   }
-  return api.actionCompile(docs, flags);
+  return vscode.window.withProgress(
+    {
+      cancellable: true,
+      location: vscode.ProgressLocation.Notification,
+      title: `Compiling ${nodes.length === 1 ? nodes[0].fullName : nodes.length + " nodes"}`,
+    },
+    (progress, token: vscode.CancellationToken) =>
+      api
+        .asyncCompile(docs, token, flags)
+        .then((data) => {
+          const info = nodes.length > 1 ? "" : `${nodes[0].fullName}: `;
+          if (data.status && data.status.errors && data.status.errors.length) {
+            throw new Error(`${info}Compile error`);
+          } else if (!config("suppressCompileMessages")) {
+            vscode.window.showInformationMessage(`${info}Compilation succeeded.`, "Dismiss");
+          }
+        })
+        .catch(() => {
+          if (!config("suppressCompileErrorMessages")) {
+            vscode.window
+              .showErrorMessage(
+                `Compilation failed. Check 'ObjectScript' output channel for details.`,
+                "Show",
+                "Dismiss"
+              )
+              .then((action) => {
+                if (action === "Show") {
+                  outputChannel.show(true);
+                }
+              });
+          }
+        })
+  );
 }