Fix Linux, 'EventType' declaration, and add '_isClosed'

- Added code to unlink the unix domain socket (in case there is one around from a previous reboot).
- I forgot that TypeScript enums don't behave quite like what I wanted. This switches from an enum to a module.
- Fixes DebugEventListener to cleanup only once.
- Handle errors in DebugEventListener

Author: gregg-miskelly

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

@@ -10,18 +10,19 @@
 // 
 // All messages are sent as UTF-8 JSON text with a tailing '\n'
 export namespace DebuggerEventsProtocol {
-    export enum EventType {
+    export module EventType {
         // Indicates that the vsdbg-ui has received the attach or launch request and is starting up
-        starting,
+        export const Starting = "starting";
         // Indicates that vsdbg-ui has successfully launched the specified process.
         // The ProcessLaunchedEvent interface details the event payload.
-        processLaunched,
+        export const ProcessLaunched = "processLaunched";
         // Debug session is ending
-        debuggingStopped
-    }
+        export const DebuggingStopped = "debuggingStopped";
+    };
 
     export interface DebuggerEvent {
-        eventType: EventType;
+        // Contains one of the 'DebuggerEventsProtocol.EventType' values
+        eventType: string;
     }
 
     export interface ProcessLaunchedEvent extends DebuggerEvent {

src/features/dotnetTest.ts

@@ -191,6 +191,7 @@ class DebugEventListener {
     _serverSocket : net.Server;
     _pipePath : string;
     _outputChannel : vscode.OutputChannel;
+    _isClosed: boolean = false;
 
     constructor() {
         // NOTE: The max pipe name on OSX is fairly small, so this name shouldn't bee too long.
@@ -211,8 +212,6 @@ class DebugEventListener {
             DebugEventListener.s_activeInstance.close();
         }
         DebugEventListener.s_activeInstance = this;
-
-        // TODO: On Unix do we need to unlink file if it exists already?     
 
         this._serverSocket = net.createServer((socket: net.Socket) => {
             socket.on('data', (buffer: Buffer) => {
@@ -225,7 +224,9 @@ class DebugEventListener {
                     return;
                 }
 
-                if (event.eventType === DebuggerEventsProtocol.EventType.debuggingStopped) {
+                if (event.eventType === DebuggerEventsProtocol.EventType.ProcessLaunched) {
+                    // TODO: notify OmniSharp
+                } else if (event.eventType === DebuggerEventsProtocol.EventType.DebuggingStopped) {
                     this.fireDebuggingStopped();
                 }
             });
@@ -235,9 +236,20 @@ class DebugEventListener {
             });
         });
 
-        return new Promise<void>((resolve, reject) => {
-            this._serverSocket.listen(this._pipePath, () => {
-                resolve();
+        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();
+                });
             });
         });
     }
@@ -250,15 +262,32 @@ class DebugEventListener {
         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);
+        }
+    }
 }