Merge pull request #1218 from ChinthakaJ98/remote-debugging

gigara · web-flow · commit 1b3fd909c73e · 2026-02-06T12:58:11.000+05:30
Support remote server debugging
diff --git a/workspaces/mi/mi-core/src/rpc-types/mi-diagram/types.ts b/workspaces/mi/mi-core/src/rpc-types/mi-diagram/types.ts
@@ -1779,6 +1779,7 @@ export interface SwaggerFromAPIRequest {
     swaggerPath?: string;
     isJsonIn?: boolean;
     isJsonOut?: boolean;
+    host?: string;
     port?: number;
     projectPath?: string;
 }
diff --git a/workspaces/mi/mi-extension/package.json b/workspaces/mi/mi-extension/package.json
@@ -82,17 +82,50 @@
                   "type": "string"
                 },
                 "default": []
+              },
+              "properties": {
+                "type": "object",
+                "description": "Debug properties for remote debugging",
+                "additionalProperties": {
+                  "type": [
+                    "string",
+                    "number"
+                  ]
+                },
+                "default": {}
               }
             }
           }
         },
         "initialConfigurations": [
           {
             "type": "mi",
-            "name": "MI: Run and Debug",
+            "name": "MI: Local Server Run and Debug",
+            "request": "launch",
+            "internalConsoleOptions": "openOnSessionStart",
+            "vmArgs": [],
+            "properties": {
+              "type": "local"
+            }
+          },
+          {
+            "type": "mi",
+            "name": "MI: Remote Server Run and Debug",
             "request": "launch",
             "internalConsoleOptions": "openOnSessionStart",
-            "vmArgs": []
+            "vmArgs": [],
+            "properties": {
+              "type": "remote",
+              "commandPort": 9005,
+              "eventPort": 9006,
+              "serverHost": "localhost",
+              "serverPort": 8290,
+              "serverReadinessPort": 9201,
+              "managementPort": 9164,
+              "managementUsername": "admin",
+              "managementPassword": "admin",
+              "connectionTimeoutInSecs": 10
+            }
           }
         ]
       }
diff --git a/workspaces/mi/mi-extension/src/debugger/activate.ts b/workspaces/mi/mi-extension/src/debugger/activate.ts
@@ -368,6 +368,6 @@ class InlineDebugAdapterFactory implements vscode.DebugAdapterDescriptorFactory
             window.showErrorMessage(errorMessage);
             return;
         }
-        return new vscode.DebugAdapterInlineImplementation(new MiDebugAdapter(projectUri));
+        return new vscode.DebugAdapterInlineImplementation(new MiDebugAdapter(projectUri, session));
     }
 }
diff --git a/workspaces/mi/mi-extension/src/debugger/config.ts b/workspaces/mi/mi-extension/src/debugger/config.ts
@@ -19,6 +19,7 @@
 
 import * as vscode from 'vscode';
 import * as path from "path";
+import { LOCALHOST, ADMIN } from './constants';
 
 const toml = require('@iarna/toml');
 const fs = require('fs');
