dbgr-server 1.1.0.dev1__py3-none-any.whl

dbgr_server/utils/state.py

@@ -0,0 +1,249 @@
+# Stdlib:
+import json
+import logging
+from struct import pack
+from typing import Any, Dict, List, Optional, Set, Union
+
+log = logging.getLogger("dbgr_server")
+
+
+class BaseSockets:
+    """
+    Base class for implement protocol for TCP/Web Socket.
+    """
+
+    __slots__ = ["_sockets"]
+
+    def __init__(self) -> None:
+        self._sockets: Dict[str, Any] = {}
+
+    async def send(
+        self,
+        uuid: str,
+        data: str,
+        message: Optional[Union[Dict[str, Any], List[int], str]] = None,
+    ) -> None:
+        """
+        Send messsage to TCP/Web Socket by uuid.
+        """
+        if message:
+            data = data + "|" + json.dumps(message)
+        sck = self.get(uuid)
+        if sck is not None:
+            await self._send(sck, data)
+        else:
+            log.warning("No socket found for %s", uuid)
+
+    async def _send(self, sck: Any, data: str) -> None:
+        raise NotImplementedError
+
+    def get(self, uuid: str) -> Any:
+        """
+        Simple getter for retrieve TCP/Web Socket by uuid.
+        """
+        return self._sockets.get(uuid)
+
+    async def broadcast(
+        self,
+        cmd: str,
+        message: Optional[Union[Dict[str, Any], List[int], str]] = None,
+    ) -> None:
+        """
+        Broadcast message to TCP/Web Socket.
+        """
+        for uuid in list(self._sockets.keys()):
+            try:
+                log.debug("Broadcast to socket %s", uuid)
+                await self.send(uuid, cmd, message)
+            except Exception:  # pylint: disable=broad-except
+                log.warning("Failed broadcast to socket %s", uuid)
+                await self.close(uuid)
+                await self.remove(uuid)
+
+    async def add(self, uuid: str, sck: Any) -> None:
+        """
+        Function which add/re-add TCP/Web Socket to store.
+        """
+        if uuid in self._sockets:
+            await self.remove(uuid)
+            await self.close(uuid)
+
+        self._sockets[uuid] = sck
+
+    async def remove(self, uuid: str) -> None:
+        """
+        Function which remove TCP/Web Socket from store.
+        """
+        sck = self._sockets.pop(uuid, None)
+        if sck:
+            await syncwebsockets.broadcast(
+                "Remove" + self.__class__.__name__.rstrip("s"), uuid
+            )
+
+    async def close(self, uuid: str) -> None:
+        """
+        Function which close TCP/Web Socket.
+        """
+        sck = self.get(uuid)
+        if sck is not None:
+            try:
+                await sck.close()
+            except Exception:  # pylint: disable=broad-except
+                log.warning("Failed close to socket %s", uuid)
+
+    @property
+    def uuids(self) -> Set[str]:
+        """
+        Simple property to return all UUID's.
+        """
+        return set(self._sockets.keys())
+
+
+class Sockets(BaseSockets):
+    """
+    General store for active TCP Sockets.
+    """
+
+    __slots__ = ["_sockets", "_filenames"]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._filenames: Dict[str, Any] = {}
+
+    async def add(self, uuid: str, sck: Any) -> None:
+        await super().add(uuid, sck)
+        await syncwebsockets.broadcast("AddSocket", {"uuid": uuid})
+
+    async def remove(self, uuid: str) -> None:
+        await super().remove(uuid)
+        self._filenames.pop(uuid, None)
+
+    def get_filename(self, uuid: str) -> str:
+        """
+        Simple getter for retrieve filename by uuid.
+        """
+        return self._filenames.get(uuid, "")
+
+    async def set_filename(self, uuid: str, filename: str) -> None:
+        """
+        Simple setter for set filename for uuid.
+        """
+        self._filenames[uuid] = filename
+        await syncwebsockets.broadcast(
+            "AddSocket",
+            {
+                "uuid": uuid,
+                "filename": filename if settings.show_filename else "",
+            },
+        )
+
+    async def _send(self, sck: Any, data: str) -> None:
+        await sck.write(pack("!i", len(data)))
+        await sck.write(data.encode("utf-8"))
+
+
+class BaseWebSockets(BaseSockets):
+    """
+    Base class for implement WebSockets/SyncWebSockets
+    """
+
+    __slots__ = ["_sockets"]
+
+    async def _send(self, sck: Any, data: str) -> None:
+        if hasattr(sck, "ws"):
+            await sck.write_message(data)
+        else:
+            log.warning("Websocket is closed")
+
+
+class WebSockets(BaseWebSockets):
+    """
+    General store for active WebSockets.
+    """
+
+    __slots__ = ["_sockets"]
+
+    async def add(self, uuid: str, sck: Any) -> None:
+        await super().add(uuid, sck)
+        await syncwebsockets.broadcast("AddWebSocket", uuid)
+
+
+class SyncWebSockets(BaseWebSockets):
+    """
+    General store for active synchronization WebSockets.
+    """
+
+    __slots__ = ["_sockets"]
+
+
+class Breakpoints:
+    """
+    General store for active breakpoints.
+    """
+
+    __slots__ = ["_breakpoints"]
+
+    def __init__(self) -> None:
+        self._breakpoints: List[Any] = []
+
+    async def add(self, brk: Any) -> None:
+        """
+        Add breakpoint to store and broadcast messaage about it.
+        """
+        if brk not in self._breakpoints:
+            self._breakpoints.append(brk)
+            await syncwebsockets.broadcast("AddBreak|" + json.dumps(brk))
+
+    async def remove(self, brk: Any) -> None:
+        """
+        Remove breakpoint from store and broadcast messaage about it.
+        """
+        if brk in self._breakpoints:
+            self._breakpoints.remove(brk)
+            await syncwebsockets.broadcast("RemoveBreak|" + json.dumps(brk))
+
+    def get(self) -> List[Any]:
+        """
+        Simple getter for access to breakpoints store.
+        """
+        return self._breakpoints
+
+
+# pylint: disable=too-few-public-methods
+class Settings:
+    """
+    Simple class for store application settings
+    """
+
+    __slots__ = [
+        "debug",
+        "extra_search_path",
+        "more",
+        "detached_session",
+        "show_filename",
+    ]
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.debug: bool = False
+        self.extra_search_path: bool = False
+        self.more: bool = False
+        self.detached_session: bool = False
+        self.show_filename: bool = False
+        self._set_params(**kwargs)
+
+    def update(self, **kwargs: Any) -> None:
+        """
+        Update attributes afteer init
+        """
+        self._set_params(**kwargs)
+
+    def _set_params(self, **kwargs: Any) -> None:
+        for name, value in kwargs.items():
+            setattr(self, name, value)
+
+
+sockets = Sockets()
+websockets = WebSockets()
+syncwebsockets = SyncWebSockets()
+breakpoints = Breakpoints()
+settings = Settings()

