@camera.ui/server 0.0.1

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

@@ -0,0 +1,267 @@
+import asyncio
+import inspect
+import os
+import signal
+import sys
+import traceback
+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 plugin_api import PluginAPI
+from proxy.camera_device import CameraDeviceProxy
+from proxy.message_queue import ClientMessageQueue
+from typings import (
+    PLUGIN_COMMAND,
+    PLUGIN_STATUS,
+    DeserializedError,
+    ProcessLoadMessage,
+    ProcessMessage,
+    ProcessResponse,
+    ProxyMessageStructure,
+)
+from utilities.packer import pack, unpack
+from utilities.task import TaskSet
+
+
+class PluginChild:
+    def __init__(self) -> None:
+        self.proxy_endpoints = [endpoint for endpoint in os.environ["PROXY_ENDPOINTS"].split(",")]
+
+        self.auth = {
+            "user": os.environ["PROXY_USER"],
+            "pass": os.environ["PROXY_PASSWORD"],
+        }
+
+        del os.environ["PROXY_USER"]
+        del os.environ["PROXY_PASSWORD"]
+        del os.environ["PROXY_ENDPOINTS"]
+
+        self.display_name = sys.argv[1] if len(sys.argv) > 1 else "PluginChild"
+        self.logger = PluginLogger(self.display_name, os.environ["LOGGER_DISABLE_TIMESTAMPS"] == "true")
+
+        self.subject = f"{os.environ['WORKER_ID']}.ipc.subscriber"
+        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.tasks: TaskSet = TaskSet(f"{self.display_name} PluginChild")
+        self.message_queue: Optional[ClientMessageQueue] = None
+
+        self.api = None
+        self.stopped = False
+
+    async def run(self):
+        self.shutdown_event = asyncio.Event()
+        self.setup_signal_handlers()
+        await self.init()
+        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,
+        )
+
+        self.subscriber = await self.publisher.subscribe(subject=self.subject)
+        self.plugin_subscriber = await self.publisher.subscribe(subject=self.plugin_subject)
+
+        self.message_queue = ClientMessageQueue(
+            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:
+        storage_path = data["storage"]["storagePath"]
+        config_file = data["storage"]["configFile"]
+        plugin = data["plugin"]
+        cameras = data["cameras"]
+
+        self.api = PluginAPI(plugin, storage_path, config_file, self.logger, self.proxy_endpoints, self.auth)
+        await self.api.init()
+
+        cameras = [
+            CameraDeviceProxy(
+                self.api,
+                self.logger,
+                camera,
+                plugin,
+                self.proxy_endpoints,
+                self.auth,
+            )
+            for camera in cameras
+        ]
+
+        await asyncio.gather(*(camera.init() for camera in cameras))
+
+        self.api.device_manager.configure_cameras(cameras)
+        self.api.plugin.configure_cameras(cast(list[CameraDevice], cameras))
+
+        await self.send_message({"type": PLUGIN_STATUS.STARTED.value})
+
+        self.api.emit("finishLaunching")
+
+    async def stop(self) -> None:
+        if self.stopped:
+            return
+
+        self.stopped = True
+
+        if self.message_queue:
+            self.message_queue.abort_queue()
+
+        if self.publisher:
+            with suppress(Exception):
+                await self.publisher.close()
+
+        if self.api:
+            self.api.emit("shutdown")
+
+        self.shutdown_event.set()
+
+    async def send_message(self, message: ProcessResponse) -> None:
+        if not self.publisher:
+            raise Exception("Publisher is not initialized")
+
+        await self.publisher.publish(self.target_subject, pack(message))
+
+    async def __request_handler(self, message: ProxyMessageStructure) -> None:
+        if not self.message_queue:
+            raise Exception("Message queue not initialized")
+
+        try:
+            plugin = None
+
+            if self.api:
+                plugin = self.api.plugin
+
+            if not plugin or not self.api:
+                raise Exception("Plugin not initialized")
+
+            fn = message["fn"]
+            args = message["args"]
+            camera_id = message.get("cameraId", None)
+            camera_storage = self.api.storage_controller.get_camera_storage(camera_id or "")
+
+            if hasattr(plugin, fn) and callable(getattr(plugin, fn)):
+                method_to_call = getattr(plugin, fn)
+
+                if inspect.iscoroutinefunction(method_to_call):
+                    response = await method_to_call(*args)
+                else:
+                    response = method_to_call(*args)
+
+                await self.message_queue.enqueue({**message, "type": "reply", "response": response})
+            elif camera_storage and hasattr(camera_storage, fn) and callable(getattr(camera_storage, fn)):
+                method_to_call = getattr(camera_storage, fn)
+
+                if inspect.iscoroutinefunction(method_to_call):
+                    response = await method_to_call(*args)
+                else:
+                    response = method_to_call(*args)
+
+                await self.message_queue.enqueue({**message, "type": "reply", "response": response})
+            else:
+                await self.message_queue.enqueue({**message, "type": "reply"})
+        except Exception as e:
+            deserialized_error: DeserializedError = {
+                "name": type(e).__name__,
+                "message": str(e),
+                "stack": traceback.format_exc(),
+            }
+
+            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
+
+                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
+
+    def setup_signal_handlers(self):
+        loop = asyncio.get_running_loop()
+        loop.set_exception_handler(self.handle_exception)
+
+        for signame in ("SIGINT", "SIGTERM"):
+            loop.add_signal_handler(
+                getattr(signal, signame),
+                lambda signame=signame: self.gracefully_close(signame, getattr(signal, signame)),
+            )
+
+    def gracefully_close(self, signame: str, reason: Any = "unknown"):
+        if self.stopped:
+            return
+
+        self.logger.log(
+            f"{self.display_name} is gracefully closing from signal='{signame}' reason='{reason}'..."
+        )
+
+        self.tasks.add(self.stop())
+        self.shutdown_event.set()
+
+    def handle_exception(self, loop: AbstractEventLoop, context: Any):
+        print("Exception context:", context)
+        traceback.print_exc()
+
+        msg = context.get("message", "Unknown error")
+        exception = context.get("exception")
+
+        if exception:
+            tb_str = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))  # type: ignore
+
+            self.logger.error(f"Caught exception: {msg}\n{tb_str}")
+        else:
+            self.logger.error(f"Caught exception: {msg}")
+
+        if loop.is_running():
+            self.gracefully_close("uncaughtException", msg)
+
+
+if __name__ == "__main__":
+    plugin_child = PluginChild()
+    asyncio.run(plugin_child.run(), debug=True)

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

