Support file-based cancellation

Author: jmbockhorst

client/src/cancellation.ts

@@ -0,0 +1,96 @@
+import { randomBytes } from "crypto";
+import * as fs from "fs";
+import * as os from "os";
+import { Disposable } from "vscode";
+import {
+  CancellationId,
+  CancellationReceiverStrategy,
+  CancellationSenderStrategy,
+  CancellationStrategy,
+  MessageConnection,
+} from "vscode-languageclient";
+import path = require("path");
+
+function getCancellationFolderPath(folderName: string) {
+  return path.join(os.tmpdir(), "elm-language-server-cancellation", folderName);
+}
+
+function getCancellationFilePath(
+  folderName: string,
+  id: CancellationId,
+): string {
+  return path.join(
+    getCancellationFolderPath(folderName),
+    `cancellation-${String(id)}.tmp`,
+  );
+}
+
+function tryRun(callback: () => void) {
+  try {
+    callback();
+  } catch (e) {
+    /* empty */
+  }
+}
+
+class FileCancellationSenderStrategy implements CancellationSenderStrategy {
+  constructor(readonly folderName: string) {
+    const folder = getCancellationFolderPath(folderName);
+    tryRun(() => fs.mkdirSync(folder, { recursive: true }));
+  }
+
+  sendCancellation(_: MessageConnection, id: CancellationId): void {
+    const file = getCancellationFilePath(this.folderName, id);
+    tryRun(() => fs.writeFileSync(file, "", { flag: "w" }));
+  }
+
+  cleanup(id: CancellationId): void {
+    tryRun(() => fs.unlinkSync(getCancellationFilePath(this.folderName, id)));
+  }
+
+  dispose(): void {
+    const folder = getCancellationFolderPath(this.folderName);
+    tryRun(() => rimraf(folder));
+
+    function rimraf(location: string) {
+      const stat = fs.lstatSync(location);
+      if (stat) {
+        if (stat.isDirectory() && !stat.isSymbolicLink()) {
+          for (const dir of fs.readdirSync(location)) {
+            rimraf(path.join(location, dir));
+          }
+
+          fs.rmdirSync(location);
+        } else {
+          fs.unlinkSync(location);
+        }
+      }
+    }
+  }
+}
+
+export class FileBasedCancellationStrategy
+  implements CancellationStrategy, Disposable {
+  private _sender: FileCancellationSenderStrategy;
+
+  constructor() {
+    const folderName = randomBytes(21).toString("hex");
+    this._sender = new FileCancellationSenderStrategy(folderName);
+  }
+
+  get receiver(): CancellationReceiverStrategy {
+    return CancellationReceiverStrategy.Message;
+  }
+
+  get sender(): CancellationSenderStrategy {
+    return this._sender;
+  }
+
+  getCommandLineArguments(): string[] {
+    return [`--cancellationReceive=file:${this._sender.folderName}`];
+  }
+
+  dispose(): void {
+    this._sender.dispose();
+  }
+}

client/src/exposeUnexposeAction.ts

@@ -1,10 +1,6 @@
-import { LanguageClient } from "vscode-languageclient";
+import { LanguageClient } from "vscode-languageclient/node";
 import { ExtensionContext, commands } from "vscode";
