reconnect correctly to debugger after disconnect

Author: d-biehl

robotcode/debugger/__main__.py

@@ -1,13 +1,14 @@
 import argparse
 import asyncio
+import functools
 import logging
 import logging.config
 import os
 import sys
 import threading
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Sequence, Union, cast
 
 __file__ = os.path.abspath(__file__)
 if __file__.endswith((".pyc", ".pyo")):
@@ -65,27 +66,33 @@ async def wait() -> None:
 
 
 @_logger.call
-async def _debug_adapter_server_(host: str, port: int) -> None:
+async def _debug_adapter_server_(
+    host: str, port: int, on_config_done_callback: Optional[Callable[["DebugAdapterServer"], None]]
+) -> None:
     from ..jsonrpc2.server import TcpParams
     from .server import DebugAdapterServer
 
-    async with DebugAdapterServer(tcp_params=TcpParams(host, port)) as server:
-        set_server(cast(DebugAdapterServer, server))
+    async with DebugAdapterServer(tcp_params=TcpParams(host, port)) as s:
+        server = cast(DebugAdapterServer, s)
+        if on_config_done_callback is not None:
+            server.protocol.received_configuration_done_callback = functools.partial(on_config_done_callback, server)
+        set_server(server)
         await server.serve()
 
 
 DEFAULT_TIMEOUT = 10.0
 
 
+config_done_callback: Optional[Callable[["DebugAdapterServer"], None]] = None
+
+
 @_logger.call
 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:
-    from ..utils.async_tools import run_coroutine_from_thread_async
     from ..utils.debugpy import enable_debugpy, wait_for_debugpy_connected
     from ..utils.net import find_free_port
     from .dap_types import Event
@@ -94,19 +101,17 @@ async def start_debugpy_async(
     if port != debugpy_port:
         _logger.warning(f"start debugpy session on port {port}")
 
-    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, "addresses": addresses})
-                ),
-                loop=server.loop,
-            )
-        )
-        if wait_for_debugpy_client:
-            wait_for_debugpy_connected()
+    if enable_debugpy(port, addresses):
+        global config_done_callback
+
+        def connect_debugpy(server: "DebugAdapterServer") -> None:
+
+            server.protocol.send_event(Event(event="debugpyStarted", body={"port": port, "addresses": addresses}))
+
+            if wait_for_debugpy_client:
+                wait_for_debugpy_connected()
+
+        config_done_callback = connect_debugpy
 
 
 @_logger.call
@@ -132,14 +137,17 @@ async def run_robot(
         run_coroutine_from_thread_async,
         run_coroutine_in_thread,
     )
-    from ..utils.debugpy import is_debugpy_installed
+    from ..utils.debugpy import is_debugpy_installed, wait_for_debugpy_connected
     from .dap_types import Event
     from .debugger import Debugger
 
     if debugpy and not is_debugpy_installed():
         print("debugpy not installed.")
 
-    server_future = run_coroutine_in_thread(_debug_adapter_server_, addresses, port)
+    if debugpy:
+        await start_debugpy_async(debugpy_port, addresses, wait_for_debugpy_client, wait_for_client_timeout)
+
+    server_future = run_coroutine_in_thread(_debug_adapter_server_, addresses, port, config_done_callback)
 
     server = await wait_for_server()
 
@@ -166,8 +174,8 @@ async def run_robot(
             except asyncio.TimeoutError as e:
                 raise ConnectionError("Timeout to get configuration from client.") from e
 
-        if debugpy:
-            await start_debugpy_async(server, debugpy_port, addresses, wait_for_debugpy_client, wait_for_client_timeout)
+        if debugpy and wait_for_debugpy_client:
+            wait_for_debugpy_connected()
 
         args = [
             "--listener",
@@ -210,6 +218,8 @@ async def run_robot(
         return exit_code
     except asyncio.CancelledError:
         pass
+    except ConnectionError as e:
+        print(e, file=sys.stderr)
     finally:
         if server.protocol.connected:
             await run_coroutine_from_thread_async(server.protocol.terminate, loop=server.loop)

robotcode/debugger/debugger.py

@@ -86,6 +86,7 @@ class State(Enum):
     Stopped = 0
     Running = 1
     Paused = 2
+    CallKeyword = 3
 
 
 class RequestedState(Enum):
@@ -222,6 +223,8 @@ def __new__(cls, *args: Any, **kwargs: Any) -> Any:
         raise RuntimeError(f"Attempt to create a '{cls.__qualname__}' instance outside of instance()")
 
     def __init__(self) -> None:
+        from robot.running.model import Keyword
+
         self.breakpoints: Dict[pathlib.PurePath, BreakpointsEntry] = {}
 
         self.exception_breakpoints: Set[ExceptionBreakpointsEntry] = set()
@@ -247,9 +250,15 @@ def __init__(self) -> None:
         self.stop_on_entry = False
         self.no_debug = False
         self.terminated = False
+        self.terminated_requested = False
         self.attached = False
         self.path_mappings: List[PathMapping] = []
 
+        self.run_keyword: Optional[Keyword] = None
+        self.run_keyword_event = threading.Event()
+        self.run_keyword_event.set()
+        self.after_run_keyword_event_state: Optional[State] = None
+
     @property
     def debug(self) -> bool:
         return not self.no_debug
@@ -278,6 +287,10 @@ def robot_output_file(self) -> Optional[str]:
     def robot_output_file(self, value: Optional[str]) -> None:
         self._robot_output_file = value
 
+    @_logger.call
+    def terminate_requested(self) -> None:
+        self.terminated_requested = True
+
     @_logger.call
     def terminate(self) -> None:
         self.terminated = True
@@ -304,16 +317,23 @@ def stop(self) -> None:
             self.condition.notify_all()
 
     @_logger.call
-    def continue_all(self) -> None:
+    def continue_all(self, send_event: bool = True) -> None:
         if self.main_thread is not None and self.main_thread.ident is not None:
-            self.continue_thread(self.main_thread.ident)
+            self.continue_thread(self.main_thread.ident, send_event)
 
     @_logger.call
-    def continue_thread(self, thread_id: int) -> None:
+    def continue_thread(self, thread_id: int, send_event: bool = False) -> None:
         if self.main_thread is None or thread_id != self.main_thread.ident:
             raise InvalidThreadId(thread_id)
 
         with self.condition:
+            if send_event:
+                self.send_event(
+                    self,
+                    ContinuedEvent(
+                        body=ContinuedEventBody(thread_id=self.main_thread.ident, all_threads_continued=True)
+                    ),
+                )
             self.state = State.Running
             self.condition.notify_all()
 
@@ -585,7 +605,12 @@ def process_end_state(self, status: str, filter_id: Set[str], description: str,
     def wait_for_running(self) -> None:
         if self.attached:
             with self.condition:
-                self.condition.wait_for(lambda: self.state in [State.Running, State.Stopped])
+                while True:
+                    self.condition.wait_for(lambda: self.state in [State.Running, State.Stopped, State.CallKeyword])
+
+                    if self.state == State.CallKeyword:
+                        continue
+                    break
 
     def start_output_group(self, name: str, attributes: Dict[str, Any], type: Optional[str] = None) -> None:
         if self.group_output:
@@ -1201,8 +1226,13 @@ def evaluate(
 
                     if splitted:
                         kw = Keyword(name=splitted[0], args=tuple(splitted[1:]), assign=tuple(variables))
+                        old_state = self.state
+                        self.state = State.CallKeyword
+
                         result = kw.run(evaluate_context)
 
+                        self.state = old_state
+
             elif self.IS_VARIABLE_RE.match(expression.strip()):
                 try:
                     result = VariableFinder(vars.store).find(expression)

robotcode/debugger/launcher/server.py

@@ -262,7 +262,7 @@ async def _launch(
             )
 
         else:
-            raise Exception(f'Unknown console type "{console}".')
+            raise ValueError(f'Unknown console type "{console}".')
 
         self.client = DAPClient(self, TcpParams(None, port))
         try:

robotcode/debugger/server.py

@@ -1,6 +1,6 @@
 import asyncio
 import os
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
 from ..jsonrpc2.protocol import rpc_method
 from ..jsonrpc2.server import JsonRPCServer, JsonRpcServerMode, TcpParams
@@ -72,6 +72,7 @@ def __init__(self) -> None:
 
         self._received_configuration_done_event = async_tools.Event()
         self._received_configuration_done = False
+        self.received_configuration_done_callback: Optional[Callable[[], None]] = None
 
         Debugger.instance().send_event.add(self.on_debugger_send_event)
 
@@ -218,14 +219,15 @@ async def terminate(self) -> None:
     async def _terminate(self, arguments: Optional[TerminateArguments] = None, *args: Any, **kwargs: Any) -> None:
         import signal
 
-        Debugger.instance().terminate()
-
         if not self._sigint_signaled:
             self._logger.info("Send SIGINT to process")
             signal.raise_signal(signal.SIGINT)
             self._sigint_signaled = True
+            # Debugger.instance().continue_all()
         else:
-            self.send_event(Event("terminateRequested"))
+            await self.send_event_async(Event("terminateRequested"))
+
+            Debugger.instance().terminate()
 
             self._logger.info("Send SIGTERM to process")
             signal.raise_signal(signal.SIGTERM)
@@ -241,9 +243,8 @@ async def _disconnect(self, arguments: Optional[DisconnectArguments] = None, *ar
             os._exit(-1)
         else:
             await self.send_event_async(Event("disconnectRequested"))
-            await asyncio.sleep(3)
             Debugger.instance().attached = False
-            Debugger.instance().continue_all()
+            Debugger.instance().continue_all(False)
 
     @rpc_method(name="setBreakpoints", param_type=SetBreakpointsArguments)
     async def _set_breakpoints(
@@ -263,6 +264,10 @@ async def _configuration_done(
         self._received_configuration_done = True
         self._received_configuration_done_event.set()
 
+        if self.received_configuration_done_callback is not None:
+
+            self.received_configuration_done_callback()
+
     @_logger.call
     async def wait_for_configuration_done(self, timeout: float = 5) -> bool:
         await asyncio.wait_for(self._received_configuration_done_event.wait(), timeout)