kalong 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

kalong/__init__.py

@@ -1,6 +1,6 @@
 """A new take on debugging"""
 
-__version__ = "0.5.3"
+__version__ = "0.5.5"
 import os
 import sys
 from pathlib import Path
@@ -111,25 +111,22 @@ def main():
 
     elif config.inject:
         kalong_dir = Path(__file__).resolve().parent.parent
-        gdb_command = (
-            ["gdb", "-p", str(config.inject), "-batch"]
-            + [
-                "-eval-command=call %s" % hook
-                for hook in [
-                    "(int) PyGILState_Ensure()",  # Getting the GIL
-                    '(int) PyRun_SimpleString("'
-                    f"print('* Kalong injection from {os.getpid()} *');"
-                    "import sys;"  # Putting kalong project directory in sys path:
-                    f"sys.path.insert(0, '{kalong_dir}');"
-                    "import kalong;"  # Setting breakpoint:
-                    "kalong.break_above(2);"
-                    '")',
-                    # Releasing the GIL with the PyGILState_Ensure handle:
-                    "(void) PyGILState_Release($1)",
-                ]
+        gdb_command = ["gdb", "-p", str(config.inject), "-batch"] + [
+            "-eval-command=call %s" % hook
+            for hook in [
+                "(int) PyGILState_Ensure()",  # Getting the GIL
+                '(int) PyRun_SimpleString("'
+                f"print('* Kalong injection from {os.getpid()} *');"
+                "import sys;"  # Putting kalong project directory in sys path:
+                f"sys.path.insert(0, '{kalong_dir}');"
+                "import kalong;"  # Setting breakpoint:
+                "kalong.break_above(2);"
+                '")',
+                # Releasing the GIL with the PyGILState_Ensure handle:
+                "(void) PyGILState_Release($1)",
             ]
-        )
-        print(f'Running: {" ".join(gdb_command)}')
+        ]
+        print(f"Running: {' '.join(gdb_command)}")
         run(gdb_command)
 
     else:

kalong/communication.py

@@ -25,7 +25,7 @@ from .errors import SetFrameError
 from .loops import get_loop
 from .stepping import add_step, clear_step, stop_trace
 from .utils import basicConfig, get_file_from_code
-from .websockets import die, websocket_state
+from .websockets import adie, die, websocket_state
 
 log = logging.getLogger(__name__)
 basicConfig(level=config.log_level)
@@ -161,7 +161,7 @@ async def handle_message(ws, data, frame, event, arg):
         elif command == "stop":
             clear_step()
             stop_trace(frame)
-            die()
+            await adie()
         else:
             step_frame = get_frame(frame, data.get("frame"), tb)
             add_step(command, step_frame)
@@ -194,42 +194,46 @@ async def communication_loop(frame_, event_, arg_, pending=None):
         # Otherwise if it's new, just wait for HELLO to answer current state
 
     stop = False
-    async for msg in ws:
-        if msg.type == WSMsgType.TEXT:
-            data = json.loads(msg.data)
-            try:
-                response = await handle_message(ws, data, frame, event, arg)
-            except Exception as e:
-                log.error(f"Error handling message {data}", exc_info=e)
-                response = {
-                    "type": "SET_ANSWER",
-                    "prompt": data.get("prompt", "?").strip(),
-                    "key": data["key"],
-                    "command": data.get("command"),
-                    "frame": data.get("frame"),
-                    "answer": [serialize_exception(*sys.exc_info(), "internal")],
-                }
-            log.debug(f"Got {data} answering with {response}")
-            response["local"] = True
-
-            if response.pop("recursive", False):
-                await ws.send_json({"type": "PAUSE", "recursive": True})
-                await init(ws, frame, event, arg)
-
-            stop = response.pop("stop", False)
-
-            try:
-                await ws.send_json(response)
-            except ConnectionResetError:
-                break
-
-            if stop:
+    try:
+        async for msg in ws:
+            if msg.type == WSMsgType.TEXT:
+                data = json.loads(msg.data)
+                try:
+                    response = await handle_message(ws, data, frame, event, arg)
+                except Exception as e:
+                    log.error(f"Error handling message {data}", exc_info=e)
+                    response = {
+                        "type": "SET_ANSWER",
+                        "prompt": data.get("prompt", "?").strip(),
+                        "key": data.get("key"),
+                        "command": data.get("command"),
+                        "frame": data.get("frame"),
+                        "answer": [serialize_exception(*sys.exc_info(), "internal")],
+                    }
+                log.debug(f"Got {data} answering with {response}")
+                response["local"] = True
+
+                if response.pop("recursive", False):
+                    await ws.send_json({"type": "PAUSE", "recursive": True})
+                    await init(ws, frame, event, arg)
+
+                stop = response.pop("stop", False)
+
+                try:
+                    await ws.send_json(response)
+                except ConnectionResetError:
+                    break
+
+                if stop:
+                    break
+
+            elif msg.type == WSMsgType.ERROR:
+                log.error("WebSocket closed", exc_info=ws.exception())
                 break
-
-        elif msg.type == WSMsgType.ERROR:
-            log.error("WebSocket closed", exc_info=ws.exception())
-            break
+    except asyncio.CancelledError:
+        log.error("WebSocket communication cancelled")
 
     # Browser exited, stopping debug if we are not stepping
     if not stop:
         stop_trace(frame)
+        await adie()

kalong/config.py

@@ -7,11 +7,15 @@ defaults = {
     "protocol": "http",
     "host": "localhost",
     "port": 59999,
+    "front_host": "localhost",
     "front_port": 59999,
+    "ws_host": "localhost",
+    "ws_port": 59999,
     "log": "warn",
     "detached": False,
     "command": [],
     "inject": None,
+    "urlsocket": False,
 }
 
 
@@ -24,25 +28,45 @@ class Config:
         parser.add_argument(
             "--server",
             action="store_true",
-            help="Launch the kalong server. " "This option is used by kalong itself",
+            help="Launch the kalong server. This option is used by kalong itself",
         )
         parser.add_argument(
             "--protocol",
             default=self.protocol,
             help="Protocol for contacting kalong server",
         )
-        parser.add_argument("--host", default=self.host, help="Host of kalong server")
         parser.add_argument(
-            "--port", type=int, default=self.port, help="Port of kalong server"
+            "--host",
+            default=self.host,
+            help="Host of kalong server",
         )
-        front_port_default = (
-            {"default": self.port} if self.port != self.front_port else {}
+        parser.add_argument(
+            "--port",
+            type=int,
+            default=self.port,
+            help="Port of kalong server",
+        )
+        parser.add_argument(
+            "--front-host",
+            default=self.front_host,
+            help="Host of kalong frontend, defaults to host option",
         )
         parser.add_argument(
             "--front-port",
             type=int,
+            default=self.front_port,
             help="Port of kalong frontend, defaults to port option",
-            **front_port_default,
+        )
+        parser.add_argument(
+            "--ws-host",
+            default=self.ws_host,
+            help="Host of kalong websocket server, defaults to host option",
+        )
+        parser.add_argument(
+            "--ws-port",
+            type=int,
+            default=self.ws_port,
+            help="Port of kalong websocket server, defaults to port option",
         )
         parser.add_argument(
             "--log",
@@ -66,6 +90,11 @@ class Config:
             action="store_true",
             help="Break at the start of the python file",
         )
+        parser.add_argument(
+            "--urlsocket",
+            type=str,
+            help="Path of the socket into which to feed the url for docker browser opening",
+        )
         parser.add_argument(
             "command",
             nargs=REMAINDER,
@@ -76,8 +105,14 @@ class Config:
 
     def parse_args(self):
         args = self.get_parser().parse_args()
+        if not args.front_host:
+            args.front_host = args.host
         if not args.front_port:
             args.front_port = args.port
+        if not args.ws_host:
+            args.ws_host = args.host
+        if not args.ws_port:
+            args.ws_port = args.port
         return args
 
     def from_args(self):
@@ -90,8 +125,14 @@ class Config:
             if value:
                 setattr(self, name, type(name)(value))
 
+        if os.getenv("KALONG_HOST") and not os.getenv("KALONG_FRONT_HOST"):
+            self.front_host = self.host
         if os.getenv("KALONG_PORT") and not os.getenv("KALONG_FRONT_PORT"):
             self.front_port = self.port
+        if os.getenv("KALONG_HOST") and not os.getenv("KALONG_WS_HOST"):
+            self.ws_host = self.host
+        if os.getenv("KALONG_PORT") and not os.getenv("KALONG_WS_PORT"):
+            self.ws_port = self.port
 
     def get_args_for_server(self):
         yield "--server"

kalong/loops.py

@@ -49,7 +49,7 @@ def close_loop():
     try:
         loops[origin].close()
     finally:
-        del loops[origin]
+        loops.pop(origin, None)
 
 
 def clean_loops():

kalong/server.py

@@ -29,6 +29,25 @@ def maybe_bail(app):
         )
 
 
+def index():
+    index.__content__ = getattr(index, "__content__", None)
+    if not index.__content__:
+        with open(Path(__file__).parent / "static" / "index.html", "rb") as f:
+            index.__content__ = f.read()
+        if config.ws_port != config.port or config.ws_host != config.host:
+            index.__content__ = index.__content__.replace(
+                b"</body>",
+                f"""
+            <script>
+                window.KALONG_WS_HOST = "{config.ws_host}";
+                window.KALONG_WS_PORT = {config.ws_port};
+            </script>
+        </body>
+        """.encode(),
+            )
+    return web.Response(body=index.__content__, content_type="text/html")
+
+
 async def shutdown(app):
     log.info("App shutdown, closing remaining websockets.")
     await asyncio.gather(
@@ -60,51 +79,53 @@ async def websocket(request):
     state = ws.can_prepare(request)
     if not state.ok:
         log.debug(f"Sending {side} app for {origin}")
-        return web.FileResponse(Path(__file__).parent / "static" / "index.html")
+        return index()
 
     await ws.prepare(request)
 
     log.debug(f"{side.title()} app connected for {origin}")
     request.app[side][origin] = ws
 
-    async for msg in ws:
-        if msg.type == WSMsgType.TEXT:
-            data = json.loads(msg.data)
-            log.debug(f"{side} -> {other_side}: {data}")
-            try:
-                pair = await peer(request.app, other_side, origin)
-            except NoClientFoundError:
-                log.error(
-                    f"No {human_readable_side(other_side)} connection was found, aborting debugger"
-                )
-                break
-            if data["type"] == "DO_COMMAND":
-                if data["command"] in ["pause", "kill"]:
-                    _, pid, _ = parse_origin(origin)
-                    os.kill(
-                        pid,
-                        signal.SIGTERM if data["command"] == "kill" else USER_SIGNAL,
+    try:
+        async for msg in ws:
+            if msg.type == WSMsgType.TEXT:
+                data = json.loads(msg.data)
+                log.debug(f"{side} -> {other_side}: {data}")
+                try:
+                    pair = await peer(request.app, other_side, origin)
+                except NoClientFoundError:
+                    log.error(
+                        f"No {human_readable_side(other_side)} connection was found, aborting debugger"
                     )
-                    continue
-
-            await pair.send_json(data)
-        elif msg.type == WSMsgType.ERROR:
-            log.error(f"{side.title()} closed", exc_info=ws.exception())
+                    break
+                if data["type"] == "DO_COMMAND":
+                    if data["command"] in ["pause", "kill"]:
+                        _, pid, _ = parse_origin(origin)
+                        sign = (
+                            signal.SIGKILL if data["command"] == "kill" else USER_SIGNAL
+                        )
+                        log.info(f"Sending signal {sign} to {pid}")
+                        os.kill(pid, sign)
+                        continue
+
+                await pair.send_json(data)
+            elif msg.type == WSMsgType.ERROR:
+                log.error(f"{side.title()} closed", exc_info=ws.exception())
+    except asyncio.CancelledError:
+        log.error(f"{side.title()} WebSocket communication cancelled")
 
     log.debug(f"Closing {side}")
-    await ws.close()
 
     if side in request.app and origin in request.app[side]:
-        del request.app[side][origin]
+        request.app[side].pop(origin)
 
     if not config.detached:
         if origin in request.app[other_side]:
             log.debug(f"Closing {other_side} due to {side} closing.")
-            await request.app[other_side][origin].close()
-
-        if origin in request.app[other_side]:
-            del request.app[other_side][origin]
+            s = request.app[other_side].pop(origin)
+            await s.close()
 
+    await ws.close()
     maybe_bail(request.app)
     return ws