-import {
-  ExposeRequest,
-  UnexposeRequest,
-  IExposeUnexposeParams,
-} from "./protocol";
+import { Protocol } from "@elm-tooling/elm-language-server";
 
 export function registerCommands(
   languageClient: LanguageClient,
@@ -13,7 +9,7 @@ export function registerCommands(
   context.subscriptions.push(
     commands.registerCommand(
       "elm.expose",
-      async (params: IExposeUnexposeParams) => {
+      async (params: Protocol.IExposeUnexposeParams) => {
         await expose(languageClient, params);
       },
     ),
@@ -22,7 +18,7 @@ export function registerCommands(
   context.subscriptions.push(
     commands.registerCommand(
       "elm.unexpose",
-      async (params: IExposeUnexposeParams) => {
+      async (params: Protocol.IExposeUnexposeParams) => {
         await unexpose(languageClient, params);
       },
     ),
@@ -31,14 +27,14 @@ export function registerCommands(
 
 async function expose(
   languageClient: LanguageClient,
-  params: IExposeUnexposeParams,
+  params: Protocol.IExposeUnexposeParams,
 ) {
-  await languageClient.sendRequest(ExposeRequest, params);
+  await languageClient.sendRequest(Protocol.ExposeRequest, params);
 }
 
 async function unexpose(
   languageClient: LanguageClient,
-  params: IExposeUnexposeParams,
+  params: Protocol.IExposeUnexposeParams,
 ) {
-  await languageClient.sendRequest(UnexposeRequest, params);
+  await languageClient.sendRequest(Protocol.UnexposeRequest, params);
 }

client/src/extension.ts

@@ -15,20 +15,25 @@ import {
   WorkspaceFolder,
 } from "vscode";
 import {
-  LanguageClient,
   LanguageClientOptions,
   Middleware,
   ResolveCodeLensSignature,
   RevealOutputChannelOn,
-  TransportKind,
   ProvideCodeLensesSignature,
   DidChangeConfigurationNotification,
+  Disposable,
 } from "vscode-languageclient";
+import {
+  LanguageClient,
+  ServerOptions,
+  TransportKind,
+} from "vscode-languageclient/node";
 import * as Package from "./elmPackage";
 import * as RefactorAction from "./refactorAction";
 import * as ExposeUnexposeAction from "./exposeUnexposeAction";
 import * as Restart from "./restart";
-import { OnDidCreateFilesRequest, OnDidRenameFilesRequest } from "./protocol";
+import { Protocol } from "@elm-tooling/elm-language-server";
+import { FileBasedCancellationStrategy } from "./cancellation";
 
 export type ElmAnalyseTrigger = "change" | "save" | "never";
 
@@ -83,6 +88,8 @@ function getOuterMostWorkspaceFolder(
   return folder;
 }
 
+const disposables: Disposable[] = [];
+
 export function activate(context: ExtensionContext): void {
   const module = context.asAbsolutePath(path.join("server", "out", "index.js"));
 
@@ -114,16 +121,24 @@ export function activate(context: ExtensionContext): void {
         relativeWorkspace.length > 0 ? `Elm (${relativeWorkspace})` : "Elm",
       );
 
+      const cancellationStrategy = new FileBasedCancellationStrategy();
+      disposables.push(cancellationStrategy);
+
       const debugOptions = {
         execArgv: ["--nolazy", `--inspect=${6010 + clients.size}`],
       };
-      const serverOptions = {
+      const serverOptions: ServerOptions = {
         debug: {
           module,
           options: debugOptions,
           transport: TransportKind.ipc,
+          args: cancellationStrategy.getCommandLineArguments(),
+        },
+        run: {
+          module,
+          transport: TransportKind.ipc,
+          args: cancellationStrategy.getCommandLineArguments(),
         },
-        run: { module, transport: TransportKind.ipc },
       };
       const clientOptions: LanguageClientOptions = {
         diagnosticCollectionName: "Elm",
@@ -143,6 +158,9 @@ export function activate(context: ExtensionContext): void {
         progressOnInitialization: true,
         revealOutputChannelOn: RevealOutputChannelOn.Never,
         workspaceFolder: folder,
+        connectionOptions: {
+          cancellationStrategy,
+        },
       };
       const client = new LanguageClient(
         "elmLS",
@@ -173,15 +191,17 @@ export function activate(context: ExtensionContext): void {
   Workspace.onDidCreateFiles((e) => {
     if (e.files.some((file) => file.toString().endsWith(".elm"))) {
       clients.forEach(
-        (client) => void client.sendRequest(OnDidCreateFilesRequest, e),
+        (client) =>
+          void client.sendRequest(Protocol.OnDidCreateFilesRequest, e),
       );
     }
   });
 
   Workspace.onDidRenameFiles((e) => {
     if (e.files.some(({ newUri }) => newUri.toString().endsWith(".elm"))) {
       clients.forEach(
-        (client) => void client.sendRequest(OnDidRenameFilesRequest, e),
+        (client) =>
+          void client.sendRequest(Protocol.OnDidRenameFilesRequest, e),
       );
     }
   });
@@ -223,6 +243,7 @@ export function activate(context: ExtensionContext): void {
 }
 
 export function deactivate(): Thenable<void> | undefined {
+  disposables.forEach((d) => d.dispose());
   const promises: Thenable<void>[] = [];
   for (const client of clients.values()) {
     promises.push(client.stop());

client/src/protocol.ts

@@ -1,6 +1,7 @@
 import { commands, ExtensionContext, window } from "vscode";
-import { CodeActionParams, LanguageClient } from "vscode-languageclient";
-import { GetMoveDestinationRequest, MoveRequest } from "./protocol";
+import { CodeActionParams } from "vscode-languageclient";
+import { LanguageClient } from "vscode-languageclient/node";
+import { Protocol } from "@elm-tooling/elm-language-server";
 
 export function registerCommands(
   languageClient: LanguageClient,
@@ -28,7 +29,7 @@ async function moveFunction(
   commandInfo: string,
 ) {
   const moveDestinations = await languageClient.sendRequest(
-    GetMoveDestinationRequest,
+    Protocol.GetMoveDestinationRequest,
     {
       sourceUri: params.textDocument.uri,
       params,
@@ -65,7 +66,7 @@ async function moveFunction(
     return;
   }
 
-  await languageClient.sendRequest(MoveRequest, {
+  await languageClient.sendRequest(Protocol.MoveRequest, {
     sourceUri: params.textDocument.uri,
     params,
     destination: selected.destination,

client/src/refactorAction.ts

@@ -1,6 +1,6 @@
 "use strict";
 import * as vscode from "vscode";
-import { LanguageClient } from "vscode-languageclient";
+import { LanguageClient } from "vscode-languageclient/node";
 
 export function registerCommand(
   langClients: Map<string, LanguageClient>,