optimize disconnect from python/robotcode debugger

Author: d-biehl

CHANGELOG.md

@@ -902,7 +902,8 @@
             "presentation": {
               "hidden": true
             },
-            "pythonConfiguration": "RobotCode: Debug"
+            "attachPython": false,
+            "pythonConfiguration": "RobotCode: Python"
           },
           {
             "name": "RobotCode: Python",

package.json

@@ -81,6 +81,7 @@ async def _debug_adapter_server_(host: str, port: int) -> None:
 async def start_debugpy_async(
     server: "DebugAdapterServer",
     debugpy_port: int = 5678,
+    addresses: Union[Sequence[str], str, None] = None,
     wait_for_debugpy_client: bool = False,
     wait_for_client_timeout: float = DEFAULT_TIMEOUT,
 ) -> None:
@@ -93,12 +94,14 @@ async def start_debugpy_async(
     if port != debugpy_port:
         _logger.warning(f"start debugpy session on port {port}")
 
-    if enable_debugpy(port) and await run_coroutine_from_thread_async(
+    if enable_debugpy(port, addresses) and await run_coroutine_from_thread_async(
         server.protocol.wait_for_client, wait_for_client_timeout, loop=server.loop
     ):
         await asyncio.wrap_future(
             asyncio.run_coroutine_threadsafe(
-                server.protocol.send_event_async(Event(event="debugpyStarted", body={"port": port})),
+                server.protocol.send_event_async(
+                    Event(event="debugpyStarted", body={"port": port, "addresses": addresses})
+                ),
                 loop=server.loop,
             )
         )
@@ -110,7 +113,7 @@ async def start_debugpy_async(
 async def run_robot(
     port: int,
     args: List[str],
-    bind: Union[Sequence[str], str, None] = None,
+    addresses: Union[Sequence[str], str, None] = None,
     no_debug: bool = False,
     wait_for_client: bool = False,
     wait_for_client_timeout: float = DEFAULT_TIMEOUT,
@@ -129,10 +132,14 @@ async def run_robot(
         run_coroutine_from_thread_async,
         run_coroutine_in_thread,
     )
+    from ..utils.debugpy import is_debugpy_installed
     from .dap_types import Event
     from .debugger import Debugger
 
-    server_future = run_coroutine_in_thread(_debug_adapter_server_, bind, port)
+    if debugpy and not is_debugpy_installed():
+        print("debugpy not installed.")
+
+    server_future = run_coroutine_in_thread(_debug_adapter_server_, addresses, port)
 
     server = await wait_for_server()
 
@@ -147,7 +154,7 @@ async def run_robot(
             except asyncio.TimeoutError as e:
                 raise ConnectionError("No incomming connection from a debugger client.") from e
 
-        await run_coroutine_from_thread_async(server.protocol.initialized, loop=server.loop)
+            await run_coroutine_from_thread_async(server.protocol.wait_for_initialized, loop=server.loop)
 
         if wait_for_client:
             try:
@@ -160,7 +167,7 @@ async def run_robot(
                 raise ConnectionError("Timeout to get configuration from client.") from e
 
         if debugpy:
-            await start_debugpy_async(server, debugpy_port, wait_for_debugpy_client, wait_for_client_timeout)
+            await start_debugpy_async(server, debugpy_port, addresses, wait_for_debugpy_client, wait_for_client_timeout)
 
         args = [
             "--listener",

robotcode/debugger/__main__.py

@@ -303,6 +303,11 @@ def stop(self) -> None:
 
             self.condition.notify_all()
 
+    @_logger.call
+    def continue_all(self) -> None:
+        if self.main_thread is not None and self.main_thread.ident is not None:
+            self.continue_thread(self.main_thread.ident)
+
     @_logger.call
     def continue_thread(self, thread_id: int) -> None:
         if self.main_thread is None or thread_id != self.main_thread.ident:

robotcode/debugger/debugger.py

@@ -19,6 +19,7 @@
     DisconnectRequest,
     Event,
     ExceptionBreakpointsFilter,
+    InitializeRequest,
     InitializeRequestArguments,
     LaunchRequestArguments,
     OutputCategory,
@@ -59,6 +60,7 @@ def __init__(self) -> None:
         super().__init__()
         self._client: Optional[DAPClient] = None
         self._process: Optional[asyncio.subprocess.Process] = None
+        self._initialize_arguments: Optional[InitializeRequestArguments] = None
 
     @property
     def client(self) -> DAPClient:
@@ -77,6 +79,8 @@ def connected(self) -> bool:
 
     @rpc_method(name="initialize", param_type=InitializeRequestArguments)
     async def _initialize(self, arguments: InitializeRequestArguments, *args: Any, **kwargs: Any) -> Capabilities:
+        self._initialize_arguments = arguments
+
         self._initialized = True
 
         return Capabilities(
@@ -264,7 +268,10 @@ async def _launch(
         try:
             await self.client.connect(connect_timeout)
         except asyncio.TimeoutError:
-            raise asyncio.TimeoutError("Can't connect to debug launcher.")
+            raise asyncio.TimeoutError("Can't connect to debug child.")
+
+        if self._initialize_arguments is not None:
+            await self.client.protocol.send_request_async(InitializeRequest(arguments=self._initialize_arguments))
 
     @rpc_method(name="configurationDone", param_type=ConfigurationDoneArguments)
     async def _configuration_done(
@@ -279,16 +286,16 @@ async def _disconnect(self, arguments: Optional[DisconnectArguments] = None, *ar
             if not self.client.protocol.terminated:
                 await self.client.protocol.send_request_async(DisconnectRequest(arguments=arguments))
         else:
+            self.send_event(Event("disconnectRequested"))
             await self.send_event_async(TerminatedEvent())
 
     @_logger.call
     @rpc_method(name="terminate", param_type=TerminateArguments)
     async def _terminate(self, arguments: Optional[TerminateArguments] = None, *args: Any, **kwargs: Any) -> None:
         if self.client.connected:
-            self.send_event(Event("terminateRequested"))
-
             return await self.client.protocol.send_request_async(TerminateRequest(arguments=arguments))
         else:
+            self.send_event(Event("terminateRequested"))
             await self.send_event_async(TerminatedEvent())
 
     async def handle_unknown_command(self, message: Request) -> Any:

robotcode/debugger/launcher/server.py

@@ -56,12 +56,14 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
     def __init__(self) -> None:
         super().__init__()
 
-        self._initialized = False
         self._connected_event = async_tools.Event()
         self._disconnected_event = async_tools.Event()
         self._connected = False
         self._sigint_signaled = False
 
+        self._initialized = False
+        self._initialized_event = async_tools.Event()
+
         self._exited_lock = async_tools.Lock()
         self._exited = False
 
@@ -115,6 +117,12 @@ async def wait_for_client(self, timeout: float = 5) -> bool:
 
         return self._connected
 
+    @_logger.call
+    async def wait_for_initialized(self, timeout: float = 60) -> bool:
+        await asyncio.wait_for(self._initialized_event.wait(), timeout)
+
+        return self._initialized
+
     @_logger.call
     async def wait_for_disconnected(self, timeout: float = 60) -> bool:
         await asyncio.wait_for(self._disconnected_event.wait(), timeout)
@@ -125,6 +133,9 @@ async def wait_for_disconnected(self, timeout: float = 60) -> bool:
     async def _initialize(self, arguments: InitializeRequestArguments, *args: Any, **kwargs: Any) -> Capabilities:
         self._initialized = True
 
+        if self.loop is not None:
+            self.loop.call_soon(self.initialized)
+
         return Capabilities(
             supports_configuration_done_request=True,
             supports_conditional_breakpoints=True,
@@ -187,8 +198,9 @@ async def _attach(
         Debugger.instance().attached = True
 
     @_logger.call
-    async def initialized(self) -> None:
-        await self.send_event_async(InitializedEvent())
+    def initialized(self) -> None:
+        self.send_event(InitializedEvent())
+        self._initialized_event.set()
 
     @_logger.call
     async def exit(self, exit_code: int) -> None:
@@ -213,17 +225,25 @@ async def _terminate(self, arguments: Optional[TerminateArguments] = None, *args
             signal.raise_signal(signal.SIGINT)
             self._sigint_signaled = True
         else:
+            self.send_event(Event("terminateRequested"))
+
             self._logger.info("Send SIGTERM to process")
             signal.raise_signal(signal.SIGTERM)
 
     @rpc_method(name="disconnect", param_type=DisconnectArguments)
     async def _disconnect(self, arguments: Optional[DisconnectArguments] = None, *args: Any, **kwargs: Any) -> None:
+
         if (
-            not (await self.exited)
-            or not (await self.terminated)
-            and (arguments is None or arguments.terminate_debuggee is None or arguments.terminate_debuggee)
+            (not (await self.exited) or not (await self.terminated))
+            and arguments is not None
+            and arguments.terminate_debuggee
         ):
             os._exit(-1)
+        else:
+            await self.send_event_async(Event("disconnectRequested"))
+            await asyncio.sleep(3)
+            Debugger.instance().attached = False
+            Debugger.instance().continue_all()
 
     @rpc_method(name="setBreakpoints", param_type=SetBreakpointsArguments)
     async def _set_breakpoints(

robotcode/debugger/server.py

@@ -1,3 +1,5 @@
+from typing import Sequence, Tuple, Union
+
 from .logging import LoggingDescriptor
 from .net import find_free_port
 
@@ -24,24 +26,34 @@ def wait_for_debugpy_connected() -> bool:
     return False
 
 
-def enable_debugpy(port: int) -> bool:
+def enable_debugpy(port: int, addresses: Union[Sequence[str], str, None] = None) -> bool:
     if is_debugpy_installed():
         import debugpy
 
-        debugpy.listen(port)
+        if addresses is None:
+            addresses = ["127.0.0.1"]
+
+        if not isinstance(addresses, Sequence):
+            addresses = [addresses]
+
+        for address in addresses:
+            debugpy.listen((address, port))
 
         return True
     return False
 
 
-def start_debugpy(port: int, wait_for_client: bool) -> bool:
+def start_debugpy(end_point: Union[Tuple[str, int], int], wait_for_client: bool) -> bool:
     if is_debugpy_installed():
         import debugpy
 
-        real_port = find_free_port(port)
-        if real_port != port:
+        if isinstance(end_point, int):
+            end_point = ("127.0.0.1", end_point)
+
+        real_port = find_free_port(end_point[1])
+        if real_port != end_point[1]:
             _logger.warning(f"start debugpy session on port {real_port}")
-        debugpy.listen(real_port)
+        debugpy.listen((end_point[0], real_port))
 
         if wait_for_client:
             _logger.info("wait for debugpy client")

robotcode/utils/debugpy.py

@@ -264,6 +264,7 @@ export class DebugManager {
               await DebugManager.OnDebugpyStarted(event.session, event.event, event.body);
               break;
             }
+            case "disconnectRequested":
             case "terminateRequested": {
               for (const s of this._attachedSessions) {
                 if (s.parentSession == event.session) {
@@ -286,9 +287,19 @@ export class DebugManager {
         }
       }),
 
-      vscode.debug.onDidTerminateDebugSession((session) => {
+      vscode.debug.onDidTerminateDebugSession(async (session) => {
         if (this._attachedSessions.has(session)) {
           this._attachedSessions.delete(session);
+          if (session.parentSession?.type === "robotcode") {
+            await vscode.debug.stopDebugging(session.parentSession);
+          }
+        }
+        if (session.configuration.type === "robotcode") {
+          for (const s of this._attachedSessions) {
+            if (s.parentSession == session) {
+              await vscode.debug.stopDebugging(s);
+            }
+          }
         }
       }),
 
@@ -389,7 +400,7 @@ export class DebugManager {
   static async OnDebugpyStarted(
     session: vscode.DebugSession,
     _event: string,
-    options?: { port: number }
+    options?: { port: number; addresses: undefined | string[] | null }
   ): Promise<void> {
     if (
       session.type === "robotcode" &&
@@ -416,10 +427,15 @@ export class DebugManager {
           request: "attach",
           connect: {
             port: options.port,
+            host: options.addresses ? options.addresses[0] : undefined,
           },
         },
       };
 
+      if (session.configuration?.request === "attach" && !debugConfiguration.pathMappings) {
+        debugConfiguration.pathMappings = session.configuration.pathMappings;
+      }
+
       await vscode.debug.startDebugging(session.workspaceFolder, debugConfiguration, {
         parentSession: session,
         compact: true,