dbgr_server/utils/streams.py

@@ -0,0 +1,151 @@
+# Stdlib:
+import asyncio
+import json
+import logging
+from asyncio.exceptions import IncompleteReadError
+from struct import unpack
+
+# Firstparty:
+from dbgr_server.constants import UNKNOWN_UUID
+from dbgr_server.utils.state import breakpoints, sockets, websockets
+
+log = logging.getLogger("dbgr_server")
+
+
+class IOStream:
+    """
+    Base class for interacting with reader/writer
+    """
+
+    __slots__ = ["_reader", "_writer", "_uuid"]
+
+    def __init__(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        self._reader: asyncio.StreamReader = reader
+        self._writer: asyncio.StreamWriter = writer
+        self._uuid: str = UNKNOWN_UUID
+
+    @property
+    def uuid(self) -> str:
+        """The uuid property."""
+        return self._uuid
+
+    @uuid.setter
+    def uuid(self, uuid: str) -> None:
+        self._uuid = uuid
+
+    async def readexactly(self, num_bytes: int) -> bytes:
+        """
+        Alias to asyncio.StreamReader.readexactly
+        """
+        return await self._reader.readexactly(num_bytes)
+
+    async def write(self, data: bytes) -> None:
+        """
+        Alias to asyncio.StreamWriter.write with drain after
+        """
+        self._writer.write(data)
+        await self._writer.drain()
+
+    async def close(self) -> None:
+        """
+        Close active socket
+        """
+        self._writer.close()
+        try:
+            await self._writer.wait_closed()
+        except BrokenPipeError:
+            pass
+        finally:
+            await self.on_close()
+
+    async def on_close(self) -> None:
+        """
+        Clean store and broadcast messages
+        """
+        # None if the user closed the window
+        log.info("uuid %s closed", self.uuid)
+        if websockets.get(self.uuid):
+            try:
+                await websockets.send(self.uuid, "Die")
+            except ConnectionResetError:
+                log.warning("Closed stream for %s", self.uuid)
+            await websockets.close(self.uuid)
+            await websockets.remove(self.uuid)
+        await sockets.remove(self.uuid)
+
+
+async def read_frame(stream: IOStream, uuid: str, frame: bytes) -> None:
+    """
+    Decode frame and process.
+    """
+    decoded_frame = frame.decode("utf-8")
+    if decoded_frame == "ServerBreaks":
+        await sockets.send(uuid, json.dumps(breakpoints.get()))
+    elif decoded_frame == "PING":
+        log.info("%s PONG", uuid)
+    elif decoded_frame.startswith("UPDATE_FILENAME"):
+        filename = decoded_frame.split("|", 1)[1]
+        await sockets.set_filename(uuid, filename)
+    else:
+        await websockets.send(uuid, frame.decode("utf-8"))
+    try:
+        await read_header(stream, uuid, await stream.readexactly(4))
+    except IncompleteReadError:
+        log.warning("Closed stream for %s", uuid)
+
+
+async def read_header(stream: IOStream, uuid: str, _length: bytes) -> None:
+    """
+    Read header data and process frame.
+    """
+    (length,) = unpack("!i", _length)
+    try:
+        await read_frame(stream, uuid, await stream.readexactly(length))
+    except IncompleteReadError:
+        log.warning("Closed stream for %s", uuid)
+
+
+async def assign_stream(stream: IOStream, _uuid: bytes) -> None:
+    """
+    Assign IOStream and socket.
+    """
+    uuid = _uuid.decode("utf-8")
+    log.debug("Assigning stream to %s", uuid)
+    await sockets.add(uuid, stream)
+    stream.uuid = uuid
+    try:
+        await read_header(stream, uuid, await stream.readexactly(4))
+    except IncompleteReadError:
+        log.warning("Closed stream for %s", uuid)
+
+
+async def read_uuid_size(stream: IOStream, _length: bytes) -> None:
+    """
+    Read UUID and go ahead.
+    """
+    (length,) = unpack("!i", _length)
+    assert length == 36, "Wrong uuid"
+    try:
+        await assign_stream(stream, await stream.readexactly(length))
+    except IncompleteReadError:
+        log.warning("Closed stream for getting uuid")
+
+
+async def handle_tcp_connection(
+    reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+) -> None:
+    """
+    General handler function to handle input TCP connections.
+    """
+    address = writer.get_extra_info("peername")[0]
+    log.info("Connection received from %s", str(address))
+    stream = IOStream(reader, writer)
+    try:
+        await read_uuid_size(stream, await stream.readexactly(4))
+    except IncompleteReadError:
+        log.warning("Closed stream for getting uuid length")
+    finally:
+        await stream.close()
+        del stream

dbgr_server/utils/technical.py

@@ -0,0 +1,132 @@
+# pylint: disable=missing-class-docstring
+# pylint: disable=missing-function-docstring
+# pylint: disable=unsubscriptable-object
+# Stdlib:
+import asyncio
+import logging
+from glob import glob
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+# Thirdparty:
+import psutil
+
+# Firstparty:
+from dbgr_server.constants import UNKNOWN_UUID
+from dbgr_server.utils.state import syncwebsockets
+
+log = logging.getLogger("dbgr_server")
+
+try:
+    # Thirdparty:
+    import pyinotify
+except ImportError:
+    LibPythonWatcher = None  # pylint: disable=invalid-name
+else:
+
+    class LibPythonWatcher:  # type: ignore # pragma: no cover
+        def __init__(self, extra_search_path: Optional[str] = None) -> None:
+            inotify = pyinotify.WatchManager()
+            self.files = glob("/usr/lib/libpython*")
+            if not self.files:
+                self.files = glob("/lib/libpython*")
+
+            if extra_search_path is not None:
+                # Handle custom installation paths
+                for file in Path(extra_search_path).rglob("libpython*"):
+                    self.files.append(str(file.resolve()))
+
+            log.debug("Watching for %s", self.files)
+            self.notifier = pyinotify.AsyncioNotifier(
+                inotify,
+                asyncio.get_event_loop(),
+                self.notified,
+                pyinotify.ProcessEvent(),
+            )
+            inotify.add_watch(
+                self.files,
+                pyinotify.EventsCodes.ALL_FLAGS["IN_OPEN"]
+                | pyinotify.EventsCodes.ALL_FLAGS["IN_CLOSE_NOWRITE"],
+            )
+
+        # pylint: disable=unused-argument
+        async def notified(self, notifier: Any) -> None:
+            log.debug("Got notified for %s", self.files)
+            await refresh_process()
+            log.debug("Process refreshed")
+
+        def close(self) -> None:
+            log.debug("Closing for %s", self.files)
+            self.notifier.stop()
+
+
+async def refresh_process(uuid: str = UNKNOWN_UUID) -> None:
+
+    if uuid != UNKNOWN_UUID:
+
+        async def send(
+            data: str,
+            message: Optional[Union[Dict[str, Any], List[int], str]] = None,
+        ) -> None:
+            await syncwebsockets.send(uuid, data, message)
+
+    else:
+
+        async def send(
+            data: str,
+            message: Optional[Union[Dict[str, Any], List[int], str]] = None,
+        ) -> None:
+            await syncwebsockets.broadcast(data, message)
+
+    remaining_pids = []
+    remaining_tids = []
+    for proc in psutil.process_iter():
+        try:
+            cl = proc.cmdline()  # pylint: disable=invalid-name
+        except (
+            psutil.ZombieProcess,
+            psutil.AccessDenied,
+            psutil.NoSuchProcess,
+        ):
+            continue
+        else:
+            if len(cl) == 0:
+                continue
+
+        binary = cl[0].split("/")[-1]
+        if (
+            ("python" in binary or "pypy" in binary)
+            and proc.is_running()
+            and proc.status() != psutil.STATUS_ZOMBIE
+        ):
+            try:
+                try:
+                    cpu = proc.cpu_percent(interval=0.01)
+                    await send(
+                        "AddProcess",
+                        {
+                            "pid": proc.pid,
+                            "user": proc.username(),
+                            "cmd": " ".join(proc.cmdline()),
+                            "threads": proc.num_threads(),
+                            "time": proc.create_time(),
+                            "mem": proc.memory_percent(),
+                            "cpu": cpu,
+                        },
+                    )
+                    remaining_pids.append(proc.pid)
+                    for thread in proc.threads():
+                        await send(
+                            "AddThread", {"id": thread.id, "of": proc.pid}
+                        )
+                        remaining_tids.append(thread.id)
+                except psutil.NoSuchProcess:
+                    pass
+                except psutil.AccessDenied:
+                    pass
+            except Exception:  # pylint: disable=broad-except
+                log.warning("", exc_info=True)
+                continue
+
+    await send("KeepProcess", remaining_pids)
+    await send("KeepThreads", remaining_tids)