Merge pull request #1379 from gregg-miskelly/debuggerEventsPipeName

Send events from the debugger to unit test code

Author: DustinCampbell

src/assets.ts

@@ -541,27 +541,10 @@ function doesAnyAssetExist(generator: AssetGenerator) {
     });
 }
 
-function deleteAsset(path: string) {
-    return new Promise<void>((resolve, reject) => {
-        fs.exists(path, exists => {
-            if (exists) {
-                // TODO: Should we check after unlinking to see if the file still exists?
-                fs.unlink(path, err => {
-                    if (err) {
-                        return reject(err);
-                    }
-
-                    resolve();
-                });
-            }
-        });
-    });
-}
-
 function deleteAssets(generator: AssetGenerator) {
     return Promise.all([
-        deleteAsset(generator.launchJsonPath),
-        deleteAsset(generator.tasksJsonPath)
+        util.deleteIfExists(generator.launchJsonPath),
+        util.deleteIfExists(generator.tasksJsonPath)
     ]);
 }
 

src/common.ts

@@ -73,6 +73,25 @@ export function fileExists(filePath: string): Promise<boolean> {
     });
 }
 
+export function deleteIfExists(filePath: string): Promise<void> {
+    return fileExists(filePath)
+    .then((exists: boolean) => {
+        return new Promise<void>((resolve, reject) => {
+            if (!exists) {
+                resolve();
+            }
+
+            fs.unlink(filePath, err => {
+                if (err) {
+                    return reject(err);
+                }
+
+                resolve();
+            });
+        });
+    });
+}
+
 export enum InstallFileType {
     Begin,
     Lock

src/coreclr-debug/debuggerEventsProtocol.ts

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+// This contains the definition of messages that VsDbg-UI can send back to a listener which registers itself via the 'debuggerEventsPipeName'
+// property on a launch or attach request.
+// 
+// All messages are sent as UTF-8 JSON text with a tailing '\n'
+export namespace DebuggerEventsProtocol {
+    export module EventType {
+        // Indicates that the vsdbg-ui has received the attach or launch request and is starting up
+        export const Starting = "starting";
+        // Indicates that vsdbg-ui has successfully launched the specified process.
+        // The ProcessLaunchedEvent interface details the event payload.
+        export const ProcessLaunched = "processLaunched";
+        // Debug session is ending
+        export const DebuggingStopped = "debuggingStopped";
+    };
+
+    export interface DebuggerEvent {
+        // Contains one of the 'DebuggerEventsProtocol.EventType' values
+        eventType: string;
+    }
+
+    export interface ProcessLaunchedEvent extends DebuggerEvent {
+        // Process id of the newly-launched target process
+        targetProcessId: number;
+    }
+
+    // Decodes a packet received from the debugger into an event
+    export function decodePacket(packet: Buffer) : DebuggerEvent {
+        // Verify the message ends in a newline
+        if (packet[packet.length-1] != 10 /*\n*/) {
+            throw new Error("Unexpected message received from debugger.");
+        }
+
+        const message = packet.toString('utf-8', 0, packet.length-1);
+        return JSON.parse(message);
+    }
+}

src/features/dotnetTest.ts

@@ -5,10 +5,14 @@
 
 import { OmniSharpServer } from '../omnisharp/server';
 import { toRange } from '../omnisharp/typeConvertion';
+import { DebuggerEventsProtocol } from '../coreclr-debug/debuggerEventsProtocol';
 import * as vscode from 'vscode';
 import * as serverUtils from "../omnisharp/utils";
 import * as protocol from '../omnisharp/protocol';
 import * as utils from '../common';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
 
 let _testOutputChannel: vscode.OutputChannel = undefined;
 
@@ -66,29 +70,33 @@ export function runDotnetTest(testMethod: string, fileName: string, testFramewor
         });
 }
 