@@ -29,20 +30,22 @@ export class DebuggerConfig {
     private static baseServerPort: number = vscode.workspace.getConfiguration().get<number>('MI.serverPort', 8290);
     private static serverReadinessPort: number = 9201;
     private static managementPort: number = 9164;
-    private static host: string = 'localhost';
+    private static host: string = LOCALHOST;
     private static internalOffset = 10;
     private static envVariables: { [key: string]: string } = {};
     private static vmArgs: string[] = [];
     private static vmArgsPortOffset: number | null = null;
     private static configPortOffset: number | null = null;
+    private static remoteDebuggingEnabled: boolean = false;
+    private static connectionTimeout: number = 10000;
 
     //Capps and Libs copied to the MI server
     private static copiedCappUri: string[] = [];
     private static copiedLibs: string[] = [];
 
     // Management API username and password
-    private static managementUserName: string = "admin";
-    private static managementPassword: string = "admin";
+    private static managementUserName: string = ADMIN;
+    private static managementPassword: string = ADMIN;
 
     private static portOffset: number | undefined;
 
@@ -96,6 +99,10 @@ export class DebuggerConfig {
         this.copiedLibs = [];
     }
 
+    public static setServerPort(port: number): void {
+        this.baseServerPort = port;
+    }
+
     public static getServerPort(): number {
         if (this.vmArgsPortOffset !== null) {
             return this.baseServerPort + this.vmArgsPortOffset - this.internalOffset;
@@ -106,6 +113,10 @@ export class DebuggerConfig {
         return this.baseServerPort;
     }
 
+    public static setServerReadinessPort(port: number): void {
+        this.serverReadinessPort = port;
+    }
+
     public static getServerReadinessPort(): number {
         if (this.vmArgsPortOffset !== null) {
             return this.serverReadinessPort + this.vmArgsPortOffset - this.internalOffset;
@@ -116,6 +127,10 @@ export class DebuggerConfig {
         return this.serverReadinessPort;
     }
 
+    public static setManagementPort(port: number): void {
+        this.managementPort = port;
+    }
+
     public static getManagementPort(): number {
         if (this.vmArgsPortOffset !== null) {
             return this.managementPort + this.vmArgsPortOffset - this.internalOffset;
@@ -130,6 +145,10 @@ export class DebuggerConfig {
         return this.host;
     }
 
+    public static setHost(host: string): void {
+        this.host = host;
+    }
+
     public static getManagementUserName(): string {
         return this.managementUserName;
     }
@@ -164,4 +183,23 @@ export class DebuggerConfig {
         const configs = toml.parse(fs.readFileSync(deploymentConfig, 'utf8'));
         this.configPortOffset = configs.server?.offset ?? null;
     }
+
+    public static setRemoteDebuggingEnabled(enabled: boolean): void {
+        this.remoteDebuggingEnabled = enabled;
+    }
+
+    public static isRemoteDebuggingEnabled(): boolean {
+        return this.remoteDebuggingEnabled;
+    }
+
+    public static getDefaultServerPort(): number {
+        return vscode.workspace.getConfiguration().get<number>('MI.serverPort', 8290);
+    }
+
+    public static getConnectionTimeout(): number {
+        return this.connectionTimeout;
+    }
+    public static setConnectionTimeout(timeout: number): void {
+        this.connectionTimeout = timeout * 1000;
+    }
 }
diff --git a/workspaces/mi/mi-extension/src/debugger/constants.ts b/workspaces/mi/mi-extension/src/debugger/constants.ts
@@ -21,3 +21,6 @@ export const SELECTED_JAVA_HOME = "JAVA_HOME";
 
 export const INCORRECT_SERVER_PATH_MSG = "Unable to locate the MI server at the provided path. Please provide the correct path.";
 
+export const REMOTE = "remote";
+export const LOCALHOST = "localhost";
+export const ADMIN = "admin";
diff --git a/workspaces/mi/mi-extension/src/debugger/debugAdapter.ts b/workspaces/mi/mi-extension/src/debugger/debugAdapter.ts
@@ -26,6 +26,7 @@ import { getStateMachine, openView, refreshUI } from '../stateMachine';
 import { webviews } from '../visualizer/webview';
 import { ViewColumn } from 'vscode';
 import { COMMANDS } from '../constants';
+import { LOCALHOST, ADMIN, REMOTE } from './constants';
 import { INCORRECT_SERVER_PATH_MSG } from './constants';
 import { extension } from '../MIExtensionContext';
 import { EVENT_TYPE, miServerRunStateChanged } from '@wso2/mi-core';
@@ -47,13 +48,39 @@ export class MiDebugAdapter extends LoggingDebugSession {
 
     private variableHandles: Handles<any>;
 
-    public constructor(private projectUri: string) {
+    public constructor(private projectUri: string, session?: vscode.DebugSession) {
         super();
         // debugger uses zero-based lines and columns
         this.setDebuggerLinesStartAt1(false);
         this.setDebuggerColumnsStartAt1(false);
 
-        this.debuggerHandler = new Debugger(DebuggerConfig.getCommandPort(), DebuggerConfig.getEventPort(), DebuggerConfig.getHost(), projectUri);
+        const debuggerProperties = session?.configuration?.properties;
+        if (debuggerProperties) {
+            DebuggerConfig.setRemoteDebuggingEnabled(debuggerProperties.type === REMOTE);
+        } else {
+            DebuggerConfig.setRemoteDebuggingEnabled(false);
+        }
+        if (DebuggerConfig.isRemoteDebuggingEnabled()) {
+            const commandPort = debuggerProperties.commandPort || 9005;
+            const eventPort = debuggerProperties.eventPort || 9006;
+            const serverHost = debuggerProperties.serverHost || LOCALHOST;
+            DebuggerConfig.setHost(serverHost);
+            DebuggerConfig.setServerPort(debuggerProperties.serverPort || 8290);
+            DebuggerConfig.setServerReadinessPort(debuggerProperties.serverReadinessPort || 9201);
+            DebuggerConfig.setManagementPort(debuggerProperties.managementPort || 9164);
+            DebuggerConfig.setManagementUserName(debuggerProperties.managementUsername || ADMIN);
+            DebuggerConfig.setManagementPassword(debuggerProperties.managementPassword || ADMIN);
+            DebuggerConfig.setConnectionTimeout(debuggerProperties.connectionTimeoutInSecs || 10);
+            this.debuggerHandler = new Debugger(commandPort, eventPort, serverHost, projectUri);
+        } else {
+            DebuggerConfig.setHost(LOCALHOST);
+            DebuggerConfig.setServerPort(DebuggerConfig.getDefaultServerPort());
+            DebuggerConfig.setServerReadinessPort(9201);
+            DebuggerConfig.setManagementPort(9164);
+            DebuggerConfig.setManagementUserName(ADMIN);
+            DebuggerConfig.setManagementPassword(ADMIN);
+            this.debuggerHandler = new Debugger(DebuggerConfig.getCommandPort(), DebuggerConfig.getEventPort(), DebuggerConfig.getHost(), projectUri);
+        }
         // setup event handlers
         this.debuggerHandler.on('stopOnEntry', () => {
             this.sendEvent(new StoppedEvent('entry', MiDebugAdapter.threadID));
@@ -284,10 +311,23 @@ export class MiDebugAdapter extends LoggingDebugSession {
 
                         DebuggerConfig.setVmArgs(args?.vmArgs ? args?.vmArgs : []);
 
-                        await setManagementCredentials(serverPath);
-
                         vscode.commands.executeCommand('setContext', 'MI.isRunning', 'true');
-                        executeTasks(this.projectUri, serverPath, isDebugAllowed)
+                        if (DebuggerConfig.isRemoteDebuggingEnabled()) {
+                            this.debuggerHandler?.initializeDebugger().then(() => {
+                                openRuntimeServicesWebview(this.projectUri);
+                                extension.isServerStarted = true;
+                                RPCLayer._messengers.get(this.projectUri)?.sendNotification(miServerRunStateChanged, { type: 'webview', webviewType: 'micro-integrator.runtime-services-panel' }, 'Running');
+                                response.success = true;
+                                this.sendResponse(response);
+                            }).catch(error => {
+                                const completeError = `Error while initializing the Debugger: ${error}`;
+                                vscode.window.showErrorMessage(completeError);
+                                this.sendError(response, 1, completeError);
+                                vscode.commands.executeCommand('setContext', 'MI.isRunning', 'false');
+                            });
+                        } else {
+                            await setManagementCredentials(serverPath);
+                            executeTasks(this.projectUri, serverPath, isDebugAllowed)
                             .then(async () => {
                                 if (args?.noDebug) {
                                     checkServerReadiness(this.projectUri).then(() => {
@@ -328,6 +368,7 @@ export class MiDebugAdapter extends LoggingDebugSession {
                                 }
                                 this.sendError(response, 1, completeError);
                             });
+                        }
                     });
                 }
             });
diff --git a/workspaces/mi/mi-extension/src/debugger/debugger.ts b/workspaces/mi/mi-extension/src/debugger/debugger.ts
@@ -28,6 +28,7 @@ import { extension } from '../MIExtensionContext';
 import { reject } from 'lodash';
 import { LogLevel, logDebug } from '../util/logger';
 import { MILanguageClient } from '../lang-client/activator';
+import { DebuggerConfig } from './config';
 
 export interface RuntimeBreakpoint {
     id: number;
@@ -393,7 +394,7 @@ export class Debugger extends EventEmitter {
                         resolve();
                     }).catch((error) => {
                         logDebug(`Error while sending the resume command: ${error}`, LogLevel.ERROR);
-                        reject(`Error while resuming the debugger server: ${error}`);
+                        reject(`Error while resuming the debugger server. ${error}`);
                     });
 
                 }).catch((error) => {
@@ -595,8 +596,13 @@ export class Debugger extends EventEmitter {
             logDebug(`Command: ${request}`, LogLevel.INFO);
             this.commandClient?.write(request);
 
+            const timeout = setTimeout(() => {
+                reject("Server did not respond within the timeout period. Please restart the server in debug mode and try again.");
+            }, DebuggerConfig.getConnectionTimeout());
+
             // Listen for response from the command port
             this.commandClient?.once('data', (data) => {
+                clearTimeout(timeout);
                 // Convert buffer to string
                 const receivedData = data.toString();
 
@@ -617,6 +623,11 @@ export class Debugger extends EventEmitter {
                     incompleteMessage = incompleteMessage.slice(newlineIndex + 1);
                 }
             });
+
+            this.commandClient?.once('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
         });
     }
 
diff --git a/workspaces/mi/mi-extension/src/rpc-managers/mi-diagram/rpc-manager.ts b/workspaces/mi/mi-extension/src/rpc-managers/mi-diagram/rpc-manager.ts
@@ -5439,7 +5439,7 @@ ${keyValuesXML}`;
         let response;
         if (params.isRuntimeService) {
             const versionedUrl = await exposeVersionedServices(this.projectUri);
-            response = await langClient.swaggerFromAPI({ apiPath: params.apiPath, port: DebuggerConfig.getServerPort(), projectPath: versionedUrl ? this.projectUri : "", ...(fs.existsSync(swaggerPath) && { swaggerPath: swaggerPath }) });
+            response = await langClient.swaggerFromAPI({ apiPath: params.apiPath, host: DebuggerConfig.getHost(), port: DebuggerConfig.getServerPort(), projectPath: versionedUrl ? this.projectUri : "", ...(fs.existsSync(swaggerPath) && { swaggerPath: swaggerPath }) });
         } else {
             response = await langClient.swaggerFromAPI({ apiPath: params.apiPath, ...(fs.existsSync(swaggerPath) && { swaggerPath: swaggerPath }) });
         }
diff --git a/workspaces/mi/mi-extension/src/rpc-managers/mi-visualizer/rpc-manager.ts b/workspaces/mi/mi-extension/src/rpc-managers/mi-visualizer/rpc-manager.ts

Original file line number	Diff line number	Diff line change
`@@ -1779,6 +1779,7 @@ export interface SwaggerFromAPIRequest {`
`1779`	`1779`	`swaggerPath?: string;`
`1780`	`1780`	`isJsonIn?: boolean;`
`1781`	`1781`	`isJsonOut?: boolean;`
	`1782`	`+ host?: string;`
`1782`	`1783`	`port?: number;`
`1783`	`1784`	`projectPath?: string;`
`1784`	`1785`	`}`
Original file line number	Diff line number	Diff line change
`@@ -368,6 +368,6 @@ class InlineDebugAdapterFactory implements vscode.DebugAdapterDescriptorFactory`
`368`	`368`	`window.showErrorMessage(errorMessage);`
`369`	`369`	`return;`
`370`	`370`	`}`
`371`		`- return new vscode.DebugAdapterInlineImplementation(new MiDebugAdapter(projectUri));`
	`371`	`+ return new vscode.DebugAdapterInlineImplementation(new MiDebugAdapter(projectUri, session));`
`372`	`372`	`}`
`373`	`373`	`}`
Original file line number	Diff line number	Diff line change
@@ -5439,7 +5439,7 @@ ${keyValuesXML}`;
`5439`	`5439`	`let response;`
`5440`	`5440`	`if (params.isRuntimeService) {`
`5441`	`5441`	`const versionedUrl = await exposeVersionedServices(this.projectUri);`
`5442`		`- response = await langClient.swaggerFromAPI({ apiPath: params.apiPath, port: DebuggerConfig.getServerPort(), projectPath: versionedUrl ? this.projectUri : "", ...(fs.existsSync(swaggerPath) && { swaggerPath: swaggerPath }) });`
	`5442`	`+ response = await langClient.swaggerFromAPI({ apiPath: params.apiPath, host: DebuggerConfig.getHost(), port: DebuggerConfig.getServerPort(), projectPath: versionedUrl ? this.projectUri : "", ...(fs.existsSync(swaggerPath) && { swaggerPath: swaggerPath }) });`
`5443`	`5443`	`} else {`
`5444`	`5444`	`response = await langClient.swaggerFromAPI({ apiPath: params.apiPath, ...(fs.existsSync(swaggerPath) && { swaggerPath: swaggerPath }) });`
`5445`	`5445`	`}`