Fixes LiveSync

Fixes LiveSync by restarting session. Each time we got terminate sessions event we wait 10 sec to get new port. If we get new port for debugging we restart the session.

Move cli process to main process because each restart the session is created(but the tns process is not killed) and we don't have reference to the long running tns process. Also conceptual it's better to have the cli output in the extension output but not in the debug console.

Fixes Debug Console messages and show exactly in which file is the console log.

Author: ivanovit

src/debug-adapter/nativeScriptDebugAdapter.ts

@@ -1,22 +1,21 @@
-import { ChildProcess } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import { ChromeDebugAdapter, logger } from 'vscode-chrome-debug-core';
-import { Event, OutputEvent, TerminatedEvent } from 'vscode-debugadapter';
+import { ChromeDebugAdapter, IRestartRequestArgs, logger } from 'vscode-chrome-debug-core';
+import { Event, TerminatedEvent } from 'vscode-debugadapter';
+import { DebugProtocol } from 'vscode-debugprotocol';
 import * as extProtocol from '../common/extensionProtocol';
-import * as utils from '../common/utilities';
 import { AndroidProject } from '../project/androidProject';
 import { IosProject } from '../project/iosProject';
 import { NativeScriptCli } from '../project/nativeScriptCli';
-import { IDebugResult } from '../project/project';
+
+const reconnectAfterLiveSyncTimeout = 10 * 1000;
 
 export function nativeScriptDebugAdapterGenerator(iosProject: typeof IosProject,
                                                   androidProject: typeof AndroidProject,
                                                   nativeScriptCli: typeof NativeScriptCli) {
     return class NativeScriptDebugAdapter extends ChromeDebugAdapter {
-        private _tnsProcess: ChildProcess;
         private _idCounter = 0;
         private _pendingRequests: object = {};
+        private isLiveSync: boolean = false;
+        private portWaitingResolve: any;
 
         public attach(args: any): Promise<void> {
             return this.processRequestAndAttach(args);
@@ -29,100 +28,94 @@ export function nativeScriptDebugAdapterGenerator(iosProject: typeof IosProject,
         public disconnect(args: any): void {
             super.disconnect(args);
 
-            if (this._tnsProcess) {
-                this._tnsProcess.stdout.removeAllListeners();
-                this._tnsProcess.stderr.removeAllListeners();
-                this._tnsProcess.removeAllListeners();
-                utils.killProcess(this._tnsProcess);
+            if (!args.restart) {
+                this.callRemoteMethod('buildService', 'disconnect');
             }
         }
 
+        public onPortReceived(port) {
+            this.portWaitingResolve && this.portWaitingResolve(port);
+        }
+
         public onExtensionResponse(response) {
             this._pendingRequests[response.requestId](response.result);
             delete this._pendingRequests[response.requestId];
         }
 
-        private async processRequestAndAttach(args: any) {
-            const transformedArgs = await this.processRequest(args);
-
-            (this.pathTransformer as any).setTargetPlatform(args.platform);
-            (ChromeDebugAdapter as any).SET_BREAKPOINTS_TIMEOUT = 20000;
-
-            return super.attach(transformedArgs);
-        }
-
-        private async processRequest(args: any): Promise<any> {
-            args = this.translateArgs(args);
-
-            this._session.sendEvent(new Event(extProtocol.BEFORE_DEBUG_START));
-
-            const tnsPath = await this.callRemoteMethod<string>('workspaceConfigService', 'tnsPath');
-            const cli = new nativeScriptCli(tnsPath, logger);
+        protected async terminateSession(reason: string, disconnectArgs?: DebugProtocol.DisconnectArguments, restart?: IRestartRequestArgs): Promise<void> {
+            let restartRequestArgs;
+            let timeoutId;
 
-            const project = args.platform === 'ios' ?
-                new iosProject(args.appRoot, cli) :
-                new androidProject(args.appRoot, cli);
+            if (this.isLiveSync) {
+                const portProm = new Promise<any>((res, rej) => {
+                    this. portWaitingResolve = res;
 
-            this.callRemoteMethod('analyticsService', 'launchDebugger', args.request, args.platform);
-
-            // Run CLI Command
-            const version = project.cli.executeGetVersion();
+                    timeoutId = setTimeout(() => {
+                        res();
+                    }, reconnectAfterLiveSyncTimeout);
+                });
 
-            this.log(`[NSDebugAdapter] Using tns CLI v${version} on path '${project.cli.path}'\n`);
-            this.log('[NSDebugAdapter] Running tns command...\n');
-            let cliCommand: IDebugResult;
+                restartRequestArgs = await portProm;
+                clearTimeout(timeoutId);
+            }
 
-            if (args.request === 'launch') {
-                let tnsArgs = args.tnsArgs;
+            await super.terminateSession(reason, disconnectArgs, restartRequestArgs);
+        }
 
-                // For iOS the TeamID is required if there's more than one.
-                // Therefore if not set, show selection to the user.
-                if (args.platform && args.platform.toLowerCase() === 'ios') {
-                    const teamId = this.getTeamId(path.join(args.appRoot, 'app'), tnsArgs);
+        protected hookConnectionEvents(): void {
+            super.hookConnectionEvents();
 
-                    if (!teamId) {
-                        const selectedTeam = await this.callRemoteMethod<{ id: string, name: string }>('iOSTeamService', 'selectTeam');
+            this.chrome.Log.onEntryAdded((params) => this.onEntryAdded(params));
+        }
 
-                        if (selectedTeam) {
-                            // add the selected by the user Team Id
-                            tnsArgs = (tnsArgs || []).concat(['--teamId', selectedTeam.id]);
-                            this.log(`[NSDebugAdapter] Using iOS Team ID '${selectedTeam.id}', you can change this in the workspace settings.\n`);
-                        }
-                    }
+        protected onEntryAdded(params: any): void {
+            if (params && params.entry && params.entry.level) {
+                const message = params.entry;
+
+                message.type = message.level;
+
+                const that = this as any;
+                const script = that.getScriptByUrl && that.getScriptByUrl(params.entry.url);
+
+                if (script) {
+                    message.stack = {
+                        callFrames: [
+                            {
+                                columnNumber: 0,
+                                lineNumber: params.entry.lineNumber,
+                                scriptId: script.scriptId,
+                                url: params.entry.url,
+                            },
+                        ],
+                    };
                 }
 
-                cliCommand = project.debug({ stopOnEntry: args.stopOnEntry, watch: args.watch }, tnsArgs);
-            } else if (args.request === 'attach') {
-                cliCommand = project.attach(args.tnsArgs);
+                this.onMessageAdded({
+                    message,
+                });
             }
+        }
 
-            if (cliCommand.tnsProcess) {
-                this._tnsProcess = cliCommand.tnsProcess;
-                cliCommand.tnsProcess.stdout.on('data', (data) => { this.log(data.toString()); });
-                cliCommand.tnsProcess.stderr.on('data', (data) => { this.log(data.toString()); });
+        private async processRequestAndAttach(args: any) {
+            const transformedArgs = this.translateArgs(args);
 
-                cliCommand.tnsProcess.on('close', (code, signal) => {
-                    this.log(`[NSDebugAdapter] The tns command finished its execution with code ${code}.\n`);
+            if (args.__restart) {
+                transformedArgs.port = args.__restart.port;
+            } else {
+                this._session.sendEvent(new Event(extProtocol.BEFORE_DEBUG_START));
+                transformedArgs.port = await this.callRemoteMethod('buildService', 'processRequest', transformedArgs);
+            }
 
-                    // Sometimes we execute "tns debug android --start" and the process finishes
-                    // which is totally fine. If there's an error we need to Terminate the session.
-                    if (code !== 0) {
-                        this.log(`The tns command finished its execution with code ${code}`);
-                        this._session.sendEvent(new TerminatedEvent());
-                    }
-                });
+            if (!transformedArgs.port) {
+                this._session.sendEvent(new TerminatedEvent());
             }
 
-            this.log('[NSDebugAdapter] Watching the tns CLI output to receive a connection token\n');
+            (this.pathTransformer as any).setTargetPlatform(args.platform);
+            (ChromeDebugAdapter as any).SET_BREAKPOINTS_TIMEOUT = 20000;
 
-            return new Promise<string | number> ((res, rej) => {
-                cliCommand.tnsOutputEventEmitter.on('readyForConnection', (connectionToken: string | number) => {
-                    this.log(`[NSDebugAdapter] Ready to attach to application on ${connectionToken}\n`);
-                    args.port = connectionToken;
+            this.isLiveSync = args.watch;
 
-                    res(args);
-                });
-            });
+            return super.attach(transformedArgs);
         }
 
         private translateArgs(args): any {
@@ -137,65 +130,6 @@ export function nativeScriptDebugAdapterGenerator(iosProject: typeof IosProject,
             return args;
         }
 
-        private log(text: string): void {
-            this._session.sendEvent(new OutputEvent(text));
-        }
-
-        private getTeamId(appRoot: string, tnsArgs?: string[]): string {
-            // try to get the TeamId from the TnsArgs
-            if (tnsArgs) {
-                const teamIdArgIndex = tnsArgs.indexOf('--teamId');
-
-                if (teamIdArgIndex > 0 && teamIdArgIndex + 1 < tnsArgs.length) {
-                    return tnsArgs[ teamIdArgIndex + 1 ];
-                }
-            }
-
-            // try to get the TeamId from the buildxcconfig or teamid file
-            const teamIdFromConfig = this.readTeamId(appRoot);
-
-            if (teamIdFromConfig) {
-                return teamIdFromConfig;
-            }
-
-            // we should get the Teams from the machine and ask the user if they are more than 1
-            return null;
-        }
-
-        private readXCConfig(appRoot: string, flag: string): string {
-            const xcconfigFile = path.join(appRoot, 'App_Resources/iOS/build.xcconfig');
-
-            if (fs.existsSync(xcconfigFile)) {
-                const text = fs.readFileSync(xcconfigFile, { encoding: 'utf8'});
-                let teamId: string;
-
-                text.split(/\r?\n/).forEach((line) => {
-                    line = line.replace(/\/(\/)[^\n]*$/, '');
-                    if (line.indexOf(flag) >= 0) {
-                        teamId = line.split('=')[1].trim();
-                        if (teamId[teamId.length - 1] === ';') {
-                            teamId = teamId.slice(0, -1);
-                        }
-                    }
-                });
-                if (teamId) {
-                    return teamId;
-                }
-            }
-
-            const fileName = path.join(appRoot, 'teamid');
-
-            if (fs.existsSync(fileName)) {
-                return fs.readFileSync(fileName, { encoding: 'utf8' });
-            }
-
-            return null;
-        }
-
-        private readTeamId(appRoot): string {
-            return this.readXCConfig(appRoot, 'DEVELOPMENT_TEAM');
-        }
-
         private callRemoteMethod<T>(service: string, method: string, ...args: any[]): Promise<T> {
             const request: extProtocol.IRequest = { id: `req${++this._idCounter}`, service, method, args };
 

src/main.ts

@@ -80,7 +80,10 @@ export function activate(context: vscode.ExtensionContext) {
         });
 
         const disposable = {
-            dispose: () => utils.killProcess(tnsProcess),
+            dispose: () => {
+                services.buildService.disconnect();
+                utils.killProcess(tnsProcess);
+            },
         };
 
         context.subscriptions.push(disposable);