-function createLaunchConfiguration(program: string, argsString: string, cwd: string) {
+function createLaunchConfiguration(program: string, argsString: string, cwd: string, debuggerEventsPipeName: string) {
     let args = utils.splitCommandLineArgs(argsString);
 
     return {
+        // NOTE: uncomment this for vsdbg developement
+        // debugServer: 4711,
         name: ".NET Test Launch",
         type: "coreclr",
         request: "launch",
+        debuggerEventsPipeName: debuggerEventsPipeName,
         program,
         args,
         cwd,
         stopAtEntry: true
     };
 }
 
-function getLaunchConfigurationForVSTest(server: OmniSharpServer, fileName: string, testMethod: string, testFrameworkName: string): Promise<any> {
+function getLaunchConfigurationForVSTest(server: OmniSharpServer, fileName: string, testMethod: string, testFrameworkName: string, debugEventListener: DebugEventListener): Promise<any> {
+
     const request: protocol.V2.DebugTestGetStartInfoRequest = {
         FileName: fileName,
         MethodName: testMethod,
         TestFrameworkName: testFrameworkName
     };
 
     return serverUtils.debugTestGetStartInfo(server, request)
-        .then(response => createLaunchConfiguration(response.FileName, response.Arguments, response.WorkingDirectory));
+        .then(response => createLaunchConfiguration(response.FileName, response.Arguments, response.WorkingDirectory, debugEventListener.pipePath()));
 }
 
 function getLaunchConfigurationForLegacy(server: OmniSharpServer, fileName: string, testMethod: string, testFrameworkName: string): Promise<any> {
@@ -99,16 +107,16 @@ function getLaunchConfigurationForLegacy(server: OmniSharpServer, fileName: stri
     };
 
     return serverUtils.getTestStartInfo(server, request)
-        .then(response => createLaunchConfiguration(response.Executable, response.Argument, response.WorkingDirectory));
+        .then(response => createLaunchConfiguration(response.Executable, response.Argument, response.WorkingDirectory, null));
 }
 
 
-function getLaunchConfiguration(server: OmniSharpServer, debugType: string, fileName: string, testMethod: string, testFrameworkName: string): Promise<any> {
+function getLaunchConfiguration(server: OmniSharpServer, debugType: string, fileName: string, testMethod: string, testFrameworkName: string, debugEventListener: DebugEventListener): Promise<any> {
     switch (debugType) {
         case "legacy":
             return getLaunchConfigurationForLegacy(server, fileName, testMethod, testFrameworkName);
         case "vstest":
-            return getLaunchConfigurationForVSTest(server, fileName, testMethod, testFrameworkName);
+            return getLaunchConfigurationForVSTest(server, fileName, testMethod, testFrameworkName, debugEventListener);
 
         default:
             throw new Error(`Unexpected debug type: ${debugType}`);
@@ -120,30 +128,35 @@ export function debugDotnetTest(testMethod: string, fileName: string, testFramew
     // We support to styles of 'dotnet test' for debugging: The legacy 'project.json' testing, and the newer csproj support
     // using VS Test. These require a different level of communication.
     let debugType: string;
+    let debugEventListener: DebugEventListener = null;
+    let outputChannel = getTestOutputChannel();
+    outputChannel.appendLine(`Debugging method '${testMethod}'.`);
 
     return serverUtils.requestProjectInformation(server, { FileName: fileName} )
         .then(projectInfo => {
             if (projectInfo.DotNetProject) {
                 debugType = "legacy";
+                return Promise.resolve();
             }
             else if (projectInfo.MsBuildProject) {
                 debugType = "vstest";
+                debugEventListener = new DebugEventListener(fileName, server, outputChannel);
+                return debugEventListener.start();
             }
             else {
                 throw new Error();
             }
-
-            return getLaunchConfiguration(server, debugType, fileName, testMethod, testFrameworkName);
         })
-        .then(config => vscode.commands.executeCommand('vscode.startDebug', config))
         .then(() => {
-            // For VS Test, we need to signal to start the test run after the debugger has launched.
-            // TODO: Need to find out when the debugger has actually launched. This is currently a race.
-            if (debugType === "vstest") {
-                serverUtils.debugTestRun(server, { FileName: fileName });
-            }
+            return getLaunchConfiguration(server, debugType, fileName, testMethod, testFrameworkName, debugEventListener);
         })
-        .catch(reason => vscode.window.showErrorMessage(`Failed to start debugger: ${reason}`));
+        .then(config => vscode.commands.executeCommand('vscode.startDebug', config))
+        .catch(reason => {
+            vscode.window.showErrorMessage(`Failed to start debugger: ${reason}`);
+            if (debugEventListener != null) {
+                debugEventListener.close();
+            }
+        });
 }
 
 export function updateCodeLensForTest(bucket: vscode.CodeLens[], fileName: string, node: protocol.Node, isDebugEnable: boolean) {
@@ -166,4 +179,118 @@ export function updateCodeLensForTest(bucket: vscode.CodeLens[], fileName: strin
                 { title: "debug test", command: 'dotnet.test.debug', arguments: [testFeature.Data, fileName, testFrameworkName] }));
         }
     }
+}
+
+class DebugEventListener {
+    static s_activeInstance : DebugEventListener = null;
+    _fileName: string;
+    _server: OmniSharpServer;
+    _outputChannel : vscode.OutputChannel;
+    _pipePath : string;
+
+    _serverSocket : net.Server;
+    _isClosed: boolean = false;
+
+    constructor(fileName: string, server: OmniSharpServer, outputChannel: vscode.OutputChannel) {
+        this._fileName = fileName;
+        this._server = server;
+        this._outputChannel = outputChannel;
+        // NOTE: The max pipe name on OSX is fairly small, so this name shouldn't bee too long.
+        const pipeSuffix = "TestDebugEvents-" + process.pid;
+        if (os.platform() === 'win32') {
+            this._pipePath = "\\\\.\\pipe\\Microsoft.VSCode.CSharpExt." + pipeSuffix;
+        } else {
+            this._pipePath = path.join(utils.getExtensionPath(), "." + pipeSuffix);
+        }
+    }
+
+    public start() : Promise<void> {
+
+        // We use our process id as part of the pipe name, so if we still somehow have an old instance running, close it.
+        if (DebugEventListener.s_activeInstance !== null) {
+            DebugEventListener.s_activeInstance.close();
+        }
+        DebugEventListener.s_activeInstance = this;
+        
+        this._serverSocket = net.createServer((socket: net.Socket) => {
+            socket.on('data', (buffer: Buffer) => {
+
+                let event: DebuggerEventsProtocol.DebuggerEvent;
+                try {
+                    event = DebuggerEventsProtocol.decodePacket(buffer);
+                } catch (e) {
+                    this._outputChannel.appendLine("Warning: Invalid event received from debugger");
+                    return;
+                }
+                
+                if (event.eventType === DebuggerEventsProtocol.EventType.ProcessLaunched) {
+                    let processLaunchedEvent = <DebuggerEventsProtocol.ProcessLaunchedEvent>(event);
+                    this._outputChannel.appendLine(`Started debugging process #${processLaunchedEvent.targetProcessId}.`);
+                    // TODO: provide the process id to OmniSharp
+                    serverUtils.debugTestRun(this._server, { FileName: this._fileName });
+                } else if (event.eventType === DebuggerEventsProtocol.EventType.DebuggingStopped) {
+                    this._outputChannel.appendLine("Debugging complete.");
+                    this.fireDebuggingStopped();
+                }
+            });
+
+            socket.on('end', () => {
+                this.fireDebuggingStopped();
+            });
+        });
+
+        return this.removeSocketFileIfExists().then(() => {
+            return new Promise<void>((resolve, reject) => {
+                let isStarted: boolean = false;
+                this._serverSocket.on('error', (err: Error) => {
+                    if (!isStarted) {
+                        reject(err.message);
+                    } else {
+                        this._outputChannel.appendLine("Warning: Communications error on debugger event channel. " + err.message);
+                    }
+                });
+                this._serverSocket.listen(this._pipePath, () => {
+                    isStarted = true;
+                    resolve();
+                });
+            });
+        });
+    }
+
+    public pipePath() : string {
+        return this._pipePath;
+    }
+
+    public close() {
+        if (this === DebugEventListener.s_activeInstance) {
+            DebugEventListener.s_activeInstance = null;
+        }
+        if (this._isClosed) {
+            return;
+        }
+        this._isClosed = true;
+
+        if (this._serverSocket !== null) {
+            this._serverSocket.close();
+        }
+    }
+
+    private fireDebuggingStopped() : void {
+        if (this._isClosed) {
+            return;
+        }
+        
+        // TODO: notify omniSharp
+
+        this.close();
+    }
+
+    private removeSocketFileIfExists() : Promise<void> {
+        if (os.platform() === 'win32') {
+            // Win32 doesn't use the file system for pipe names
+            return Promise.resolve();
+        } else {
+            return utils.deleteIfExists(this._pipePath);
+        }
+    }
 }