Add interprocess communication between debug adapter and extension host

Author: ivanbuhov

package.json

@@ -25,6 +25,7 @@
   ],
   "license": "SEE LICENSE IN LICENSE.txt",
   "dependencies": {
+    "node-ipc": "^7.0.0",
     "source-map": "^0.5.3",
     "universal-analytics": "^0.3.11",
     "vscode-debugadapter": "^1.7.0",

src/debug-adapter/webKitDebugAdapter.ts

@@ -15,7 +15,7 @@ import * as ns from '../services/NsCliService';
 import {ILaunchRequestArgs, IAttachRequestArgs, IDebugAdapter, ISetBreakpointsArgs, ISetBreakpointsResponseBody, IBreakpoint,
     IStackTraceResponseBody, IScopesResponseBody, IVariablesResponseBody, ISourceResponseBody, IThreadsResponseBody, IEvaluateResponseBody} from './WebKitAdapterInterfaces';
 import {AnalyticsService} from '../services/analytics/AnalyticsService';
-
+import {ExtensionClient} from '../services/ipc/ExtensionClient';
 
 interface IScopeVarHandle {
     objectId: string;
@@ -115,7 +115,8 @@ export class WebKitDebugAdapter implements IDebugAdapter {
     }
 
     private _attach(args: IAttachRequestArgs | ILaunchRequestArgs) {
-        AnalyticsService.getInstance().launchDebugger(args.request, args.platform, args.emulator);
+        ExtensionClient.setAppRoot(utils.getAppRoot(args));
+        ExtensionClient.getInstance().analyticsLaunchDebugger({ request: args.request, platform: args.platform, emulator: args.emulator });
         this.initDiagnosticLogging(args.request, args);
         this.appRoot = utils.getAppRoot(args);
         this.platform = args.platform;

src/main.ts

@@ -3,6 +3,7 @@ import * as child from 'child_process';
 import * as ns from './services/NsCliService';
 import {ExtensionVersionInfo} from './services/ExtensionVersionInfo';
 import {AnalyticsService} from './services/analytics/AnalyticsService';
+import {ExtensionServer} from './services/ipc/ExtensionServer';
 
 function performVersionsCheck(context: vscode.ExtensionContext) {
     // Check the state of the existing NativeScript CLI
@@ -40,6 +41,7 @@ function performVersionsCheck(context: vscode.ExtensionContext) {
 
 // this method is called when the extension is activated
 export function activate(context: vscode.ExtensionContext) {
+    ExtensionServer.getInstance().start();
     performVersionsCheck(context);
 
     let runCommand = (project: ns.NSProject, options: string[]) => {
@@ -100,4 +102,8 @@ export function activate(context: vscode.ExtensionContext) {
 
     context.subscriptions.push(runIosCommand);
     context.subscriptions.push(runAndroidCommand);
+}
+
+export function deactivate() {
+    ExtensionServer.getInstance().stop();
 }

src/services/ipc/ExtensionClient.ts

@@ -0,0 +1,71 @@
+import * as path from 'path';
+import * as extProtocol from './ExtensionProtocol';
+let ipc = require('node-ipc');
+
+export class ExtensionClient {
+    private static _appRoot: string;
+    private static _instance: ExtensionClient;
+
+    private _idCounter = 0;
+    private _pendingRequests: Object;
+
+    private _ipcClientInitialized: Promise<any>;
+
+    public static getInstance() {
+        if (!this._instance) {
+            this._instance = new ExtensionClient();
+        }
+        return this._instance;
+    }
+
+    public static getAppRoot() {
+        return this._appRoot;
+    }
+
+    public static setAppRoot(appRoot: string) {
+        this._appRoot = appRoot;
+    }
+
+    constructor() {
+        if (!ExtensionClient.getAppRoot()) {
+            throw new Error(`Unable to connect to extension host. App root is '${ExtensionClient.getAppRoot()}'`);
+        }
+
+        this._idCounter = 0;
+        this._pendingRequests = {};
+
+        ipc.config.id = 'debug-adpater-' + process.pid;
+        ipc.config.retry = 1500;
+
+        this._ipcClientInitialized = new Promise((res, rej) => {
+            ipc.connectTo(
+                'extHost',
+                path.join(ExtensionClient.getAppRoot(), 'temp-nativescript-vscode-extension-pipe-handle'),
+                () => {
+                    ipc.of.extHost.on('connect', () => {
+                        res();
+                    });
+                    ipc.of.extHost.on('extension-protocol-message', (response: extProtocol.Response) => {
+                        (<(result: Object) => void>this._pendingRequests[response.requestId])(response.result);
+                    });
+                }
+            );
+        });
+    }
+
+    private callRemoteMethod(method: string, args: Object): Promise<Object> {
+        let request: extProtocol.Request = { id: 'req' + (++this._idCounter), method: method, args: args };
+        return new Promise<Object>((res, rej) => {
+            this._pendingRequests[request.id] = res;
+            ipc.of.extHost.emit('extension-protocol-message', request);
+        });
+    }
+
+    public analyticsLaunchDebugger(args: extProtocol.AnalyticsLaunchDebuggerArgs): Promise<any> {
+        return this.callRemoteMethod('analyticsLaunchDebugger', args);
+    }
+
+    public runRunCommand(args: extProtocol.AnalyticsRunRunCommandArgs): Promise<any> {
+        return this.callRemoteMethod('runRunCommand', args);
+    }
+}

src/services/ipc/ExtensionProtocol.ts

@@ -0,0 +1,21 @@
+export interface Request {
+    id: string;
+    method: string;
+    args: Object;
+}
+
+export interface Response {
+    requestId: string;
+    result: Object;
+}
+
+export interface AnalyticsLaunchDebuggerArgs {
+    request: string;
+    platform: string;
+    emulator: boolean;
+}
+
+export interface AnalyticsRunRunCommandArgs {
+    platform: string;
+    emulator: boolean;
+}

src/services/ipc/ExtensionServer.ts

@@ -0,0 +1,71 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import * as vscode from 'vscode';
+import * as extProtocol from './ExtensionProtocol';
+import {AnalyticsService} from '../analytics/AnalyticsService';
+let ipc = require('node-ipc');
+
+export class ExtensionServer {
+    private static _instance: ExtensionServer;
+
+    private _isRunning: boolean;
+
+    public static getInstance() {
+        if (!this._instance) {
+            this._instance = new ExtensionServer();
+        }
+        return this._instance;
+    }
+
+    constructor() {
+        this._isRunning = false;
+    }
+
+    public getPipeHandlePath(): string {
+        return vscode.workspace.rootPath ?
+            path.join(vscode.workspace.rootPath, 'temp-nativescript-vscode-extension-pipe-handle') :
+            null;
+    }
+
+    public start() {
+        if (!this._isRunning) {
+            let pipeHandlePath = this.getPipeHandlePath();
+            if (pipeHandlePath) {
+                ipc.serve(
+                    pipeHandlePath,
+                    () => {
+                        ipc.server.on('extension-protocol-message', (data: extProtocol.Request, socket) => {
+                            return (<Promise<Object>>this[data.method].call(this, data.args)).then(result => {
+                                let response: extProtocol.Response = { requestId: data.id, result: result };
+                                return ipc.server.emit(socket, 'extension-protocol-message', response);
+                            });
+                        });
+                    });
+                ipc.server.start();
+                this._isRunning = true;
+            }
+        }
+        return this._isRunning;
+    }
+
+    public stop() {
+        if (this._isRunning) {
+            ipc.server.stop();
+            this._isRunning = false;
+        }
+    }
+
+    public isRunning() {
+        return this._isRunning;
+    }
+
+    public analyticsLaunchDebugger(args: extProtocol.AnalyticsLaunchDebuggerArgs): Promise<any> {
+        return AnalyticsService.getInstance().launchDebugger(args.request, args.platform, args.emulator);
+    }
+
+    public runRunCommand(args: extProtocol.AnalyticsRunRunCommandArgs): Promise<any> {
+        return AnalyticsService.getInstance().runRunCommand(args.platform, args.emulator);
+    }
+
+
+}