@camera.ui/server 0.0.5 → 0.0.8

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

@@ -8,14 +8,13 @@ from asyncio import AbstractEventLoop
 from contextlib import suppress
 from typing import Any, Optional, cast
 
-import nats
 from camera_ui_types import CameraDevice
-from logger import PluginLogger
-from nats.aio.client import Client as NatsConnection
-from nats.aio.subscription import Subscription
+from decoder.typings import AuthConfig
+from message_queue import MessageQueue
+from nats.aio.msg import Msg
 from plugin_api import PluginAPI
+from plugin_logger import PluginLogger
 from proxy.camera_device import CameraDeviceProxy
-from proxy.message_queue import ClientMessageQueue
 from typings import (
     PLUGIN_COMMAND,
     PLUGIN_STATUS,
@@ -25,7 +24,9 @@ from typings import (
     ProcessResponse,
     ProxyMessageStructure,
 )
-from utilities.packer import pack, unpack
+from utilities.connection import ProxyConnection
+from utilities.packer import unpack
+from utilities.subscriptions import ProxySubscription
 from utilities.task import TaskSet
 
 
@@ -33,9 +34,9 @@ class PluginChild:
     def __init__(self) -> None:
         self.proxy_endpoints = [endpoint for endpoint in os.environ["PROXY_ENDPOINTS"].split(",")]
 
-        self.auth = {
+        self.auth: AuthConfig = {
             "user": os.environ["PROXY_USER"],
-            "pass": os.environ["PROXY_PASSWORD"],
+            "password": os.environ["PROXY_PASSWORD"],
         }
 
         del os.environ["PROXY_USER"]
@@ -49,12 +50,12 @@ class PluginChild:
         self.plugin_subject = f"{os.environ['PLUGIN_ID']}.child"
         self.target_subject = f"{os.environ['WORKER_ID']}.ipc.publisher"
 
-        self.publisher: Optional[NatsConnection] = None
-        self.subscriber: Optional[Subscription] = None
-        self.plugin_subscriber: Optional[Subscription] = None
+        self.publisher: Optional[ProxyConnection] = None
+        self.subscriber: Optional[ProxySubscription] = None
+        self.plugin_subscriber: Optional[ProxySubscription] = None
 
         self.tasks: TaskSet = TaskSet(f"{self.display_name} PluginChild")
-        self.message_queue: Optional[ClientMessageQueue] = None
+        self.message_queue: Optional[MessageQueue] = None
 
         self.api = None
         self.stopped = False
@@ -66,35 +67,22 @@ class PluginChild:
         await self.shutdown_event.wait()
 
     async def init(self) -> None:
-        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,
-        )
+        servers = [endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")]
+
+        self.publisher = ProxyConnection(self.subject, servers, self.auth)
+        await self.publisher.connect()
 
         self.subscriber = await self.publisher.subscribe(subject=self.subject)
-        self.plugin_subscriber = await self.publisher.subscribe(subject=self.plugin_subject)
+        self.subscriber.on("message", self.on_worker_message)
 
-        self.message_queue = ClientMessageQueue(
+        self.plugin_subscriber = await self.publisher.subscribe(subject=self.plugin_subject)
+        self.message_queue = MessageQueue(
             self.logger,
             self.publisher,
             self.plugin_subscriber,
             self.__request_handler,
         )
 
-        self.tasks.add(self.message_queue.start())
-        self.tasks.add(self.listen_to_messages())
-
         await self.send_message({"type": PLUGIN_STATUS.READY.value})
 
     async def start(self, data: ProcessLoadMessage) -> None:
@@ -104,9 +92,9 @@ class PluginChild:
         cameras = data["cameras"]
 
         self.api = PluginAPI(plugin, storage_path, config_file, self.logger, self.proxy_endpoints, self.auth)
-        await self.api.init()
+        await self.api.device_manager.init()
 
-        cameras = [
+        cameras_devices = [
             CameraDeviceProxy(
                 self.api,
                 self.logger,
@@ -118,10 +106,10 @@ class PluginChild:
             for camera in cameras
         ]
 
-        await asyncio.gather(*(camera.init() for camera in cameras))
+        await asyncio.gather(*(camera_device.init() for camera_device in cameras_devices))
 
-        self.api.device_manager.configure_cameras(cameras)
-        self.api.plugin.configure_cameras(cast(list[CameraDevice], cameras))
+        self.api.device_manager.configure_cameras(cameras_devices)
+        self.api.plugin.configure_cameras(cast(list[CameraDevice], cameras_devices))
 
         await self.send_message({"type": PLUGIN_STATUS.STARTED.value})
 
@@ -149,7 +137,7 @@ class PluginChild:
         if not self.publisher:
             raise Exception("Publisher is not initialized")
 
-        await self.publisher.publish(self.target_subject, pack(message))
+        await self.publisher.publish(self.target_subject, message)
 
     async def __request_handler(self, message: ProxyMessageStructure) -> None:
         if not self.message_queue:
@@ -198,30 +186,17 @@ class PluginChild:
 
             await self.message_queue.enqueue({**message, "type": "reply", "error": deserialized_error})
 
-    async def listen_to_messages(self) -> None:
-        if not self.subscriber:
-            raise Exception("Subscriber is not initialized")
-
-        async for msg in self.subscriber.messages:
-            try:
-                if self.stopped:
-                    break
-
-                if len(msg.data) == 0:
-                    continue
+    async def on_worker_message(self, msg: Msg) -> None:
+        if self.stopped:
+            return
 
-                message: ProcessMessage = unpack(msg.data)
+        message: ProcessMessage = unpack(msg.data)
 
-                if "type" in message:
-                    if message["type"] == PLUGIN_COMMAND.START.value and "data" in message:
-                        self.tasks.add(self.start(message["data"]))
-                    elif message["type"] == PLUGIN_COMMAND.STOP.value:
-                        self.tasks.add(self.stop())
-            except Exception as e:
-                if not self.stopped:
-                    self.logger.error("Error while processing server message:", e)
-                else:
-                    break
+        if "type" in message:
+            if message["type"] == PLUGIN_COMMAND.START.value and "data" in message:
+                self.tasks.add(self.start(message["data"]))
+            elif message["type"] == PLUGIN_COMMAND.STOP.value:
+                self.tasks.add(self.stop())
 
     def setup_signal_handlers(self):
         loop = asyncio.get_running_loop()

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

@@ -1,22 +1,22 @@
 import asyncio
-from contextlib import suppress
-from typing import Any, Callable, Union, cast
+from typing import Any, Callable, cast
 
-from logger import PluginLogger
-from nats.aio.client import Client as NatsConnection
-from nats.aio.subscription import Subscription
+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.packer import pack, unpack
+from utilities.connection import ProxyConnection
+from utilities.packer import unpack
+from utilities.subscriptions import ProxySubscription
 from utilities.task import TaskSet
 
 
-class ClientMessageQueue:
+class MessageQueue:
     def __init__(
         self,
         logger: PluginLogger,
-        publisher: NatsConnection,
-        subscriber: Subscription,
+        publisher: ProxyConnection,
+        subscriber: ProxySubscription,
         request_handler: Callable[[ProxyMessageStructure], Any],
     ):
         self.logger = logger
@@ -24,24 +24,16 @@ class ClientMessageQueue:
         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.tasks: TaskSet = TaskSet(f"MessageQueue {self.publisher.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()
+        self.subscriber.on("message", self.__on_message)
 
     def abort_queue(self) -> None:
-        self.started = False
         self.aborted = True
         self.is_processing = False
 
@@ -74,7 +66,7 @@ class ClientMessageQueue:
     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)
+            #     "CLIENT => Enqueueing message:", json.dumps(message, indent=4)
             # )
 
             promise = asyncio.get_event_loop().create_future()
@@ -92,15 +84,7 @@ class ClientMessageQueue:
 
             return await promise
         else:
-            # print(
-            #     "CLIENT => Sending reply to router:",
-            #     json.dumps(message, indent=4),
-            # )
-
-            await self.publisher.publish(
-                NATS_SERVER_SUBJECT,
-                pack(message),
-            )
+            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:
@@ -113,7 +97,7 @@ class ClientMessageQueue:
             request_id: str = current_item["message"].get("requestId", "")
 
             # print(
-            #     "CLIENT => Sending request to router:",
+            #     "CLIENT => Sending request to SERVER:",
             #     json.dumps(current_item["message"], indent=4),
             # )
 
@@ -157,57 +141,42 @@ class ClientMessageQueue:
                 "reject": reject,
             }
 
-            await self.publisher.publish(
-                NATS_SERVER_SUBJECT,
-                pack(current_item["message"]),
-            )
+            await self.publisher.publish(NATS_SERVER_SUBJECT, 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
+    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

@@ -9,7 +9,8 @@ from typing import Any, cast
 from camera_ui_types import BasePlugin
 from camera_ui_types import PluginAPI as IPluginAPI
 from config_service import PluginConfigService
-from logger import PluginLogger
+from decoder.typings import AuthConfig
+from plugin_logger import PluginLogger
 from pyeecui.asyncio import AsyncIOEventEmitter
 from typings import PluginInfo
 
@@ -22,7 +23,7 @@ class PluginAPI(AsyncIOEventEmitter):
         config_file: str,
         logger: PluginLogger,
         proxy_endpoints: list[str],
-        auth: dict[str, str],
+        auth: AuthConfig,
     ) -> None:
         super().__init__()
 
@@ -37,25 +38,13 @@ class PluginAPI(AsyncIOEventEmitter):
         self.config_file = config_file
 
         self.config_service = PluginConfigService(config_file)
-        self.storage_controller = StorageController(self, logger)
-
+        self.storage_controller = StorageController(self)
         self.device_manager = DeviceManager(self, logger, plugin, proxy_endpoints, auth)
 
-        module = self.__load_module()
-        plugin_class = self.__find_plugin_class(module)
-        self.__check_plugin_class_methods(plugin_class)
-
-        self.plugin: BasePlugin = plugin_class(logger, api_instance)
-
-    async def init(self) -> None:
-        if self.__initialized:
-            return
+        plugin_constructor = self.__load_module()
+        self.plugin: BasePlugin = plugin_constructor(logger, api_instance)
 
-        self.__initialized = True
-
-        await self.device_manager.init()
-
-    def __load_module(self) -> ModuleType:
+    def __load_module(self) -> Any:
         module_path = os.environ.get("MODULE_PATH")
 
         spec = importlib.util.spec_from_file_location("plugin_module", module_path)
@@ -70,9 +59,12 @@ class PluginAPI(AsyncIOEventEmitter):
 
         spec.loader.exec_module(module)
 
-        return module
+        plugin_constructor = self.__find_plugin_constructor(module)
+        self.__check_plugin_class_methods(plugin_constructor)
+
+        return plugin_constructor
 
-    def __find_plugin_class(self, module: ModuleType) -> Any:
+    def __find_plugin_constructor(self, module: ModuleType) -> Any:
         if hasattr(module, "__main__"):
             main_func = module.__main__
             if callable(main_func):
@@ -80,7 +72,7 @@ class PluginAPI(AsyncIOEventEmitter):
                 if isinstance(plugin_base_class, type):
                     return plugin_base_class
                 else:
-                    raise Exception("Plugin's __main__ must return a class plugin class")
+                    raise Exception("Plugin's __main__ must return a plugin constructor.")
             else:
                 raise Exception("Plugin's __main__ is not callable.")