@camera.ui/server 0.0.6 → 0.0.8

package/dist/server/src/polyglot/python/camera/video_frame.py

@@ -10,18 +10,16 @@ from camera_ui_types import (
     ImageOptions,
     MotionState,
 )
-from nats.aio.client import Client as NatsConnection
-from nats.aio.msg import Msg
 from PIL import Image
 from plugins.typings import ProcessPrebufferedImageRequest
-from utilities.packer import pack
+from utilities.connection import ProxyConnection
 
 
 class VideoFrame:
     def __init__(
         self,
         camera_id: str,
-        publisher: NatsConnection,
+        publisher: ProxyConnection,
         frame_data: FrameData,
         metadata: FrameMetadata,
         prebuffer_duration: int,
@@ -57,10 +55,10 @@ class VideoFrame:
         options = self.__validate_options("buffer", options)
         image_information = self.__get_image_information(options)
 
-        response = await self.__send(options)
+        data = await self.__send(options)
 
         return {
-            "image": response.data,
+            "image": data,
             "info": image_information,
         }
 
@@ -76,12 +74,10 @@ class VideoFrame:
             else "RGB"
         )
 
-        response = await self.__send(options)
+        data = await self.__send(options)
 
         return {
-            "image": Image.frombytes(
-                mode, (image_information["width"], image_information["height"]), response.data
-            ),
+            "image": Image.frombytes(mode, (image_information["width"], image_information["height"]), data),
             "info": image_information,
         }
 
@@ -90,8 +86,8 @@ class VideoFrame:
         image["image"].save(path)
         image["image"].close()
 
-    async def __send(self, options: ImageOptions) -> Msg:
-        if not self.__publisher or not self.__publisher.is_connected:
+    async def __send(self, options: ImageOptions) -> bytes:
+        if not self.__publisher:
             raise Exception("Frame generator closed?")
 
         request: ProcessPrebufferedImageRequest = {
@@ -101,11 +97,7 @@ class VideoFrame:
             "prebufferDuration": self.__prebuffer_duration,
         }
 
