Properly disconnect socket io on exit

src/common/debugger_communication_client.py

@@ -79,3 +79,8 @@ def input_changed(data):
 @sio.on("received_state")
 def received_state(data):
     processing_state_event.set()
+
+
+@sio.on("process_disconnect")
+def process_disconnect(data):
+    sio.disconnect()

src/debugger/debugAdapter.ts

@@ -1,16 +1,20 @@
 import { DebugAdapterTracker, DebugConsole, DebugSession } from "vscode";
+import { DebuggerCommunicationService } from "../service/debuggerCommunicationService";
 import { MessagingService } from "../service/messagingService";
 import { DEBUG_COMMANDS } from "../view/constants";
 
 export class DebugAdapter implements DebugAdapterTracker {
     private readonly console: DebugConsole | undefined;
     private readonly messagingService: MessagingService;
+    private debugCommunicationService: DebuggerCommunicationService;
     constructor(
         debugSession: DebugSession,
-        messagingService: MessagingService
+        messagingService: MessagingService,
+        debugCommunicationService: DebuggerCommunicationService
     ) {
         this.console = debugSession.configuration.console;
         this.messagingService = messagingService;
+        this.debugCommunicationService = debugCommunicationService;
     }
     onWillStartSession() {
         // To Implement
@@ -24,6 +28,13 @@ export class DebugAdapter implements DebugAdapterTracker {
                     break;
                 case DEBUG_COMMANDS.STACK_TRACE:
                     this.messagingService.sendPauseMessage();
+                    break;
+                case DEBUG_COMMANDS.DISCONNECT:
+                    // Triggered on stop event for debugger
+                    if (!message.arguments.restart) {
+                        this.debugCommunicationService.handleStopEvent();
+                    }
+                    break;
             }
         }
     }

src/debugger/debugAdapterFactory.ts

@@ -4,22 +4,30 @@ import {
     DebugSession,
     ProviderResult,
 } from "vscode";
+import { DebuggerCommunicationService } from "../service/debuggerCommunicationService";
 import { MessagingService } from "../service/messagingService";
 import { DebugAdapter } from "./debugAdapter";
 
 export class DebugAdapterFactory implements DebugAdapterTrackerFactory {
     private debugSession: DebugSession;
     private messagingService: MessagingService;
+    private debugCommunicationService: DebuggerCommunicationService;
     constructor(
         debugSession: DebugSession,
-        messagingService: MessagingService
+        messagingService: MessagingService,
+        debugCommunicationService: DebuggerCommunicationService
     ) {
         this.debugSession = debugSession;
         this.messagingService = messagingService;
+        this.debugCommunicationService = debugCommunicationService;
     }
     public createDebugAdapterTracker(
         session: DebugSession
     ): ProviderResult<DebugAdapterTracker> {
-        return new DebugAdapter(session, this.messagingService);
+        return new DebugAdapter(
+            session,
+            this.messagingService,
+            this.debugCommunicationService
+        );
     }
 }

src/debuggerCommunicationServer.ts

@@ -6,11 +6,11 @@ import * as socketio from "socket.io";
 import { WebviewPanel } from "vscode";
 import { SERVER_INFO } from "./constants";
 
