VsCode plugin: review adjustments

Aleksander Boruch-Gruszecki · Aleksander Boruch-Gruszecki · commit 34f7a11d4c47 · 2018-10-12T18:17:42.000+02:00
An item in status bar now shows tracing status and can be clicked to
adjust consent.

Tracing and workspace dump now take into account that consent can be
given/revoked - workspace dump is only initialized after consent is
given, tracing socket is only created lazily as necessary.
diff --git a/vscode-dotty/src/extension.ts b/vscode-dotty/src/extension.ts
@@ -14,7 +14,7 @@ import { enableOldServerWorkaround } from './compat'
 
 import { Tracer } from './tracer';
 
-const extensionName = 'dotty';
+export const extensionName = 'dotty';
 const extensionConfig = vscode.workspace.getConfiguration(extensionName);
 
 let extensionContext: ExtensionContext
@@ -166,8 +166,7 @@ function configureIDE(sbtClasspath: string, languageServerScalaVersion: string,
 
 function run(serverOptions: ServerOptions, isOldServer: boolean) {
 
-  tracer.initializeAsyncWorkspaceDump();
-  const tracingOutputChannel = tracer.createLspOutputChannel();
+  const { lspOutputChannel } = tracer.run();
 
   const clientOptions: LanguageClientOptions = {
     documentSelector: [
@@ -177,7 +176,7 @@ function run(serverOptions: ServerOptions, isOldServer: boolean) {
     synchronize: {
       configurationSection: 'dotty'
     },
-    outputChannel: tracingOutputChannel,
+    outputChannel: lspOutputChannel,
     revealOutputChannelOn: RevealOutputChannelOn.Never
   }
 
@@ -188,5 +187,4 @@ function run(serverOptions: ServerOptions, isOldServer: boolean) {
   // Push the disposable to the context's subscriptions so that the
   // client can be deactivated on extension deactivation
   extensionContext.subscriptions.push(client.start());
-  if (tracingOutputChannel) extensionContext.subscriptions.push(tracingOutputChannel);
 }
diff --git a/vscode-dotty/src/tracer.ts b/vscode-dotty/src/tracer.ts
@@ -7,8 +7,11 @@ import * as archiver from 'archiver';
 import * as WebSocket from 'ws';
 import * as request from 'request';
 
+import { extensionName } from './extension';
 import { TracingConsentCache } from './tracing-consent';
 
+const consentCommandName = `${extensionName}.adjust-consent`;
+
 export interface Ctx {
   readonly extensionContext: vscode.ExtensionContext,
   readonly extensionConfig: vscode.WorkspaceConfiguration,
@@ -24,13 +27,20 @@ export class Tracer {
 
     private tracingConsent: TracingConsentCache
 
-    private remoteTracingUrl?: string
+    private readonly remoteTracingUrl: string | undefined
+    private readonly remoteWorkspaceDumpUrl: string | undefined
+    private get isTracingEnabled(): boolean {
+        return Boolean(this.remoteWorkspaceDumpUrl || this.remoteTracingUrl);
+    }
 
     constructor(ctx: Ctx) {
         this.ctx = ctx;
 
         this.tracingConsent = new TracingConsentCache(ctx.extensionContext.workspaceState);
 
+        this.remoteWorkspaceDumpUrl = this.ctx.extensionConfig.get<string>('remoteWorkspaceDumpUrl');
+        this.remoteTracingUrl = this.ctx.extensionConfig.get<string>('remoteTracingUrl');
+
         this.machineId = (() => {
             const machineIdKey = 'tracing.machineId';
             function persisted(value: string): string {
@@ -60,35 +70,82 @@ export class Tracer {
         this.sessionId = new Date().toISOString();
     }
 
-    initializeAsyncWorkspaceDump() {
-        const remoteWorkspaceDumpUrl = this.ctx.extensionConfig.get<string>('remoteWorkspaceDumpUrl');
-        if (remoteWorkspaceDumpUrl === undefined) return;
+    run(): { lspOutputChannel?: vscode.OutputChannel } {
+        const consentCommandDisposable = vscode.commands.registerCommand(consentCommandName, () => this.askForTracingConsent());
+        if (this.isTracingEnabled && this.tracingConsent.get() === 'no-answer') this.askForTracingConsent();
+        this.initializeAsyncWorkspaceDump();
+        const lspOutputChannel = this.createLspOutputChannel();
+        const statusBarItem = this.createStatusBarItem();
+        for (const disposable of [consentCommandDisposable, lspOutputChannel, statusBarItem]) {
+            if (disposable) this.ctx.extensionContext.subscriptions.push(disposable);
+        }
+        return { lspOutputChannel };
+    }
+
+    private askForTracingConsent(): void {
+        vscode.window.showInformationMessage(
+            'Do you want to help EPFL develop Dotty LSP plugin by uploading your LSP communication? ' +
+            'PLEASE BE AWARE that the data sent contains your entire codebase and ALL the IDE actions, ' +
+            'including every single keystroke.',
+            'yes', 'no'
+        ).then((value: string | undefined) => {
+            if (value === 'yes' || value === 'no') this.tracingConsent.set(value);
+        });
+    }
 
-        try {
-            this.asyncUploadWorkspaceDump(remoteWorkspaceDumpUrl);
-        } catch (err) {
-            this.logError('error during workspace dump', safeError(err));
+    private initializeAsyncWorkspaceDump() {
+        if (this.remoteWorkspaceDumpUrl === undefined) return;
+        // convince TS that this is a string
+        const definedUrl: string = this.remoteWorkspaceDumpUrl;
+
+        const doInitialize = () => {
+            try {
+                this.asyncUploadWorkspaceDump(definedUrl);
+            } catch (err) {
+                this.logError('error during workspace dump', safeError(err));
+            }
+        };
+
+        if (this.tracingConsent.get() === 'yes') {
+            doInitialize()
+        } else {
+            let didInitialize = false;
+            this.tracingConsent.subscribe(() => {
+                if (didInitialize) return;
+                didInitialize = true;
+                doInitialize();
+            })
         }
     }
 
-    createLspOutputChannel(): vscode.OutputChannel | undefined {
-        const remoteTracingUrl = this.ctx.extensionConfig.get<string>('remoteTracingUrl');
-        if (!remoteTracingUrl) return undefined;
-
-        if (this.tracingConsent.get() === 'no-answer') {
-            vscode.window.showInformationMessage(
-                'Do you want to help EPFL develop this plugin by uploading your usage data? ' +
-                'PLEASE BE AWARE that this will upload all of your keystrokes and all of your code, ' +
-                'among other things.',
-                'yes', 'no'
-            ).then((value: string | undefined) => {
-                if (value === 'yes' || value === 'no') this.tracingConsent.set(value);
-            });
+    private createStatusBarItem(): vscode.StatusBarItem | undefined {
+        if (!this.isTracingEnabled) return undefined;
+        const item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 0)
+        item.command = consentCommandName;
+        const renderStatusBarItem = () => {
+            item.text = (() => {
+                const desc = this.tracingConsent.get() === 'yes' ? 'ON' : 'OFF';
+                return `$(radio-tower) Dotty trace: ${desc}`;
+            })();
+
+            item.tooltip = (() => {
+                const desc = this.tracingConsent.get() === 'yes' ? 'consented' : 'not consented';
+                return `This workspace is configured for remote tracing of Dotty LSP and you have ${desc} to it. ` +
+                    'Click to adjust your consent.';
+            })();
         }
+        renderStatusBarItem();
+        this.tracingConsent.subscribe(renderStatusBarItem);
+        item.show();
+        return item;
+    }
+
+    private createLspOutputChannel(): vscode.OutputChannel | undefined {
+        if (!this.remoteTracingUrl) return undefined;
 
         const localLspOutputChannel = vscode.window.createOutputChannel('Dotty LSP Communication')
         try {
-            return this.createRemoteLspOutputChannel(remoteTracingUrl, localLspOutputChannel);
+            return this.createRemoteLspOutputChannel(this.remoteTracingUrl, localLspOutputChannel);
         } catch (err) {
             this.logError('error during remote output channel creation', safeError(err));
             return localLspOutputChannel;
@@ -97,6 +154,7 @@ export class Tracer {
 
     private asyncUploadWorkspaceDump(url: string) {
         const storagePath = this.ctx.extensionContext.storagePath;
+        // TODO: handle multi-root workspaces
         const rootPath = vscode.workspace.rootPath;
         if (storagePath === undefined || rootPath === undefined) {
             this.logError('Cannot start workspace dump b/c of workspace state:', { storagePath, rootPath });
@@ -106,7 +164,7 @@ export class Tracer {
         if (!fs.existsSync(storagePath)) fs.mkdirSync(storagePath);
         const outputPath = path.join(storagePath, 'workspace-dump.zip');
         if (fs.existsSync(outputPath)) fs.unlinkSync(outputPath);
-        let output = fs.createWriteStream(outputPath);
+        const output = fs.createWriteStream(outputPath);
         output.on('end', () => {
             this.ctx.extensionOut.appendLine('zip - data has been drained');
         });
@@ -138,57 +196,81 @@ export class Tracer {
             );
         });
         zip.pipe(output);
-        zip.glob('./**/*.{scala,sbt}', { cwd: rootPath });
+        zip.glob('./**/*.{scala,sc,sbt,java}', { cwd: rootPath });
+        zip.glob('./**/.dotty-ide{.json,-artifact}', { cwd: rootPath });
         zip.finalize();
     }
 
     private createRemoteLspOutputChannel(
         remoteTracingUrl: string,
         localOutputChannel: vscode.OutputChannel
     ): vscode.OutputChannel {
-        const socketHeaders = {
-            'X-DLS-Project-ID': this.projectId,
-            'X-DLS-Client-ID': this.machineId,
-            'X-DLS-Session-ID': this.sessionId,
-        };
+        const createSocket = () => {
+            const socket = new WebSocket(remoteTracingUrl, {
+                headers: {
+                    'X-DLS-Project-ID': this.projectId,
+                    'X-DLS-Client-ID': this.machineId,
+                    'X-DLS-Session-ID': this.sessionId,
+                },
+            });
+
+            const timer = setInterval(
+                () => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send('');
+                    } else if (socket.readyState === WebSocket.CLOSED) {
+                        clearInterval(timer);
+                    }
+                },
+                10 * 1000 /*ms*/,
+            )
+
+            socket.onerror = (event) => {
+                this.logErrorWithoutNotifying(
+                    'socket error',
+                    remoteTracingUrl,
+                    new SafeJsonifier(event, (event) => ({
+                        error: safeError(event.error),
+                        message: event.message,
+                        type: event.type
+                    }))
+                );
+                vscode.window.showWarningMessage('An error occured in Dotty LSP remote tracing connection.');
+            }
 
-        const socket = new WebSocket(remoteTracingUrl, { headers: socketHeaders });
+            socket.onclose = (event) => {
+                this.logErrorWithoutNotifying(
+                    'socket closed',
+                    remoteTracingUrl,
+                    new SafeJsonifier(event, (event) => ({
+                        wasClean: event.wasClean,
+                        code: event.code,
+                        reason: event.reason
+                    }))
+                );
+                vscode.window.showWarningMessage('Dotty LSP remote tracing connection was dropped.');
+            }
 
-        const timer = setInterval(
-            () => {
-                if (socket.readyState === WebSocket.OPEN) {
-                    socket.send('');
-                } else if (socket.readyState === WebSocket.CLOSED) {
-                    clearInterval(timer);
+            return socket;
+        };
+
+        let alreadyCreated = false;
+        let socket: WebSocket;
+        // note: creating socket lazily is important for correctness
+        // if the user did not initially give his consent on IDE start, but gives it afterwards
+        // we only want to start a connection and upload data *after* being given consent
+        const withSocket: (thunk: (socket: WebSocket) => any) => void = (thunk) => {
+            // only try to create the socket _once_ to avoid endlessly looping
+            if (!alreadyCreated) {
+                alreadyCreated = true;
+                try {
+                    socket = createSocket();
+                } catch (err) {
+                    this.logError('socket create error', safeError(err));
                 }
-            },
-            10 * 1000 /*ms*/,
-        )
-
-        socket.onerror = (event) => {
-            this.logErrorWithoutNotifying(
-                'socket error',
-                remoteTracingUrl,
-                new SafeJsonifier(event, (event) => ({
-                    error: safeError(event.error),
-                    message: event.message,
-                    type: event.type
-                }))
-            );
-            vscode.window.showWarningMessage('An error occured in Dotty LSP remote tracing connection.');
-        }
+            }
 
-        socket.onclose = (event) => {
-            this.logErrorWithoutNotifying(
-                'socket closed',
-                remoteTracingUrl,
-                new SafeJsonifier(event, (event) => ({
-                    wasClean: event.wasClean,
-                    code: event.code,
-                    reason: event.reason
-                }))
-            );
-            vscode.window.showWarningMessage('Dotty LSP remote tracing connection was dropped.');
+            if (socket) thunk(socket);
         }
 
         let log: string = '';
@@ -210,21 +292,23 @@ export class Tracer {
 
                 log += value;
                 log += '\n';
-                if (this.tracingConsent.get() === 'yes' && socket.readyState === WebSocket.OPEN) {
-                    socket.send(log, (err) => {
-                        if (err) {
-                            this.logError('socket send error', err)
-                        }
-                    });
-                    log = '';
-                }
+                if (this.tracingConsent.get() === 'yes') withSocket((socket) => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send(log, (err) => {
+                            if (err) {
+                                this.logError('socket send error', err)
+                            }
+                        });
+                        log = '';
+                    }
+                });
             },
 
             clear() { },
             show() { },
             hide() { },
             dispose() {
-                socket.close();
+                if (socket) socket.close();
                 localOutputChannel.dispose();
             }
         };
diff --git a/vscode-dotty/src/tracing-consent.ts b/vscode-dotty/src/tracing-consent.ts
@@ -5,7 +5,9 @@ export type TracingConsent = 'yes' | 'no' | 'no-answer';
 export class TracingConsentCache {
     private readonly workspaceState: Memento
 
+    // since updating Memento is async, caching prevents nonsense edge-cases
     private cache?: TracingConsent
+    private subscribers: Array<() => void> = [];
 
     constructor(workspaceState: Memento) {
         this.workspaceState = workspaceState;
@@ -23,5 +25,10 @@ export class TracingConsentCache {
     set(value: 'yes' | 'no'): void {
       this.workspaceState.update('remote-tracing-consent', value === 'yes');
       this.cache = value;
+      this.subscribers.forEach(f => f());
+    }
+
+    subscribe(callback: () => void): void {
+      this.subscribers.push(callback);
     }
 }