-        return await self.__publisher.request(
-            self.__frame_generator_subject,
-            pack(request),
-            10000,
-        )
+        return await self.__publisher.request(self.__frame_generator_subject, request, 10000)
 
     def __validate_options(
         self,
@@ -183,7 +175,7 @@ class MotionFrame(VideoFrame):
     def __init__(
         self,
         camera_id: str,
-        publisher: NatsConnection,
+        publisher: ProxyConnection,
         frame_data: FrameData,
         motion_state: MotionState,
         metadata: FrameMetadata,

package/dist/server/src/polyglot/python/camera_ui_types/__init__.py

@@ -646,9 +646,6 @@ class CameraDelegate(metaclass=ABCMeta):
     @abstractmethod
     async def snapshot(self) -> bytes: ...
 
-    @abstractmethod
-    async def reboot(self) -> None: ...
-
 
 CameraDelegateMethodNames = Literal["reboot", "snapshot"]
 
@@ -836,8 +833,7 @@ class CameraDevice(Protocol):
     mid_resolution_source: Optional[CameraSource]
     low_resolution_source: Optional[CameraSource]
 
-    cameraDelegate: CameraDelegate
-    ptzDelegate: CameraPTZDelegate
+    ptz: CameraPTZDelegate
 
     @overload
     def set_delegate(self, name: Literal["cameraDelegate"], delegate: CameraDelegate) -> None: ...

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

@@ -9,14 +9,11 @@ from contextlib import suppress
 from datetime import datetime
 from typing import Any, Literal, Optional, Union, cast
 
-import nats
 from camera_ui_types import DecoderFormat, FrameData, FrameMetadata, ImageOptions
 from image_utils import process_image_threaded
-from nats.aio.client import Client as NatsConnection
 from nats.aio.msg import Msg
-from nats.aio.subscription import Subscription
 from nats.errors import NoRespondersError, TimeoutError
-from plugins.logger import PluginLogger
+from plugins.plugin_logger import PluginLogger
 from plugins.typings import ProcessPrebufferedImageRequest
 from typings import (
     BaseFrameWorkerConfig,
@@ -35,7 +32,9 @@ from typings import (
     WorkerToMainMessage,
     WorkerToMainResponse,
 )
+from utilities.connection import ProxyConnection
 from utilities.packer import pack, unpack
+from utilities.subscriptions import ProxySubscription
 from utilities.task import TaskSet
 
 config: BaseFrameWorkerConfig = {
@@ -73,14 +72,14 @@ class FrameWorkerChild:
         self.signaling_subject = f"{config['cameraId']}.frameGenerator.signaling"
         self.frame_subject = f"{config['cameraId']}.frameReceiver"
 
-        self.publisher: Optional[NatsConnection] = None
-        self.signaling_publisher: Optional[NatsConnection] = None
-        self.image_publisher: Optional[NatsConnection] = None
-        self.frame_publisher: Optional[NatsConnection] = None
+        self.publisher: Optional[ProxyConnection] = None
+        self.signaling_publisher: Optional[ProxyConnection] = None
+        self.image_publisher: Optional[ProxyConnection] = None
+        self.frame_publisher: Optional[ProxyConnection] = None
 
-        self.subscriber: Optional[Subscription] = None
-        self.image_subscriber: Optional[Subscription] = None
-        self.signal_subscriber: Optional[Subscription] = None
+        self.subscriber: Optional[ProxySubscription] = None
+        self.image_subscriber: Optional[ProxySubscription] = None
+        self.signal_subscriber: Optional[ProxySubscription] = None
 
         self.max_diff_frame = 3
         self.restart_delay = 5
@@ -105,6 +104,12 @@ class FrameWorkerChild:
         self.stdout_task: Optional[asyncio.Task[None]] = None
         self.close_task: Optional[asyncio.Task[None]] = None
 
+        self.restart_timeout: Optional[asyncio.TimerHandle] = None
+        self.restart_delay = 10
+
+        self.close_timeout: Optional[asyncio.TimerHandle] = None
+        self.close_delay = 5
+
     @property
     def log_prefix(self) -> str:
         return f"{self.camera_name}:"
@@ -119,72 +124,30 @@ class FrameWorkerChild:
     async def listen(self) -> None:
         self.setup_signal_handlers()
 
-        async def ignore_cb(e: Optional[Any] = None):
-            pass
+        servers = [endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")]
 
-        self.publisher = await nats.connect(
-            servers=[endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")],
-            name=self.subject,
-            user=config["auth"]["user"],
-            password=config["auth"]["password"],
-            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.publisher = ProxyConnection(self.subject, servers, config["auth"])
+        await self.publisher.connect()
 
-        self.image_publisher = await nats.connect(
-            servers=[endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")],
-            name=self.image_subject,
-            user=config["auth"]["user"],
-            password=config["auth"]["password"],
-            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.image_publisher = ProxyConnection(self.image_subject, servers, config["auth"])
+        await self.image_publisher.connect()
 
-        self.frame_publisher = await nats.connect(
-            servers=[endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")],
-            name=self.frame_subject,
-            user=config["auth"]["user"],
-            password=config["auth"]["password"],
-            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.frame_publisher = ProxyConnection(self.frame_subject, servers, config["auth"])
+        await self.frame_publisher.connect()
 
-        self.signaling_publisher = await nats.connect(
-            servers=[endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")],
-            name=self.signaling_subject,
-            user=config["auth"]["user"],
-            password=config["auth"]["password"],
-            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.signaling_publisher = ProxyConnection(self.signaling_subject, servers, config["auth"])
+        await self.signaling_publisher.connect()
 
         self.subscriber = await self.publisher.subscribe(subject=self.subject)
+        self.subscriber.on("message", self.on_worker_message)
+
         self.image_subscriber = await self.image_publisher.subscribe(subject=self.image_subject)
-        self.signal_subscriber = await self.signaling_publisher.subscribe(subject=self.signaling_subject)
+        self.image_subscriber.on("message", self.on_image_request)
 
-        await asyncio.gather(
-            self.send("started"),
-            self.listen_to_ipc_messages(),
-            self.listen_to_signaling_messages(),
-            self.listen_to_prebuffered_image_messages(),
-        )
+        self.signal_subscriber = await self.signaling_publisher.subscribe(subject=self.signaling_subject)
+        self.signal_subscriber.on("message", self.on_signaling_message)
 
+        await self.send("started")
         await self.shutdown_event.wait()
 
     async def close(self) -> None:
@@ -209,13 +172,14 @@ class FrameWorkerChild:
     async def start(self) -> None:
         try:
             self.closed = False
+
+            if self.close_timeout:
+                self.close_timeout.cancel()
+                self.close_timeout = None
+
             await self.start_video_session()
         except Exception as e:
-            self.logger.error(
-                f"{self.log_prefix} An error occurred while starting frame session:",
-                e,
-            )
-
+            self.logger.error(f"{self.log_prefix} An error occurred while starting frame session:", e)
             await self.restart_ffmpeg()
 
     async def stop(self) -> None:
@@ -237,6 +201,14 @@ class FrameWorkerChild:
         self._metadata = None
 
     async def reset_video_session(self) -> None:
+        if self.close_timeout:
+            self.close_timeout.cancel()
+            self.close_timeout = None
+
+        if self.restart_timeout:
+            self.restart_timeout.cancel()
+            self.restart_timeout = None
+
         if self.stderr_task:
             self.stderr_task.cancel()
             self.stderr_task = None
@@ -256,8 +228,7 @@ class FrameWorkerChild:
             self.ffmpeg_process = None
 
     async def start_video_session(self) -> None:
-        if self.ffmpeg_process:
-            return
+        await self.reset_video_session()
 
         # await self.reset()
         self.stopped = False
@@ -267,9 +238,6 @@ class FrameWorkerChild:
             await asyncio.wait_for(self.metadata_event.wait(), timeout=15)
             self.logger.debug(f"{self.log_prefix} Frame session started")
         except asyncio.TimeoutError:
-            ffmpeg_process = cast(Optional[asyncio.subprocess.Process], self.ffmpeg_process)
-            if ffmpeg_process and ffmpeg_process.returncode is None:
-                ffmpeg_process.kill()
             raise Exception("FFmpeg process timed out") from None
 
     def build_ffmpeg_args(self, ffmpeg_path: str, camera_source: str, ffmpeg_args: FfmpegArgs) -> list[str]:
@@ -335,7 +303,7 @@ class FrameWorkerChild:
         self.close_task = self.tasks.add(self.handle_ffmpeg_close())
 
     async def restart_ffmpeg(self) -> None:
-        if not self.stopped and not self.closed and not self.restarting:
+        if not self.stopped and not self.closed and not self.restarting and len(self.clients) > 0:
             self.restarting = True
 
             self.logger.log(f"{self.log_prefix} Restarting FFmpeg process in {self.restart_delay} seconds...")
@@ -343,7 +311,7 @@ class FrameWorkerChild:
             with suppress(asyncio.TimeoutError):
                 await asyncio.wait_for(asyncio.sleep(self.restart_delay), timeout=self.restart_delay)
 
-            if not self.stopped and not self.closed:
+            if not self.stopped and not self.closed and len(self.clients) > 0:
                 await self.start()
 
             self.restarting = False
@@ -392,32 +360,40 @@ class FrameWorkerChild:
     async def handle_ffmpeg_stdout(self) -> None:
         try:
             metadata = (await self.metadata).copy()
-            restart_timeout = None
+            warned = False
 
             def is_closed() -> bool:
                 return (
                     self.stopped
                     or self.closed
                     or not self.frame_publisher
-                    or self.frame_publisher.is_closed
                     or not self.ffmpeg_process
                     or not self.ffmpeg_process.stdout
                     or self.ffmpeg_process.returncode is not None
                 )
 
+            def reset_restart_watchdog():
+                if self.restart_timeout:
+                    self.restart_timeout.cancel()
+                self.restart_timeout = None
+
             def restart_watchdog():
-                nonlocal restart_timeout
-                if restart_timeout:
-                    restart_timeout.cancel()
-                restart_timeout = asyncio.get_event_loop().call_later(
-                    3, lambda: asyncio.create_task(restart_ffmpeg())
+                reset_restart_watchdog()
+                self.restart_timeout = asyncio.get_event_loop().call_later(
+                    self.restart_delay, lambda: asyncio.create_task(restart_ffmpeg())
                 )
 
             async def restart_ffmpeg():
                 if not self.stopped and not self.closed and not self.restarting:
-                    self.logger.error(
-                        f"{self.log_prefix} FFmpeg process is not producing frames, restarting..."
-                    )
+                    message = "FFmpeg process is not producing frames, terminating..."
+
+                    nonlocal warned
+                    if warned is False:
+                        self.logger.debug(f"{self.log_prefix} {message}")
+                        warned = True
+                    else:
+                        self.logger.error(f"{self.log_prefix} {message}")
+
                     await self.reset()
                     await self.restart_ffmpeg()
 
@@ -429,7 +405,10 @@ class FrameWorkerChild:
                         int(metadata["frameSize"]),
                     )
 
+                    warned = False
+
                     if is_closed():
+                        reset_restart_watchdog()
                         break
 
                     frame_id = self.generate_id()
@@ -459,7 +438,7 @@ class FrameWorkerChild:
                     if self.prebuffer_full:
                         frame_data: FrameData = {"frameId": frame_id, "timestamp": now}
 
-                        await self.frame_publisher.publish(self.frame_subject, pack(frame_data))  # type: ignore
+                        await self.frame_publisher.publish(self.frame_subject, frame_data)  # type: ignore
 
                 except asyncio.IncompleteReadError as e:
                     if not is_closed() and not self.restarting:
@@ -473,6 +452,8 @@ class FrameWorkerChild:
                             e,
                         )
                     break
+                finally:
+                    reset_restart_watchdog()
         except asyncio.CancelledError:
             pass
 
@@ -480,9 +461,6 @@ class FrameWorkerChild:
         try:
             if self.ffmpeg_process:
                 code = await self.ffmpeg_process.wait()
-                self.ffmpeg_process = None
-
-                await self.reset()
 
                 if code != 0 and code != -9 or not self.stopped:
                     self.logger.error(
@@ -494,6 +472,9 @@ class FrameWorkerChild:
                         f"{self.log_prefix} FFmpeg process has exited with code {code} (expected)"
                     )
 
+                self.ffmpeg_process = None
+
+                await self.reset()
                 await self.restart_ffmpeg()
         except asyncio.CancelledError:
             pass
@@ -547,14 +528,10 @@ class FrameWorkerChild:
             "data": data,
         }
 
-        msg = await self.publisher.request(
-            self.ipc_subject,
-            pack(worker_message),
-            timeout=30,
+        response: MainToWorkerResponse = await self.publisher.request(
+            self.ipc_subject, worker_message, timeout=30
         )
 
-        response: MainToWorkerResponse = unpack(msg.data)
-
         return response.get("response")
 
     async def add_client(self, plugin_id: str, request_id: str) -> None:
@@ -593,7 +570,12 @@ class FrameWorkerChild:
             await self.send("updateClient", {"pluginId": client.plugin_id, "requestIds": client.request_ids})
 
         if len(self.clients) == 0:
-            await self.stop()
+            if self.close_timeout:
+                self.close_timeout.cancel()
+
+            self.close_timeout = asyncio.get_event_loop().call_later(
+                self.close_delay, lambda: asyncio.create_task(self.stop())
+            )
 
     async def recover_clients(self, clients: list[RecoveredClient]) -> None:
         for client in clients:
@@ -617,7 +599,7 @@ class FrameWorkerChild:
 
         response: SignalingResponse = {"type": "disconnect", "requestId": request_id}
 
-        await self.signaling_publisher.publish(ping_target_subject, pack(response))
+        await self.signaling_publisher.publish(ping_target_subject, response)
         await self.remove_client(plugin_id, request_id)
 
     async def disconnect_all_clients(self) -> None:
@@ -653,22 +635,20 @@ class FrameWorkerChild:
 
         while self.signaling_publisher and request_id_exists():
             try:
-                ping_message: PingMessage = {"type": "ping", "requestId": request_id}
+                message: PingMessage = {"type": "ping", "requestId": request_id}
 
                 # self.logger.trace(f"{self.log_prefix} Sending ping to {camera_id}:{plugin_id}")
 
-                msg = await self.signaling_publisher.request(
+                response: PongMessage = await self.signaling_publisher.request(
                     ping_target_subject,
-                    pack(ping_message),
+                    message,
                     timeout=ping_timeout,
                 )
 
-                ping_response: PongMessage = unpack(msg.data)
-
                 if not request_id_exists():
                     break
 
-                if ping_response["type"] != "pong":
+                if response["type"] != "pong":
                     raise Exception("Invalid response to ping")
 
                 # self.logger.trace(f"{self.log_prefix} Received pong from {camera_id}:{plugin_id}")
@@ -684,62 +664,23 @@ class FrameWorkerChild:
 
                 break
 
-    async def listen_to_ipc_messages(self) -> None:
-        if not self.subscriber:
-            raise Exception("Subscriber not initialized")
-
-        async for msg in self.subscriber.messages:
-            try:
-                if self.closed:
-                    break
-
-                if len(msg.data) == 0:
-                    continue
-
-                self.tasks.add(self.respond_on_ipc_message(msg))
-            except Exception as e:
-                if not self.closed:
-                    self.logger.error(f"{self.log_prefix} Error while processing IPC message:", e)
-                else:
-                    break
-
-    async def listen_to_signaling_messages(self) -> None:
-        if not self.signal_subscriber:
-            raise Exception("Subscriber not initialized")
-
-        async for msg in self.signal_subscriber.messages:
-            try:
-                if self.closed:
-                    break
-
-                if len(msg.data) == 0:
-                    continue
+    async def on_worker_message(self, msg: Msg) -> None:
+        if self.closed:
+            return
 
-                self.tasks.add(self.respond_on_signaling_message(msg))
-            except Exception as e:
-                if not self.closed:
-                    self.logger.error(f"{self.log_prefix} Error while processing signaling message:", e)
-                else:
-                    break
+        self.tasks.add(self.respond_on_ipc_message(msg))
 
-    async def listen_to_prebuffered_image_messages(self) -> None:
-        if not self.image_subscriber:
-            raise Exception("Subscriber not initialized")
+    async def on_signaling_message(self, msg: Msg) -> None:
+        if self.closed:
+            return
 
-        async for msg in self.image_subscriber.messages:
-            try:
-                if self.closed:
-                    break
+        self.tasks.add(self.respond_on_signaling_message(msg))
 
-                if len(msg.data) == 0:
-                    continue
+    async def on_image_request(self, msg: Msg) -> None:
+        if self.closed:
+            return
 
-                self.tasks.add(self.respond_on_prebuffered_image_message(msg))
-            except Exception as e:
-                if not self.closed:
-                    self.logger.error(f"{self.log_prefix} Error while processing image message:", e)
-                else:
-                    break
+        self.tasks.add(self.respond_on_prebuffered_image_message(msg))
 
     async def respond_on_ipc_message(self, msg: Msg) -> None:
         try:
@@ -788,10 +729,10 @@ class FrameWorkerChild:
                 processed_image = await self.process_frame(
                     target_frame["frame"], width, height, format, options
                 )
-                await msg.respond(processed_image)
+                await msg.respond(pack(processed_image))
                 return
 
-            await msg.respond(b"")
+            await msg.respond(pack(b""))
         except Exception as e:
             self.logger.error(f"{self.log_prefix} Error while processing image respond:", e)
 

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

@@ -14,7 +14,6 @@ from camera_ui_types import (
 )
 from deepdiff import DeepDiff
 from lmdbm import Lmdb
-from logger import PluginLogger
 from plugin_api import PluginAPI
 from schema import (
     config_path_to_schema_path,
@@ -61,7 +60,6 @@ class CameraStorage:
     def __init__(
         self,
         api: PluginAPI,
-        logger: PluginLogger,
         instance: Any,
         camera_id: str,
         schema: Optional[PluginJsonSchemaForm] = None,
@@ -69,7 +67,6 @@ class CameraStorage:
         if schema is None:
             schema = {}
         self.__api = api
-        self.__logger = logger
         self.__instance = instance
         self.__camera_id = camera_id
         self.__schema: PluginJsonSchemaForm = schema or {}
@@ -96,8 +93,8 @@ class CameraStorage:
         try:
             config: Any = self.__db.get("config") or {}
             camera_config = config.get(self.__camera_id, {})
-        except Exception as e:
-            self.__logger.error("Error loading config from database:", e)
+        except:  # noqa: E722
+            pass
 
         schema_config = generate_json_from_root_schema({"schema": self.__schema})
 
@@ -426,29 +423,19 @@ class CameraStorage:
             )
 
     def __save_db(self) -> None:
-        try:
-            config: Any = self.__db.get("config") or {}
-            storable_config = self.__filter_storable_values(self.__schema)
+        config: Any = self.__db.get("config") or {}
+        storable_config = self.__filter_storable_values(self.__schema)
 
-            config[self.__camera_id] = storable_config
+        config[self.__camera_id] = storable_config
 
-            self.__db.update(
-                {
-                    "config": config,
-                }
-            )
-        except Exception as e:
-            self.__logger.error("Error saving to database:", e)
+        self.__db.update({"config": config})
 
     def __remove_db(self) -> None:
-        try:
-            config: Any = self.__db.get("config") or {}
+        config: Any = self.__db.get("config") or {}
 
-            if self.__camera_id in config:
-                del config[self.__camera_id]
-                self.__db.update(config)
-        except Exception as e:
-            self.__logger.error("Error removing from database:", e)
+        if self.__camera_id in config:
+            del config[self.__camera_id]
+            self.__db.update(config)
 
     def __deselected(self, id: str) -> None:
         if id == self.__camera_id: