enhance debugging for new RF5 TRY/EXCEPT/WHILE statements, some refactoring

d-biehl · d-biehl · commit 693a8765cec7 · 2022-02-02T15:22:47.000+01:00
diff --git a/robotcode/debugger/__main__.py b/robotcode/debugger/__main__.py
@@ -34,25 +34,25 @@
 _logger = LoggingDescriptor(name=__package__)
 
 if TYPE_CHECKING:
-    from .server import LaucherServer
+    from .server import DebugAdapterServer
 
 server_lock = threading.RLock()
-_server: Optional["LaucherServer"] = None
+_server: Optional["DebugAdapterServer"] = None
 
 
-def get_server() -> Optional["LaucherServer"]:
+def get_server() -> Optional["DebugAdapterServer"]:
     with server_lock:
         return _server
 
 
-def set_server(value: "LaucherServer") -> None:
+def set_server(value: "DebugAdapterServer") -> None:
     with server_lock:
         global _server
         _server = value
 
 
 @_logger.call
-async def wait_for_server(timeout: float = 5) -> "LaucherServer":
+async def wait_for_server(timeout: float = 5) -> "DebugAdapterServer":
     async def wait() -> None:
         while get_server() is None:
             await asyncio.sleep(0.05)
@@ -67,12 +67,12 @@ async def wait() -> None:
 @_logger.call
 def run_server(port: int, loop: asyncio.AbstractEventLoop) -> None:
     from ..jsonrpc2.server import TcpParams
-    from .server import LaucherServer
+    from .server import DebugAdapterServer
 
     asyncio.set_event_loop(loop)
 
-    with LaucherServer(tcp_params=TcpParams("127.0.0.1", port)) as server:
-        set_server(cast(LaucherServer, server))
+    with DebugAdapterServer(tcp_params=TcpParams("127.0.0.1", port)) as server:
+        set_server(cast(DebugAdapterServer, server))
         try:
             server.run()
         except asyncio.CancelledError:
@@ -144,7 +144,9 @@ async def start_debugpy_async() -> None:
                         server.protocol.wait_for_client(wait_for_client_timeout), loop=loop
                     )
                 )
-            except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
+            except SystemExit:
+                raise
+            except (asyncio.CancelledError, KeyboardInterrupt):
                 pass
             except asyncio.TimeoutError:
                 raise ConnectionError("No incomming connection from a debugger client.")
@@ -158,7 +160,9 @@ async def start_debugpy_async() -> None:
                         server.protocol.wait_for_configuration_done(configuration_done_timeout), loop=loop
                     )
                 )
-            except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
+            except SystemExit:
+                raise
+            except (asyncio.CancelledError, KeyboardInterrupt):
                 pass
             except asyncio.TimeoutError:
                 raise ConnectionError("Timeout to get configuration from client.")
@@ -362,11 +366,13 @@ def main() -> None:
             _logger.logger.addHandler(get_log_handler(args.log_file))
 
         if not args.log_asyncio:
-            logging.getLogger("asyncio").level = logging.CRITICAL
+            logging.getLogger("asyncio").setLevel(logging.CRITICAL)
 
         if not args.log_debugger:
-            logging.getLogger("robotcode.debugger").level = logging.CRITICAL
-            logging.getLogger("robotcode.debugger").level = logging.CRITICAL
+            logging.getLogger("robotcode.debugger").propagate = True
+            logging.getLogger("robotcode.debugger").setLevel(logging.CRITICAL)
+            logging.getLogger("robotcode.jsonrpc2").propagate = True
+            logging.getLogger("robotcode.jsonrpc2").setLevel(logging.CRITICAL)
 
     _logger.info(f"starting {__package__} version={__version__}")
     _logger.debug(f"args={args}")
diff --git a/robotcode/debugger/debugger.py b/robotcode/debugger/debugger.py
@@ -269,7 +269,17 @@ def next(self, thread_id: int, granularity: Optional[SteppingGranularity] = None
                 self.requested_state = RequestedState.Next
 
                 self.stop_stack_len = len(self.stack_frames)
-                if self.stack_frames and self.stack_frames[0].type in ["FOR", "FOR ITERATION", "IF", "ELSE", "ELSE IF"]:
+                if self.stack_frames and self.stack_frames[0].type in [
+                    "FOR",
+                    "FOR ITERATION",
+                    "ITERATION",
+                    "IF",
+                    "ELSE",
+                    "ELSE IF",
+                    "TRY",
+                    "EXCEPT",
+                    "WHILE",
+                ]:
                     self.stop_stack_len += 1
 
             self.condition.notify_all()
@@ -302,9 +312,13 @@ def step_out(self, thread_id: int, granularity: Optional[SteppingGranularity] =
             while i < len(self.stack_frames) and self.stack_frames[i].type in [
                 "FOR",
                 "FOR ITERATION",
+                "ITERATION",
                 "IF",
                 "ELSE",
                 "ELSE IF",
+                "TRY",
+                "EXCEPT",
+                "WHILE",
             ]:
                 self.stop_stack_len -= 1
                 i += 1
@@ -599,11 +613,10 @@ def start_test(self, name: str, attributes: Dict[str, Any]) -> None:
 
         entry = self.add_stackframe_entry(longname, type, source, line_no)
 
-        if self.debug:
-            if entry.source:
-                self.process_start_state(entry.source, entry.line, entry.type, status)
+        if self.debug and entry.source:
+            self.process_start_state(entry.source, entry.line, entry.type, status)
 
-                self.wait_for_running()
+            self.wait_for_running()
 
     def end_test(self, name: str, attributes: Dict[str, Any]) -> None:
         if self.debug:
@@ -638,10 +651,11 @@ def start_keyword(self, name: str, attributes: Dict[str, Any]) -> None:
             self.wait_for_running()
 
     def end_keyword(self, name: str, attributes: Dict[str, Any]) -> None:
+        type = attributes.get("type", None)
         if self.debug:
             status = attributes.get("status", "")
 
-            if status != "NOT RUN":
+            if status != "NOT RUN" and type in ["KEYWORD", "SETUP", "TEARDOWN"]:
                 self.process_end_state(
                     status,
                     "failed_keyword",
diff --git a/robotcode/debugger/launcher/__main__.py b/robotcode/debugger/launcher/__main__.py
@@ -51,9 +51,9 @@ def get_log_handler(logfile: str) -> logging.FileHandler:
 
 def run_server(mode: str, port: int) -> None:
     from ...jsonrpc2.server import JsonRpcServerMode, TcpParams
-    from .server import DebugAdapterServer
+    from .server import LauncherServer
 
-    with DebugAdapterServer(JsonRpcServerMode(mode), tcp_params=TcpParams("127.0.0.1", port)) as server:
+    with LauncherServer(JsonRpcServerMode(mode), tcp_params=TcpParams("127.0.0.1", port)) as server:
         try:
             server.run()
         except (SystemExit, KeyboardInterrupt):
@@ -140,10 +140,11 @@ def main() -> None:
             _logger.logger.addHandler(get_log_handler(args.log_file))
 
         if not args.log_asyncio:
-            logging.getLogger("asyncio").level = logging.CRITICAL
+            logging.getLogger("asyncio").setLevel(logging.CRITICAL)
 
         if not args.log_debugger_launcher:
-            logging.getLogger("robotcode.debugger.launcher").level = logging.CRITICAL
+            logging.getLogger("robotcode.debugger.launcher").setLevel(logging.CRITICAL)
+            logging.getLogger("robotcode.jsonrpc2").setLevel(logging.CRITICAL)
 
     _logger.info(f"starting debugger launcher server version={__version__}")
     _logger.debug(f"args={args}")
diff --git a/robotcode/debugger/launcher/server.py b/robotcode/debugger/launcher/server.py
@@ -34,7 +34,7 @@
 
 
 class OutputProtocol(asyncio.SubprocessProtocol):
-    def __init__(self, parent: DAPServerProtocol) -> None:
+    def __init__(self, parent: LauncherDebugAdapterProtocol) -> None:
         super().__init__()
         self.parent = parent
 
@@ -49,7 +49,7 @@ def pipe_data_received(self, fd: Any, data: bytes) -> None:
         self.parent.send_event(OutputEvent(body=OutputEventBody(output=data.decode(), category=category)))
 
 
-class DAPServerProtocol(DebugAdapterProtocol):
+class LauncherDebugAdapterProtocol(DebugAdapterProtocol):
     _logger = LoggingDescriptor()
 
     def __init__(self) -> None:
@@ -268,7 +268,7 @@ async def handle_unknown_command(self, message: Request) -> Any:
 TCP_DEFAULT_PORT = 6611
 
 
-class DebugAdapterServer(JsonRPCServer[DAPServerProtocol]):
+class LauncherServer(JsonRPCServer[LauncherDebugAdapterProtocol]):
     def __init__(
         self,
         mode: JsonRpcServerMode = JsonRpcServerMode.STDIO,
@@ -279,5 +279,5 @@ def __init__(
             tcp_params=tcp_params,
         )
 
-    def create_protocol(self) -> DAPServerProtocol:
-        return DAPServerProtocol()
+    def create_protocol(self) -> LauncherDebugAdapterProtocol:
+        return LauncherDebugAdapterProtocol()
diff --git a/robotcode/debugger/listeners.py b/robotcode/debugger/listeners.py
@@ -75,32 +75,36 @@ def end_test(self, name: str, attributes: Dict[str, Any]) -> None:
         self.failed_keywords = None
 
     def start_keyword(self, name: str, attributes: Dict[str, Any]) -> None:
-        Debugger.instance().send_event(
-            self, Event(event="robotStarted", body=RobotExecutionEventBody(type="keyword", attributes=dict(attributes)))
-        )
-
-        Debugger.instance().start_output_group(
-            f"{name}({', '.join(repr(v) for v in attributes.get('args', []))})",
-            attributes,
-            attributes.get("type", None),
-        )
+        if attributes["type"] in ["KEYWORD", "SETUP", "TEARDOWN"]:
+            Debugger.instance().send_event(
+                self,
+                Event(event="robotStarted", body=RobotExecutionEventBody(type="keyword", attributes=dict(attributes))),
+            )
+
+            Debugger.instance().start_output_group(
+                f"{name}({', '.join(repr(v) for v in attributes.get('args', []))})",
+                attributes,
+                attributes.get("type", None),
+            )
 
         Debugger.instance().start_keyword(name, attributes)
 
     def end_keyword(self, name: str, attributes: Dict[str, Any]) -> None:
         Debugger.instance().end_keyword(name, attributes)
 
-        Debugger.instance().end_output_group(name, attributes)
+        if attributes["type"] in ["KEYWORD", "SETUP", "TEARDOWN"]:
+            Debugger.instance().end_output_group(name, attributes)
 
-        if attributes["status"] == "FAIL" and attributes.get("source", None):
-            if self.failed_keywords is None:
-                self.failed_keywords = []
+            if attributes["status"] == "FAIL" and attributes.get("source", None):
+                if self.failed_keywords is None:
+                    self.failed_keywords = []
 
-            self.failed_keywords.insert(0, {"message": self.last_fail_message, **attributes})
+                self.failed_keywords.insert(0, {"message": self.last_fail_message, **attributes})
 
-        Debugger.instance().send_event(
-            self, Event(event="robotEnded", body=RobotExecutionEventBody(type="keyword", attributes=dict(attributes)))
-        )
+            Debugger.instance().send_event(
+                self,
+                Event(event="robotEnded", body=RobotExecutionEventBody(type="keyword", attributes=dict(attributes))),
+            )
 
     def log_message(self, message: Dict[str, Any]) -> None:
         current_frame = Debugger.instance().stack_frames[0] if Debugger.instance().stack_frames else None
diff --git a/robotcode/debugger/protocol.py b/robotcode/debugger/protocol.py
@@ -3,7 +3,6 @@
 import asyncio
 import inspect
 import json
-import logging
 import threading
 import traceback
 from collections import OrderedDict
@@ -78,7 +77,6 @@ def __init__(
 class DebugAdapterProtocol(JsonRPCProtocolBase):
 
     _logger = LoggingDescriptor()
-    _message_logger = LoggingDescriptor(postfix=".message")
 
     def __init__(self) -> None:
         super().__init__()
@@ -90,19 +88,14 @@ def __init__(self) -> None:
 
     @_logger.call
     def send_message(self, message: ProtocolMessage) -> None:
-        body = as_json(message, indent=self._message_logger.is_enabled_for(logging.DEBUG) or None).encode(self.CHARSET)
+        body = as_json(message, compact=True).encode(self.CHARSET)
 
         header = (f"Content-Length: {len(body)}\r\n\r\n").encode("ascii")
 
-        self._message_logger.debug(
-            lambda: "write ->\n" + (header.decode("ascii") + body.decode(self.CHARSET)).replace("\r\n", "\n")
-        )
-
         if self.write_transport is not None:
             msg = header + body
-            if self._loop == asyncio.get_running_loop():
-                self.write_transport.write(msg)
-            elif self._loop is not None:
+
+            if self._loop:
                 self._loop.call_soon_threadsafe(self.write_transport.write, msg)
 
     def send_error(
diff --git a/robotcode/debugger/server.py b/robotcode/debugger/server.py
@@ -45,7 +45,7 @@
 TCP_DEFAULT_PORT = 6612
 
 
-class LauncherServerProtocol(DebugAdapterProtocol):
+class DebugAdapterServerProtocol(DebugAdapterProtocol):
     _logger = LoggingDescriptor()
 
     def __init__(self) -> None:
@@ -272,7 +272,7 @@ async def _set_exception_breakpoints(
         return SetExceptionBreakpointsResponseBody(breakpoints=result) if result else None
 
 
-class LaucherServer(JsonRPCServer[LauncherServerProtocol]):
+class DebugAdapterServer(JsonRPCServer[DebugAdapterServerProtocol]):
     def __init__(
         self,
         tcp_params: TcpParams = TcpParams(None, TCP_DEFAULT_PORT),
@@ -281,7 +281,7 @@ def __init__(
             mode=JsonRpcServerMode.TCP,
             tcp_params=tcp_params,
         )
-        self.protocol = LauncherServerProtocol()
+        self.protocol = DebugAdapterServerProtocol()
 
-    def create_protocol(self) -> LauncherServerProtocol:
+    def create_protocol(self) -> DebugAdapterServerProtocol:
         return self.protocol
diff --git a/robotcode/language_server/__main__.py b/robotcode/language_server/__main__.py
@@ -152,17 +152,17 @@ def init_logging(args: argparse.Namespace) -> None:
         _logger.logger.addHandler(get_log_handler(args.log_file))
 
     if not args.log_robotframework:
-        logging.getLogger("robotcode.language_server.robotframework").level = logging.CRITICAL
+        logging.getLogger("robotcode.language_server.robotframework").setLevel(logging.CRITICAL)
     if not args.log_language_server_parts:
-        logging.getLogger("robotcode.language_server.common.parts").level = logging.CRITICAL
+        logging.getLogger("robotcode.language_server.common.parts").setLevel(logging.CRITICAL)
     if not args.log_language_server:
-        logging.getLogger("robotcode.language_server.common").level = logging.CRITICAL
+        logging.getLogger("robotcode.language_server.common").setLevel(logging.CRITICAL)
     if not args.log_json_rpc:
-        logging.getLogger("robotcode.jsonrpc2").level = logging.CRITICAL
+        logging.getLogger("robotcode.jsonrpc2").setLevel(logging.CRITICAL)
     if not args.log_json_rpc_data:
-        logging.getLogger("robotcode.jsonrpc2.protocol.JsonRPCProtocol_data").level = logging.CRITICAL
+        logging.getLogger("robotcode.jsonrpc2.protocol.JsonRPCProtocol_data").setLevel(logging.CRITICAL)
     if not args.log_asyncio:
-        logging.getLogger("asyncio").level = logging.CRITICAL
+        logging.getLogger("asyncio").setLevel(logging.CRITICAL)
 
 
 def main() -> None:
