camera.ui3 0.0.30-alpha.0

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

@@ -0,0 +1,394 @@
+import asyncio
+import importlib.util
+import inspect
+import os
+import signal
+import sys
+import traceback
+from asyncio import AbstractEventLoop
+from contextlib import suppress
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Literal, Optional, cast
+
+from camera_ui_types import BasePlugin, CameraDevice
+from decoder.typings import AuthConfig
+from lmdbm import Lmdb
+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 typings import (
+    PLUGIN_COMMAND,
+    PLUGIN_STATUS,
+    DeserializedError,
+    ProcessLoadMessage,
+    ProcessMessage,
+    ProcessResponse,
+    ProxyMessageStructure,
+)
+from utilities.connection import ProxyConnection
+from utilities.json_lmdb import JsonLmdb
+from utilities.packer import unpack
+from utilities.subscriptions import ProxySubscription
+from utilities.task import TaskSet
+
+if sys.platform == "win32":
+    import ctypes
+
+    def force_exit():
+        kernel32 = ctypes.windll.kernel32
+        kernel32.TerminateProcess(kernel32.GetCurrentProcess(), 1)
+else:
+
+    def force_exit():
+        os.kill(os.getpid(), signal.SIGKILL)
+
+
+def find_plugin_constructor(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 plugin constructor.")
+        else:
+            raise Exception("Plugin's __main__ is not callable.")
+
+    else:
+        raise Exception("Plugin does not have a __main__ function.")
+
+
+def check_plugin_class_methods(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}"
+        #     )
+
+
+class PluginChild:
+    def __init__(self) -> None:
+        self.proxy_endpoints = [endpoint for endpoint in os.environ["PROXY_ENDPOINTS"].split(",")]
+
+        self.auth: AuthConfig = {
+            "user": os.environ["PROXY_USER"],
+            "password": 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.plugin_db: Optional[Lmdb[Literal["config"], dict[str, Any]]] = None
+
+        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[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[MessageQueue] = None
+
+        self.api: Optional[PluginAPI] = None
+        self.plugin: Optional[BasePlugin] = None
+
+        self.stopped = False
+        self.closed = False
+
+    async def run(self):
+        try:
+            self.shutdown_event = asyncio.Event()
+            self.setup_signal_handlers()
+            await self.init()
+            await self.shutdown_event.wait()
+        except asyncio.CancelledError:
+            pass
+
+    async def init(self) -> None:
+        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.subscriber.on("message", self.on_worker_message)
+
+        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,
+        )
+
+        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_info = data["plugin"]
+        cameras = data["cameras"]
+
+        db_path = Path(storage_path) / "volume"
+        Path(db_path).mkdir(parents=True, exist_ok=True)
+
+        self.plugin_db = JsonLmdb.open(file=str(db_path), flag="c")
+
+        config: Any = self.plugin_db.get("config")
+        if config is None:
+            self.plugin_db.update({"config": {}})
+
+        self.api = PluginAPI(
+            plugin_info,
+            storage_path,
+            config_file,
+            self.logger,
+            self.proxy_endpoints,
+            self.auth,
+            self.plugin_db,
+        )
+
+        plugin_constructor = self.load_plugin()
+        self.plugin = cast(BasePlugin, plugin_constructor(self.logger, self.api))
+
+        await asyncio.gather(
+            self.api.core_manager.init(),
+            self.api.device_manager.init(),
+        )
+
+        cameras_devices = [
+            CameraDeviceProxy(
+                self.api,
+                self.logger,
+                camera,
+                plugin_info,
+                self.proxy_endpoints,
+                self.auth,
+            )
+            for camera in cameras
+        ]
+
+        await asyncio.gather(*(camera_device.init() for camera_device in cameras_devices))
+
+        self.api.device_manager.configure_cameras(cameras_devices)
+        self.plugin.configure_cameras(cast(list[CameraDevice], cameras_devices))
+
+        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.api:
+            self.api.emit("shutdown")
+
+        if self.message_queue:
+            self.message_queue.abort_queue()
+
+        if self.publisher:
+            with suppress(Exception):
+                await self.publisher.close()
+
+        if self.plugin_db:
+            await asyncio.sleep(0.5)
+            with suppress(Exception):
+                self.plugin_db.close()
+
+        self.shutdown_event.set()
+
+    def load_plugin(self) -> Any:
+        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)
+
+        plugin_constructor = find_plugin_constructor(module)
+
+        check_plugin_class_methods(plugin_constructor)
+
+        return plugin_constructor
+
+    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, message)
+
+    async def request_handler(self, message: ProxyMessageStructure) -> None:
+        if not self.message_queue:
+            raise Exception("Message queue not initialized")
+
+        reply = message.copy()
+        reply["type"] = "reply"
+
+        try:
+            if not self.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(self.plugin, fn) and callable(getattr(self.plugin, fn)):
+                method_to_call = getattr(self.plugin, fn)
+
+                if inspect.iscoroutinefunction(method_to_call):
+                    reply["response"] = await method_to_call(*args)
+                else:
+                    reply["response"] = method_to_call(*args)
+            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):
+                    reply["response"] = await method_to_call(*args)
+                else:
+                    reply["response"] = method_to_call(*args)
+            else:
+                raise Exception(f"Unknown function: {fn}")
+        except Exception as e:
+            deserialized_error: DeserializedError = {
+                "name": type(e).__name__,
+                "message": str(e),
+                "stack": traceback.format_exc(),
+            }
+
+            reply["error"] = deserialized_error
+
+        if message["timeout"] == 0:
+            return
+        else:
+            await self.message_queue.enqueue(reply)
+
+    async def on_worker_message(self, msg: Msg) -> None:
+        if self.stopped:
+            return
+
+        message: ProcessMessage = unpack(msg.data)
+
+        if "type" in message:
+            if message["type"] == PLUGIN_COMMAND.START.value and "data" in message:
+                await self.start(message["data"])
+            elif message["type"] == PLUGIN_COMMAND.STOP.value:
+                await self.stop()
+
+    async def gracefully_close(self, signame: str, reason: Any = "unknown"):
+        if self.stopped or self.closed:
+            return
+
+        self.closed = True
+
+        self.logger.log(
+            f"{self.display_name} is gracefully closing from signal='{signame}' reason='{reason}'..."
+        )
+
+        try:
+            stop_task = asyncio.create_task(self.stop(), name=f"{self.display_name} Stop")
+            await asyncio.wait_for(stop_task, timeout=2)
+            self.force_exit()
+        except asyncio.TimeoutError:
+            self.logger.warn("Failed to gracefully close before timeout, force quit!")
+            self.force_exit()
+
+    def setup_signal_handlers(self):
+        loop = asyncio.get_running_loop()
+        loop.set_exception_handler(self.handle_exception)
+
+        if sys.platform == "win32":
+            try:
+                from win32api import SetConsoleCtrlHandler
+
+                def handler(ctrl_type: int) -> bool:
+                    if ctrl_type in (0, 1, 2):  # CTRL_C_EVENT, CTRL_BREAK_EVENT, CTRL_CLOSE_EVENT
+                        asyncio.create_task(self.gracefully_close("SIGINT"))
+                        return True
+                    return False
+
+                SetConsoleCtrlHandler(handler, True)
+            except ImportError:
+                # self.logger.warn("win32api not available, falling back to limited signal support")
+                self.setup_limited_signal_handlers(loop)
+
+    def setup_limited_signal_handlers(self, loop: AbstractEventLoop):
+        for signame in ("SIGINT", "SIGTERM"):
+            try:  # noqa: SIM105
+                loop.add_signal_handler(
+                    getattr(signal, signame),
+                    lambda signame=signame: asyncio.create_task(self.gracefully_close(signame)),
+                )
+            except NotImplementedError:
+                # self.logger.warn(f"Signal {signame} is not supported on this platform")
+                pass
+
+    def force_exit(self):
+        if sys.platform == "win32":
+            # Windows-spezifisches Beenden
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            kernel32.TerminateProcess(kernel32.GetCurrentProcess(), 1)
+        else:
+            # Unix-basiertes Beenden
+            os.kill(os.getpid(), signal.SIGKILL)
+
+    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():
+            asyncio.create_task(self.gracefully_close("uncaughtException", msg))
+
+
+if __name__ == "__main__":
+    plugin_child = PluginChild()
+    asyncio.run(plugin_child.run())
+    # asyncio.run(plugin_child.run(), debug=True)

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

@@ -0,0 +1,187 @@
+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:
+        directory = os.path.dirname(self.__config_file)
+
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+
+        if not os.path.exists(self.__config_file):
+            open(self.__config_file, "a").close()
+
+        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 @@
+NATS_SERVER_SUBJECT = "camera.ui-server"