@camera.ui/server 0.0.1

package/dist/server/src/polyglot/python/plugins/proxy/device_manager.py

@@ -0,0 +1,265 @@
+from contextlib import suppress
+from datetime import datetime
+from typing import Any, Optional, Union, cast
+from uuid import uuid4
+
+import nats
+from camera_ui_types import Camera, CameraConfig
+from logger import PluginLogger
+from nats.aio.client import Client as NatsConnection
+from nats.aio.msg import Msg
+from nats.aio.subscription import Subscription
+from plugin_api import PluginAPI
+from pyeecui.asyncio import AsyncIOEventEmitter
+from typings import PluginInfo, ProxyMessageStructure
+from utilities.packer import unpack
+from utilities.task import TaskSet
+
+from .camera_device import CameraDeviceProxy
+from .message_queue import ClientMessageQueue
+
+
+class DeviceManager(AsyncIOEventEmitter):
+    def __init__(
+        self,
+        api: PluginAPI,
+        logger: PluginLogger,
+        plugin: PluginInfo,
+        proxy_endpoints: list[str],
+        auth: dict[str, str],
+    ):
+        super().__init__()
+
+        self.initialized = False
+
+        self.devices: dict[str, CameraDeviceProxy] = {}
+
+        self.api = api
+        self.logger = logger
+
+        self.auth = auth
+        self.proxy_endpoints = proxy_endpoints
+        self.plugin = plugin
+
+        self.subject = f"{self.plugin['id']}.deviceManager"
+        self.dm_subject = f"{self.plugin['id']}.deviceManager.subscriber"
+
+        self.publisher: Optional[NatsConnection] = None
+        self.dm_publisher: Optional[NatsConnection] = None
+
+        self.subscriber: Optional[Subscription] = None
+        self.dm_subscriber: Optional[Subscription] = None
+
+        self.tasks: TaskSet = TaskSet(f"{self.plugin['name']} DeviceManager")
+        self.message_queue: Optional[ClientMessageQueue] = None
+
+        # print("DeviceManager", self.plugin["name"], self.dealer_id, self.subscriber_ids)
+
+        self.api.once("shutdown", self.__close)
+
+    async def init(self):
+        if self.initialized:
+            return
+
+        self.initialized = True
+
+        async def ignore_cb(e: Optional[Any] = None):
+            pass
+
+        self.publisher = await nats.connect(
+            servers=[endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")],
+            name=self.subject,
+            user=self.auth["user"],
+            password=self.auth["pass"],
+            max_reconnect_attempts=-1,
+            error_cb=ignore_cb,
+            disconnected_cb=ignore_cb,
+            closed_cb=ignore_cb,
+            reconnected_cb=ignore_cb,
+            discovered_server_cb=ignore_cb,
+        )
+
+        self.dm_publisher = await nats.connect(
+            servers=[endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")],
+            name=self.dm_subject,
+            user=self.auth["user"],
+            password=self.auth["pass"],
+            max_reconnect_attempts=-1,
+            error_cb=ignore_cb,
+            disconnected_cb=ignore_cb,
+            closed_cb=ignore_cb,
+            reconnected_cb=ignore_cb,
+            discovered_server_cb=ignore_cb,
+        )
+
+        self.subscriber = await self.publisher.subscribe(subject=self.subject)
+        self.dm_subscriber = await self.dm_publisher.subscribe(subject=self.dm_subject)
+
+        self.message_queue = ClientMessageQueue(
+            self.logger,
+            self.publisher,
+            self.subscriber,
+            self.__request_handler,
+        )
+
+        self.tasks.add(self.message_queue.start())
+        self.tasks.add(self.__listen_to_messages())
+
+    async def get_camera_by_id(self, id: str) -> Optional[CameraDeviceProxy]:
+        camera_device = await self.__add_or_get_camera(id)
+
+        if not camera_device:
+            camera: Camera = await self.__on_request("getCameraById", [id])
+
+            if camera:
+                camera_device = await self.__add_or_get_camera(camera)
+
+        return camera_device
+
+    async def get_camera_by_name(self, name: str) -> Optional[CameraDeviceProxy]:
+        camera_device = next((device for device in self.devices.values() if device.name == name), None)
+
+        if not camera_device:
+            camera: Camera = await self.__on_request("getCameraByName", [name])
+
+            if camera:
+                camera_device = await self.__add_or_get_camera(camera)
+
+        return camera_device
+
+    async def create_camera(self, camera_config: CameraConfig) -> CameraDeviceProxy:
+        camera: Camera = await self.__on_request("createCamera", [camera_config])
+        camera_device = cast(CameraDeviceProxy, await self.__add_or_get_camera(camera))
+        return camera_device
+
+    async def remove_camera_by_name(self, name: str) -> None:
+        camera = await self.__on_request("getCameraByName", [name])
+
+        if camera:
+            await self.__on_request("removeCameraByName", [name])
+            del self.devices[camera["_id"]]
+
+    async def remove_camera_by_id(self, id: str) -> None:
+        await self.__on_request("removeCameraById", [id])
+        del self.devices[id]
+
+    def configure_cameras(self, camera_devices: list[CameraDeviceProxy]) -> None:
+        for camera_device in camera_devices:
+            self.devices[camera_device.id] = camera_device
+
+    def emit(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        pass
+
+    async def __request_handler(self, message: ProxyMessageStructure):
+        pass
+
+    async def __emit_event(self, msg: Msg) -> None:
+        message = unpack(msg.data)
+
+        type = message.get("type")
+        data = message.get("data", {})
+        camera = data.get("camera")
+        extension = data.get("extension")
+
+        if type == "cameraSelected":
+            camera_device = await self.__add_or_get_camera(camera)
+
+            super().emit(type, camera_device, extension)
+        elif type == "cameraDeselected":
+            camera_device = self.devices.get(camera["_id"])
+
+            if camera_device:
+                await camera_device.cleanup()
+
+            del self.devices[camera["_id"]]
+
+            super().emit(type, camera["_id"], extension)
+
+    async def __listen_to_messages(self) -> None:
+        if not self.dm_subscriber:
+            raise Exception("Subscriber is not initialized")
+
+        async for msg in self.dm_subscriber.messages:
+            try:
+                if not self.initialized:
+                    break
+
+                if len(msg.data) == 0:
+                    continue
+
+                self.tasks.add(self.__emit_event(msg))
+            except Exception as e:
+                if self.initialized:
+                    self.logger.error(
+                        "Error while listening to device manager messages from server:",
+                        e,
+                    )
+                else:
+                    break
+
+    async def __on_request(self, fn: str, args: list[Any] = []) -> Any:
+        if not self.message_queue:
+            raise Exception("Message queue is not initialized")
+
+        message: ProxyMessageStructure = {
+            "requestId": str(uuid4()),
+            "targetId": self.subject,
+            "targetName": self.plugin["name"],
+            "pluginId": self.plugin["id"],
+            "type": "request",
+            "proxy": "device",
+            "client": "deviceFn",
+            "fn": fn,
+            "args": args,
+            "timestamp": int(datetime.now().timestamp() * 1000),
+            "timeout": 5000,
+        }
+
+        return await self.message_queue.enqueue(message)
+
+    async def __add_or_get_camera(self, camera_or_id: Union[Camera, str]) -> Optional[CameraDeviceProxy]:
+        camera_device: Optional[CameraDeviceProxy] = None
+
+        if isinstance(camera_or_id, str):
+            id = camera_or_id
+
+            camera_device: Optional[CameraDeviceProxy] = next(
+                (device for device in self.devices.values() if device.id == id or device.name == id),
+                None,
+            )
+        else:
+            camera = camera_or_id
+
+            if camera["_id"] in self.devices:
+                camera_device = self.devices[camera["_id"]]
+            else:
+                camera_device = CameraDeviceProxy(
+                    self.api,
+                    self.logger,
+                    camera,
+                    self.plugin,
+                    self.proxy_endpoints,
+                    self.auth,
+                )
+
+                self.devices[camera["_id"]] = camera_device
+
+        if camera_device:
+            await camera_device.init()
+
+        return camera_device
+
+    async def __close(self) -> None:
+        self.initialized = False
+        self.remove_all_listeners()
+        self.api.remove_listener("shutdown", self.__close)
+
+        if self.message_queue:
+            self.message_queue.abort_queue()
+
+        with suppress(Exception):
+            if self.publisher:
+                await self.publisher.close()
+
+            if self.dm_publisher:
+                await self.dm_publisher.close()

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

@@ -0,0 +1,213 @@
+import asyncio
+from contextlib import suppress
+from typing import Any, Callable, Union, cast
+
+from logger import PluginLogger
+from nats.aio.client import Client as NatsConnection
+from nats.aio.subscription import Subscription
+from plugins.constants import NATS_SERVER_SUBJECT
+from typings import ProxyMessageStructure, QueueItem, RemoteError
+from utilities.packer import pack, unpack
+from utilities.task import TaskSet
+
+
+class ClientMessageQueue:
+    def __init__(
+        self,
+        logger: PluginLogger,
+        publisher: NatsConnection,
+        subscriber: Subscription,
+        request_handler: Callable[[ProxyMessageStructure], Any],
+    ):
+        self.logger = logger
+        self.publisher = publisher
+        self.subscriber = subscriber
+        self.request_handler = request_handler
+
+        self.started = False
+        self.aborted = False
+        self.is_processing = False
+
+        self.tasks: TaskSet = TaskSet(f"ClientMessageQueue {self.publisher.options['name']}")
+        self.queue: list[QueueItem] = []
+        self.pending_responses: dict[str, QueueItem] = {}
+
+    async def start(self):
+        if self.started:
+            return
+
+        with suppress(asyncio.CancelledError):
+            self.started = True
+            await self.__listen_to_messages()
+
+    def abort_queue(self) -> None:
+        self.started = False
+        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 request 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:
+            # print(
+            #     "CLIENT => Sending reply to router:",
+            #     json.dumps(message, indent=4),
+            # )
+
+            await self.publisher.publish(
+                NATS_SERVER_SUBJECT,
+                pack(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 router:",
+            #     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,
+                pack(current_item["message"]),
+            )
+
+        self.is_processing = False
+
+    async def __listen_to_messages(self) -> None:
+        message: Union[ProxyMessageStructure, None] = None
+
+        async for msg in self.subscriber.messages:
+            try:
+                if self.aborted:
+                    break
+
+                if len(msg.data) == 0:
+                    continue
+
+                message = cast(ProxyMessageStructure, unpack(msg.data))
+
+                if message.get("type") == "reply":
+                    # print(
+                    #     "CLIENT => Received reply from router:",
+                    #     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)
+                        continue
+
+                    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 router:",
+                    #     json.dumps(message, indent=4),
+                    # )
+
+                    self.tasks.add(self.request_handler(message))
+                else:
+                    raise Exception("Invalid message type received")
+            except Exception as e:
+                if not self.aborted:
+                    self.logger.error("Error while processing request:", message, e)
+                else:
+                    break