@@ -0,0 +1,180 @@
+import json
+import os
+from typing import Any, Callable, Optional
+
+from camera_ui_types import JSONValue, PluginConfig
+from utilities.object_path import ObjectPath, Path
+
+
+class PluginConfigService:
+    def __init__(self, config_file: str):
+        self.__config_file = config_file
+        self.__config: PluginConfig = {}
+        self.__init()
+
+    def get(
+        self,
+        key: Path,
+        default_value: Optional[JSONValue] = None,
+        validate: Optional[Callable[[Any], bool]] = None,
+        refresh: bool = False,
+        write_if_not_valid: bool = False,
+    ) -> Any:
+        if refresh:
+            self.__read()
+
+        val = ObjectPath.get(self.__config, key, default_value)
+
+        if validate and default_value is not None:
+            is_valid = validate(val)
+
+            if not is_valid:
+                self.set(key, default_value, write_if_not_valid)
+
+        return val
+
+    def has(self, key: Path, refresh: bool = False) -> bool:
+        if refresh:
+            self.__read()
+
+        return ObjectPath.has(self.__config, key)
+
+    def ensure_exists(self, key: Path, default_value: JSONValue, write: bool = False) -> None:
+        exists = self.has(key)
+
+        ObjectPath.ensure_exists(self.__config, key, default_value)
+
+        if write and not exists:
+            self.__write()
+
+    def set(self, key: Path, value: Any, write: bool = False) -> None:
+        ObjectPath.set(self.__config, key, value)
+
+        if write:
+            self.__write()
+
+    def insert(self, key: Path, value: Any, at: int = 0, write: bool = False) -> None:
+        ObjectPath.insert(self.__config, key, value, at)
+
+        if write:
+            self.__write()
+
+    def push(self, key: Path, write: bool = False, *items: Any) -> None:
+        ObjectPath.push(self.__config, key, *items)
+
+        if write:
+            self.__write()
+
+    def delete(self, key: Path, write: bool = False) -> None:
+        ObjectPath.delete(self.__config, key)
+
+        if write:
+            self.__write()
+
+    def all(self, refresh: bool = False) -> PluginConfig:
+        if refresh:
+            self.__read()
+
+        return self.__config.copy()
+
+    def replace(self, config: PluginConfig, write: bool = False) -> None:
+        self.__config = config
+
+        if write:
+            self.__write()
+
+    def update_value(
+        self,
+        path: str,
+        search_key: str,
+        search_value: Any,
+        target_key: str,
+        new_value: Any,
+        write: bool = False,
+    ) -> None:
+        path_segments = path.split(".")
+
+        def update_recursive(obj: Any, index: int) -> None:
+            if index == len(path_segments):
+                if obj.get(search_key) == search_value:
+                    obj[target_key] = new_value
+                return
+
+            current_path = path_segments[index]
+
+            if isinstance(obj.get(current_path), list):
+                for element in obj[current_path]:
+                    update_recursive(element, index + 1)
+            elif obj.get(current_path) is not None:
+                update_recursive(obj[current_path], index + 1)
+
+        update_recursive(self.__config, 0)
+
+        self.set(path_segments[0], self.__config[path_segments[0]], write)
+
+    def replace_or_add_item(
+        self,
+        path: str,
+        search_key: str,
+        search_value: Any,
+        new_item: Any,
+        write: bool = False,
+    ) -> None:
+        path_segments = path.split(".")
+
+        def ensure_path_exists(obj: Any, path_segments: list[str], index: int) -> None:
+            if index >= len(path_segments):
+                return
+
+            current_path = path_segments[index]
+
+            if obj.get(current_path) is None:
+                obj[current_path] = [] if index == len(path_segments) - 1 else {}
+
+            ensure_path_exists(obj[current_path], path_segments, index + 1)
+
+        def find_and_replace_or_add_recursive(obj: Any, path_index: int) -> None:
+            if isinstance(obj, list):
+                o: list[Any] = obj
+                for sub_obj in o:
+                    find_and_replace_or_add_recursive(sub_obj, path_index)
+            else:
+                current_path = path_segments[path_index]
+                if path_index == len(path_segments) - 1:
+                    if isinstance(obj.get(current_path), list):
+                        item_index = next(
+                            (
+                                index
+                                for index, item in enumerate(obj[current_path])
+                                if item.get(search_key) == search_value
+                            ),
+                            -1,
+                        )
+                        if item_index != -1:
+                            obj[current_path][item_index] = new_item
+                        else:
+                            obj[current_path].append(new_item)
+                elif obj.get(current_path) is not None:
+                    find_and_replace_or_add_recursive(obj[current_path], path_index + 1)
+
+        ensure_path_exists(self.__config, path_segments, 0)
+        find_and_replace_or_add_recursive(self.__config, 0)
+
+        self.set(path_segments[0], self.__config[path_segments[0]], write)
+
+    def __init(self) -> None:
+        os.makedirs(os.path.dirname(self.__config_file), exist_ok=True)
+        self.__read()
+
+    def __read(self) -> None:
+        try:
+            with open(self.__config_file) as file:
+                config = json.load(file)
+        except (FileNotFoundError, json.JSONDecodeError):
+            config = {}
+
+        self.__config = config or self.__config or {}
+
+    def __write(self) -> None:
+        with open(self.__config_file, "w") as file:
+            json.dump(self.__config, file, indent=2)

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

