camera.ui3 0.0.30-alpha.0

package/dist/server/src/polyglot/python/plugins/message_queue.py

@@ -0,0 +1,182 @@
+import asyncio
+from typing import Any, Callable, cast
+
+from nats.aio.msg import Msg
+from plugin_logger import PluginLogger
+from plugins.constants import NATS_SERVER_SUBJECT
+from typings import ProxyMessageStructure, QueueItem, RemoteError
+from utilities.connection import ProxyConnection
+from utilities.packer import unpack
+from utilities.subscriptions import ProxySubscription
+from utilities.task import TaskSet
+
+
+class MessageQueue:
+    def __init__(
+        self,
+        logger: PluginLogger,
+        publisher: ProxyConnection,
+        subscriber: ProxySubscription,
+        request_handler: Callable[[ProxyMessageStructure], Any],
+    ):
+        self.logger = logger
+        self.publisher = publisher
+        self.subscriber = subscriber
+        self.request_handler = request_handler
+
+        self.aborted = False
+        self.is_processing = False
+
+        self.tasks: TaskSet = TaskSet(f"MessageQueue {self.publisher.name}")
+        self.queue: list[QueueItem] = []
+        self.pending_responses: dict[str, QueueItem] = {}
+
+        self.subscriber.on("message", self.__on_message)
+
+    def abort_queue(self) -> None:
+        self.aborted = True
+        self.is_processing = False
+
+        while self.queue:
+            item = self.queue.pop(0)
+            remote_error = RemoteError(
+                {
+                    "name": "AbortError",
+                    "message": "Message processing aborted",
+                    "stack": "",
+                },
+                item["message"],
+            )
+
+            item["reject"](remote_error)
+
+        for request_id, handlers in self.pending_responses.items():
+            remote_error = RemoteError(
+                {
+                    "name": "AbortError",
+                    "message": "Request aborted due to queue abort",
+                    "stack": "",
+                },
+                handlers["message"],
+            )
+
+            handlers["reject"](remote_error)
+            del self.pending_responses[request_id]
+
+    async def enqueue(self, message: ProxyMessageStructure) -> Any:
+        if message["type"] == "request" and message["timeout"] > 0:
+            # print(
+            #     "CLIENT => Enqueueing message:", json.dumps(message, indent=4)
+            # )
+
+            promise = asyncio.get_event_loop().create_future()
+
+            queue_item: QueueItem = {
+                "message": message,
+                "resolve": promise.set_result,
+                "reject": promise.set_exception,
+            }
+
+            self.queue.append(queue_item)
+
+            if not self.is_processing:
+                self.tasks.add(self.__process_queue())
+
+            return await promise
+        else:
+            await self.publisher.publish(NATS_SERVER_SUBJECT, message)
+
+    async def __process_queue(self) -> None:
+        if self.is_processing or not self.queue or self.aborted:
+            return
+
+        self.is_processing = True
+
+        while self.queue and not self.aborted:
+            current_item = self.queue.pop(0)
+            request_id: str = current_item["message"].get("requestId", "")
+
+            # print(
+            #     "CLIENT => Sending request to SERVER:",
+            #     json.dumps(current_item["message"], indent=4),
+            # )
+
+            timeout = current_item["message"].get("timeout", 5000) / 1000
+
+            def cleanup():
+                if request_id in self.pending_responses:
+                    handle.cancel()
+                    del self.pending_responses[request_id]
+
+            def on_timeout():
+                if not self.aborted:
+                    remote_error = RemoteError(
+                        {
+                            "name": "TimeoutError",
+                            "message": f"Request timed out after {timeout} seconds",
+                            "stack": "",
+                        },
+                        current_item["message"],
+                    )
+
+                    current_item["reject"](remote_error)
+                    cleanup()
+
+            loop = asyncio.get_event_loop()
+            handle = loop.call_later(timeout, on_timeout)
+
+            def response(response: Any):
+                if not self.aborted:
+                    current_item["resolve"](response)
+                    cleanup()
+
+            def reject(error: RemoteError):
+                if not self.aborted:
+                    current_item["reject"](error)
+                    cleanup()
+
+            self.pending_responses[request_id] = {
+                "message": current_item["message"],
+                "resolve": response,
+                "reject": reject,
+            }
+
+            await self.publisher.publish(NATS_SERVER_SUBJECT, current_item["message"])
+
+        self.is_processing = False
+
+    async def __on_message(self, msg: Msg) -> None:
+        if self.aborted:
+            return
+
+        message = cast(ProxyMessageStructure, unpack(msg.data))
+
+        if message.get("type") == "reply":
+            # print(
+            #     "CLIENT => Received reply from SERVER:",
+            #     json.dumps(message, indent=4),
+            # )
+
+            request_id = message.get("requestId", "")
+
+            current_item = self.pending_responses.get(request_id, None)
+
+            if current_item is None:
+                # self.logger.error("Unknown reply from server:", message)
+                return
+
+            if "error" in message:
+                error = message.pop("error")
+                cause: Any = {k: v for k, v in message.items()}
+                current_item["reject"](RemoteError(error, cause))
+            else:
+                current_item["resolve"](message.get("response", {}))
+        elif message.get("type") == "request":
+            # print(
+            #     "CLIENT => Received request from SERVER:",
+            #     json.dumps(message, indent=4),
+            # )
+
+            self.tasks.add(self.request_handler(message))
+        else:
+            raise Exception(f"Invalid message type received: {message['type']}")

package/dist/server/src/polyglot/python/plugins/plugin_api.py