-const DEBUGGER_MESSAGES = {
+export const DEBUGGER_MESSAGES = {
     EMITTER: {
         INPUT_CHANGED: "input_changed",
         RECEIVED_STATE: "received_state",
-        DISCONNECT: "frontend_disconnected",
+        DISCONNECT: "process_disconnect",
     },
     LISTENER: {
         UPDATE_STATE: "updateState",
@@ -45,10 +45,9 @@ export class DebuggerCommunicationServer {
         this.currentActiveDevice = currentActiveDevice;
     }
 
+    // send the message to start closing the connection
     public closeConnection(): void {
-        this.serverIo.close();
-        this.serverHttp.close();
-        console.info("Closing the server");
+        this.sendDisconnectEvent();
     }
 
     public setWebview(webviewPanel: WebviewPanel | undefined) {
@@ -71,6 +70,13 @@ export class DebuggerCommunicationServer {
             this.isPendingResponse = true;
         }
     }
+    public disconnectFromPort() {
+        this.serverIo.close();
+        this.serverHttp.close();
+    }
+    private sendDisconnectEvent() {
+        this.serverIo.emit(DEBUGGER_MESSAGES.EMITTER.DISCONNECT, {});
+    }
 
     private initHttpServer(): void {
         this.serverHttp.listen(this.port);

src/extension.ts

@@ -21,6 +21,7 @@ import { DebugAdapterFactory } from "./debugger/debugAdapterFactory";
 import { DebuggerCommunicationServer } from "./debuggerCommunicationServer";
 import * as utils from "./extension_utils/utils";
 import { SerialMonitor } from "./serialMonitor";
+import { DebuggerCommunicationService } from "./service/debuggerCommunicationService";
 import { MessagingService } from "./service/messagingService";
 import { SimulatorDebugConfigurationProvider } from "./simulatorDebugConfigurationProvider";
 import TelemetryAI from "./telemetry/telemetryAI";
@@ -36,12 +37,12 @@ let telemetryAI: TelemetryAI;
 let pythonExecutableName: string = "python";
 let configFileCreated: boolean = false;
 let inDebugMode: boolean = false;
-let debuggerCommunicationHandler: DebuggerCommunicationServer;
 // Notification booleans
 let firstTimeClosed: boolean = true;
 let shouldShowInvalidFileNamePopup: boolean = true;
 let shouldShowRunCodePopup: boolean = true;
 const messagingService = new MessagingService();
+const debuggerCommunicationService = new DebuggerCommunicationService();
 
 let currentActiveDevice: string = DEFAULT_DEVICE;
 
@@ -193,11 +194,11 @@ export async function activate(context: vscode.ExtensionContext) {
                                 console.log(`About to write ${messageJson} \n`);
                                 if (
                                     inDebugMode &&
-                                    debuggerCommunicationHandler
+                                    debuggerCommunicationService.getCurrentDebuggerServer()
                                 ) {
-                                    debuggerCommunicationHandler.emitInputChanged(
-                                        messageJson
-                                    );
+                                    debuggerCommunicationService
+                                        .getCurrentDebuggerServer()
+                                        .emitInputChanged(messageJson);
                                 } else if (childProcess) {
                                     childProcess.stdin.write(
                                         messageJson + "\n"
@@ -240,11 +241,11 @@ export async function activate(context: vscode.ExtensionContext) {
                                 console.log(`Sensor changed ${messageJson} \n`);
                                 if (
                                     inDebugMode &&
-                                    debuggerCommunicationHandler
+                                    debuggerCommunicationService.getCurrentDebuggerServer()
                                 ) {
-                                    debuggerCommunicationHandler.emitInputChanged(
-                                        messageJson
-                                    );
+                                    debuggerCommunicationService
+                                        .getCurrentDebuggerServer()
+                                        .emitInputChanged(messageJson);
                                 } else if (childProcess) {
                                     childProcess.stdin.write(
                                         messageJson + "\n"
@@ -283,8 +284,12 @@ export async function activate(context: vscode.ExtensionContext) {
             currentPanel.onDidDispose(
                 () => {
                     currentPanel = undefined;
-                    if (debuggerCommunicationHandler) {
-                        debuggerCommunicationHandler.setWebview(undefined);
+                    if (
+                        debuggerCommunicationService.getCurrentDebuggerServer()
+                    ) {
+                        debuggerCommunicationService
+                            .getCurrentDebuggerServer()
+                            .setWebview(undefined);
                     }
                     killProcessIfRunning();
                     if (firstTimeClosed) {
@@ -947,7 +952,8 @@ export async function activate(context: vscode.ExtensionContext) {
 
     const debugAdapterFactory = new DebugAdapterFactory(
         vscode.debug.activeDebugSession,
-        messagingService
+        messagingService,
+        debuggerCommunicationService
     );
     vscode.debug.registerDebugAdapterTrackerFactory(
         "python",
@@ -958,27 +964,29 @@ export async function activate(context: vscode.ExtensionContext) {
         if (simulatorDebugConfiguration.deviceSimulatorExpressDebug) {
             // Reinitialize process
             killProcessIfRunning();
-            console.log("Debug Started");
             inDebugMode = true;
 
             try {
                 // Shut down existing server on debug restart
-                if (debuggerCommunicationHandler) {
-                    debuggerCommunicationHandler.closeConnection();
-                    debuggerCommunicationHandler = undefined;
+                if (debuggerCommunicationService.getCurrentDebuggerServer()) {
+                    debuggerCommunicationService.resetCurrentDebuggerServer();
                 }
 
-                debuggerCommunicationHandler = new DebuggerCommunicationServer(
-                    currentPanel,
-                    utils.getServerPortConfig(),
-                    currentActiveDevice
+                debuggerCommunicationService.setCurrentDebuggerServer(
+                    new DebuggerCommunicationServer(
+                        currentPanel,
+                        utils.getServerPortConfig(),
+                        currentActiveDevice
+                    )
                 );
 
                 handleDebuggerTelemetry();
 
                 openWebview();
                 if (currentPanel) {
-                    debuggerCommunicationHandler.setWebview(currentPanel);
+                    debuggerCommunicationService
+                        .getCurrentDebuggerServer()
+                        .setWebview(currentPanel);
                     currentPanel.webview.postMessage({
                         currentActiveDevice,
                         command: "activate-play",
@@ -1005,12 +1013,10 @@ export async function activate(context: vscode.ExtensionContext) {
     // On Debug Session Stop: Stop communiation
     const debugSessionStopped = vscode.debug.onDidTerminateDebugSession(() => {
         if (simulatorDebugConfiguration.deviceSimulatorExpressDebug) {
-            console.log("Debug Stopped");
             inDebugMode = false;
             simulatorDebugConfiguration.deviceSimulatorExpressDebug = false;
-            if (debuggerCommunicationHandler) {
-                debuggerCommunicationHandler.closeConnection();
-                debuggerCommunicationHandler = undefined;
+            if (debuggerCommunicationService.getCurrentDebuggerServer()) {
+                debuggerCommunicationService.resetCurrentDebuggerServer();
             }
             if (currentPanel) {
                 currentPanel.webview.postMessage({

src/service/debuggerCommunicationService.ts

@@ -0,0 +1,27 @@
+import { DebuggerCommunicationServer } from "../debuggerCommunicationServer";
+
+export class DebuggerCommunicationService {
+    private currentDebuggerServer?: DebuggerCommunicationServer;
+    private previousDebuggerServerToDisconnect?: DebuggerCommunicationServer;
+
+    public setCurrentDebuggerServer(debugServer: DebuggerCommunicationServer) {
+        this.currentDebuggerServer = debugServer;
+    }
+    // Used for restart and stop event
+    public resetCurrentDebuggerServer() {
+        if (this.currentDebuggerServer) {
+            this.currentDebuggerServer.closeConnection();
+        }
+        this.previousDebuggerServerToDisconnect = this.currentDebuggerServer;
+        this.currentDebuggerServer = undefined;
+    }
+    public getCurrentDebuggerServer() {
+        return this.currentDebuggerServer;
+    }
+    // Only used for stop event
+    public handleStopEvent() {
+        if (this.previousDebuggerServerToDisconnect) {
+            this.previousDebuggerServerToDisconnect.disconnectFromPort();
+        }
+    }
+}

src/view/constants.ts

@@ -80,6 +80,7 @@ export enum VSCODE_MESSAGES_TO_WEBVIEW {
 export enum DEBUG_COMMANDS {
     STACK_TRACE = "stackTrace",
     CONTINUE = "continue",
+    DISCONNECT = "disconnect",
 }
 export enum SENSOR_LIST {
     TEMPERATURE = "temperature",