@@ -0,0 +1,2 @@
+NATS_SERVER_SUBJECT = "camera.ui-server"
+NATS_SIGNALING_SUBJECT = "camera.ui-signaling"

package/dist/server/src/polyglot/python/plugins/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"

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

@@ -0,0 +1,114 @@
+import importlib.util
+
+# import inspect
+import os
+import sys
+from types import ModuleType
+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 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: dict[str, str],
+    ) -> None:
+        super().__init__()
+
+        from proxy.device_manager import DeviceManager
+        from storage_controller import StorageController
+
+        api_instance = cast(IPluginAPI, self)
+
+        self.__initialized = False
+
+        self.storage_path = storage_path
+        self.config_file = config_file
+
+        self.config_service = PluginConfigService(config_file)
+        self.storage_controller = StorageController(self, logger)
+
+        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
+
+        self.__initialized = True
+
+        await self.device_manager.init()
+
+    def __load_module(self) -> ModuleType:
+        module_path = os.environ.get("MODULE_PATH")
+
+        spec = importlib.util.spec_from_file_location("plugin_module", module_path)
+        if spec is None:
+            raise Exception(f"Could not load module from '{module_path}'.")
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules["plugin_module"] = module
+
+        if spec.loader is None:
+            raise Exception(f"Could not load module from '{module_path}'.")
+
+        spec.loader.exec_module(module)
+
+        return module
+
+    def __find_plugin_class(self, module: ModuleType) -> Any:
+        if hasattr(module, "__main__"):
+            main_func = module.__main__
+            if callable(main_func):
+                plugin_base_class: BasePlugin = main_func()
+                if isinstance(plugin_base_class, type):
+                    return plugin_base_class
+                else:
+                    raise Exception("Plugin's __main__ must return a class plugin class")
+            else:
+                raise Exception("Plugin's __main__ is not callable.")
+
+        else:
+            raise Exception("Plugin does not have a __main__ function.")
+
+    def __check_plugin_class_methods(self, cls: Any) -> None:
+        base_plugin_methods = {
+            name
+            for name in dir(BasePlugin)
+            if callable(getattr(BasePlugin, name)) and not name.startswith("__")
+        }
+
+        for method_name in base_plugin_methods:
+            if not hasattr(cls, method_name):
+                raise Exception(f"Method '{method_name}' is not implemented in plugin.")
+
+            cls_method = getattr(cls, method_name)
+            if not callable(cls_method):
+                raise Exception(f"Method '{method_name}' is not callable.")
+
+            # base_method = getattr(BasePlugin, method_name)
+            # cls_signature = inspect.signature(cls_method)
+            # base_signature = inspect.signature(base_method)
+
+            # if cls_signature.return_annotation != base_signature.return_annotation:
+            #     raise Exception(
+            #         f"Method '{method_name}' has a different return type than the one in BasePlugin. "
+            #         f"Expected: {base_signature.return_annotation}, "
+            #         f"Actual: {cls_signature.return_annotation}"
+            #     )