@@ -0,0 +1,34 @@
+from typing import Any, Literal
+
+from config_service import PluginConfigService
+from decoder.typings import AuthConfig
+from lmdbm import Lmdb
+from plugin_logger import PluginLogger
+from pyeecui.asyncio import AsyncIOEventEmitter
+from typings import PluginInfo
+
+
+class PluginAPI(AsyncIOEventEmitter):
+    def __init__(
+        self,
+        plugin: PluginInfo,
+        storage_path: str,
+        config_file: str,
+        logger: PluginLogger,
+        proxy_endpoints: list[str],
+        auth: AuthConfig,
+        plugin_db: Lmdb[Literal["config"], dict[str, Any]],
+    ) -> None:
+        super().__init__()
+
+        from proxy.core_manager import CoreManager
+        from proxy.device_manager import DeviceManager
+        from storage_controller import StorageController
+
+        self.storage_path = storage_path
+        self.config_file = config_file
+
+        self.config_service = PluginConfigService(config_file)
+        self.storage_controller = StorageController(self, plugin_db)
+        self.core_manager = CoreManager(self, logger, plugin, proxy_endpoints, auth)
+        self.device_manager = DeviceManager(self, logger, plugin, proxy_endpoints, auth)

package/dist/server/src/polyglot/python/plugins/plugin_logger.py

@@ -0,0 +1,111 @@
+import json
+import traceback
+from datetime import datetime
+from typing import Any
+
+
+class Colors:
+    RESET = "\033[0m"
+    WHITE = "\033[37m"
+    BLUE = "\033[34m"
+    CYAN = "\033[36m"
+    RED = "\033[31m"
+    YELLOW = "\033[33m"
+    MAGENTA = "\033[35m"
+    LIGHT_BLACK = "\033[90m"
+    RED_BACKGROUND = "\033[41m"
+    YELLOW_BACKGROUND = "\033[43m"
+    MAGENTA_BACKGROUND = "\033[45m"
+    WHITE_BACKGROUND = "\033[47m"
+    BOLD = "\033[1m"
+
+
+class PluginLogger:
+    def __init__(self, prefix: str, disable_timestamps: bool) -> None:
+        self.__prefix = "camera.ui"
+        self.__disable_timestamps = disable_timestamps
+        self.__logger_prefix = prefix
+
+        self.debug_enabled = True
+        self.trace_enabled = True
+
+    @property
+    def prefix(self) -> str:
+        if not self.__disable_timestamps:
+            return f"{Colors.WHITE}[{self.__format_date_time()}] {Colors.BLUE}[{self.__prefix}] {Colors.CYAN}[{self.__logger_prefix}]{Colors.RESET}"
+        else:
+            return f"{Colors.BLUE}[{self.__prefix}] {Colors.CYAN}[{self.__logger_prefix}]{Colors.RESET}"
+
+    def log(self, *args: Any) -> None:
+        formatted_args = self.__format_args(args)
+        print(self.prefix, *formatted_args)
+
+    def error(self, *args: Any) -> None:
+        formatted_args = self.__format_args(args)
+        print(
+            self.prefix,
+            f"{Colors.RED_BACKGROUND}{Colors.BOLD} ERROR {Colors.RESET}",
+            f"{Colors.RED}{' '.join(formatted_args)}{Colors.RESET}",
+        )
+
+    def warn(self, *args: Any) -> None:
+        formatted_args = self.__format_args(args)
+        print(
+            self.prefix,
+            f"{Colors.YELLOW_BACKGROUND}{Colors.BOLD} WARN {Colors.RESET}",
+            f"{Colors.YELLOW}{' '.join(formatted_args)}{Colors.RESET}",
+        )
+
+    def attention(self, *args: Any) -> None:
+        formatted_args = self.__format_args(args)
+        print(
+            self.prefix,
+            f"{Colors.MAGENTA_BACKGROUND}{Colors.BOLD} ATTENTION {Colors.RESET}",
+            f"{Colors.MAGENTA}{' '.join(formatted_args)}{Colors.RESET}",
+        )
+
+    def debug(self, *args: Any) -> None:
+        if not self.debug_enabled:
+            return
+
+        formatted_args = self.__format_args(args)
+        print(
+            self.prefix,
+            f"{Colors.LIGHT_BLACK}{' '.join(formatted_args)}{Colors.RESET}",
+        )
+
+    def trace(self, *args: Any) -> None:
+        if not self.trace_enabled:
+            return
+
+        formatted_args = self.__format_args(args)
+        print(
+            self.prefix,
+            f"{Colors.WHITE_BACKGROUND}{Colors.BOLD} TRACE {Colors.RESET}",
+            f"{Colors.LIGHT_BLACK}{' '.join(formatted_args)}{Colors.RESET}",
+        )
+
+    def __format_args(self, args: Any) -> list[str]:
+        formatted_args: list[str] = []
+        for arg in args:
+            if isinstance(arg, BaseException):
+                message = f"{arg.__class__.__name__}: {arg}"
+                formatted_args.append(message)
+                traceback_info = traceback.format_exception(type(arg), arg, arg.__traceback__)
+                formatted_args.append("\n")
+                formatted_args.extend(traceback_info)
+                # formatted_args.extend(traceback_info[:-1])
+            elif isinstance(arg, dict):
+                try:
+                    formatted_args.append(json.dumps(arg, indent=2))
+                except TypeError:
+                    formatted_args.append(repr(arg))  # type: ignore
+            else:
+                formatted_args.append(str(arg))
+        return formatted_args
+
+    def __format_date_time(self) -> str:
+        try:
+            return datetime.now().strftime("%d.%m.%Y, %H:%M:%S")
+        except:  # noqa
+            return "Unknown"