@camera.ui/server 0.0.6 → 0.0.8

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

@@ -9,7 +9,6 @@ from typing import Any, Optional, Union, cast
 from uuid import uuid4
 
 import aiohttp
-import nats
 from cachetools import LRUCache, cached
 from camera.polygon import are_motion_detections_valid, are_object_detections_valid
 from camera.video_frame import MotionFrame, VideoFrame
@@ -55,13 +54,12 @@ from camera_ui_types import (
     StateNames,
     StateValue,
 )
-from decoder.typings import PingMessage, PongMessage, SignalingRequest, SignalingResponse
+from decoder.typings import AuthConfig, PingMessage, PongMessage, SignalingRequest, SignalingResponse
 from deepdiff import DeepDiff
-from logger import PluginLogger
-from nats.aio.client import Client as NatsConnection
+from message_queue import MessageQueue
 from nats.aio.msg import Msg
-from nats.aio.subscription import Subscription
 from plugin_api import PluginAPI
+from plugin_logger import PluginLogger
 from reactivex import Observable
 from reactivex import operators as ops
 from reactivex.subject.behaviorsubject import BehaviorSubject
@@ -74,11 +72,11 @@ from typings import (
     PluginInfo,
     ProxyMessageStructure,
 )
+from utilities.connection import ProxyConnection
 from utilities.packer import pack, unpack
+from utilities.subscriptions import ProxySubscription
 from utilities.task import TaskSet
 
-from .message_queue import ClientMessageQueue
-
 
 class CameraSource:
     def __init__(self, source: CameraInput, parent: Any):
@@ -110,7 +108,7 @@ class CameraDeviceProxy:
         camera: Camera,
         plugin: PluginInfo,
         proxy_endpoints: list[str],
-        auth: dict[str, str],
+        auth: AuthConfig,
     ):
         self.snapshot_cache = LRUCache(maxsize=100)
         self.camera_subject = BehaviorSubject(camera)
@@ -172,8 +170,8 @@ class CameraDeviceProxy:
         from camera.interfaces.ptz import CameraPTZInterface
 
         self.cameraDelegate = CameraInterface(self, logger)
-        self.prebufferDelegate = CameraPrebufferInterface(self, logger)
         self.ptzDelegate = CameraPTZInterface(self, logger)
+        self.prebufferDelegate = CameraPrebufferInterface(self, logger)
 
         self.subject = f"{self.plugin['id']}.camera.{self.id}"
         self.camera_subscriber_subject = f"{self.id}.camera"
@@ -183,21 +181,21 @@ class CameraDeviceProxy:
         self.signaling_subject = f"{self.plugin['id']}.camera.{self.id}.signaling"
         self.signaling_target_subject = f"{self.id}.frameGenerator.signaling"
 
-        self.publisher: Optional[NatsConnection] = None
-        self.camera_publisher: Optional[NatsConnection] = None
-        self.frame_publisher: Optional[NatsConnection] = None
-        self.motion_frame_publisher: Optional[NatsConnection] = None
-        self.signaling_publisher: Optional[NatsConnection] = None
+        self.publisher: Optional[ProxyConnection] = None
+        self.camera_publisher: Optional[ProxyConnection] = None
+        self.frame_publisher: Optional[ProxyConnection] = None
+        self.motion_frame_publisher: Optional[ProxyConnection] = None
+        self.signaling_publisher: Optional[ProxyConnection] = None
 
-        self.subscriber: Optional[Subscription] = None
-        self.camera_subscriber: Optional[Subscription] = None
-        self.camera_plugin_subscriber: Optional[Subscription] = None
-        self.signaling_subscriber: Optional[Subscription] = None
-        self.frame_subscriber: Optional[Subscription] = None
-        self.motion_frame_subscriber: Optional[Subscription] = None
+        self.subscriber: Optional[ProxySubscription] = None
+        self.camera_subscriber: Optional[ProxySubscription] = None
+        self.camera_plugin_subscriber: Optional[ProxySubscription] = None
+        self.signaling_subscriber: Optional[ProxySubscription] = None
+        self.frame_subscriber: Optional[ProxySubscription] = None
+        self.motion_frame_subscriber: Optional[ProxySubscription] = None
 
         self.tasks: TaskSet = TaskSet(f"{self.plugin['name']} - {self.name} - CameraDeviceProxy")
-        self.message_queue: Optional[ClientMessageQueue] = None
+        self.message_queue: Optional[MessageQueue] = None
         self.active_requests: set[str] = set()
         self.active_motion_requests = 0
 
@@ -321,98 +319,53 @@ class CameraDeviceProxy:
     def low_resolution_source(self) -> Optional[CameraSource]:
         return next(source for source in self.sources if "low-resolution" in source.roles)
 
+    @property
+    def ptz(self) -> CameraPTZDelegate:
+        return self.ptzDelegate
+
     async def init(self):
         if self.initialized:
             return
 
         self.initialized = True
 
-        async def ignore_cb(e: Optional[Any] = None):
-            pass
+        self.publisher = ProxyConnection(self.subject, self.proxy_endpoints, self.auth)
+        await self.publisher.connect()
 
-        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.camera_publisher = ProxyConnection(
+            self.camera_subscriber_subject, self.proxy_endpoints, self.auth
         )
+        await self.camera_publisher.connect()
 
-        self.camera_publisher = await nats.connect(
-            servers=[endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")],
-            name=self.camera_subscriber_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.signaling_publisher = ProxyConnection(self.signaling_subject, self.proxy_endpoints, self.auth)
+        await self.signaling_publisher.connect()
 
-        self.signaling_publisher = await nats.connect(
-            servers=[endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")],
-            name=self.signaling_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.frame_publisher = ProxyConnection(self.frame_subject, self.proxy_endpoints, self.auth)
+        await self.frame_publisher.connect()
 
-        self.frame_publisher = await nats.connect(
-            servers=[endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")],
-            name=self.frame_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.motion_frame_publisher = await nats.connect(
-            servers=[endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")],
-            name=self.motion_frame_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.motion_frame_publisher = ProxyConnection(
+            self.motion_frame_subject, self.proxy_endpoints, self.auth
         )
+        await self.motion_frame_publisher.connect()
 
         self.subscriber = await self.publisher.subscribe(subject=self.subject)
-        self.signaling_subscriber = await self.signaling_publisher.subscribe(subject=self.signaling_subject)
-        self.camera_subscriber = await self.camera_publisher.subscribe(subject=self.camera_subscriber_subject)
-        self.camera_plugin_subscriber = await self.camera_publisher.subscribe(
-            subject=self.camera_plugin_subscriber_subject
-        )
-
-        self.message_queue = ClientMessageQueue(
+        self.message_queue = MessageQueue(
             self.logger,
             self.publisher,
             self.subscriber,
             self.__request_handler,
         )
 
-        self.tasks.add(self.message_queue.start())
-        self.tasks.add(self.__listen_to_messages(self.camera_subscriber))
-        self.tasks.add(self.__listen_to_messages(self.camera_plugin_subscriber))
-        self.tasks.add(self.__listen_to_signaling_messages())
+        self.signaling_subscriber = await self.signaling_publisher.subscribe(subject=self.signaling_subject)
+        self.signaling_subscriber.on("message", self.__on_signaling_message)
+
+        self.camera_subscriber = await self.camera_publisher.subscribe(subject=self.camera_subscriber_subject)
+        self.camera_subscriber.on("message", self.__on_proxy_message)
+
+        self.camera_plugin_subscriber = await self.camera_publisher.subscribe(
+            subject=self.camera_plugin_subscriber_subject
+        )
+        self.camera_plugin_subscriber.on("message", self.__on_proxy_message)
 
         await self.refresh_states()
 
@@ -483,7 +436,7 @@ class CameraDeviceProxy:
             if not self.frame_subscriber:
                 self.frame_subscriber = await self.frame_publisher.subscribe(self.frame_subject)
 
-            async for msg in self.frame_subscriber.messages:
+            async for msg in self.frame_subscriber.subscriber.messages:
                 try:
                     if (
                         not self.initialized
@@ -524,7 +477,7 @@ class CameraDeviceProxy:
                     self.motion_frame_subject
                 )
 
-            async for msg in self.motion_frame_subscriber.messages:
+            async for msg in self.motion_frame_subscriber.subscriber.messages:
                 try:
                     if not self.initialized or self.active_motion_requests <= 0:
                         break
@@ -885,10 +838,7 @@ class CameraDeviceProxy:
         if not self.frame_publisher:
             return
 
-        await self.frame_publisher.publish(
-            self.motion_frame_subject,
-            pack(frame),
-        )
+        await self.frame_publisher.publish(self.motion_frame_subject, frame)
 
     @overload
     def __check_state_internal(
@@ -1454,10 +1404,7 @@ class CameraDeviceProxy:
             "pluginId": self.plugin["id"],
         }
 
-        await self.signaling_publisher.publish(
-            self.signaling_target_subject,
-            pack(message),
-        )
+        await self.signaling_publisher.publish(self.signaling_target_subject, message)
 
         self.active_requests.add(request_id)
 
@@ -1480,13 +1427,12 @@ class CameraDeviceProxy:
                 "pluginId": self.plugin["id"],
             }
 
-            metadata_msg = await self.signaling_publisher.request(
+            metadata_response: SignalingResponse = await self.signaling_publisher.request(
                 self.signaling_target_subject,
-                pack(metadata_request),
+                metadata_request,
                 timeout=timeout,
             )
 
-            metadata_response: SignalingResponse = unpack(metadata_msg.data)
             metadata = metadata_response.get("metadata")
 
             return metadata
@@ -1500,9 +1446,6 @@ class CameraDeviceProxy:
         if not self.signaling_publisher:
             raise Exception("Signaling Publisher not initialized")
 
-        if self.signaling_publisher.is_closed:
-            return
-
         message: SignalingRequest = {
             "type": "disconnect",
             "requestId": request_id,
@@ -1510,18 +1453,18 @@ class CameraDeviceProxy:
             "pluginId": self.plugin["id"],
         }
 
-        await self.signaling_publisher.publish(self.signaling_target_subject, pack(message))
+        await self.signaling_publisher.publish(self.signaling_target_subject, message)
 
     async def __close_frame_subscriber(self) -> None:
         with suppress(Exception):
             if self.frame_subscriber:
-                await self.frame_subscriber.unsubscribe()
+                await self.frame_subscriber.close()
                 self.frame_subscriber = None
 
     async def __close_motion_frame_subscriber(self) -> None:
         if self.motion_frame_subscriber:
             with suppress(Exception):
-                await self.motion_frame_subscriber.unsubscribe()
+                await self.motion_frame_subscriber.close()
 
             self.motion_frame_subscriber = None
 
@@ -1581,74 +1524,48 @@ class CameraDeviceProxy:
 
             await self.message_queue.enqueue({**message, "type": "reply", "error": deserialized_error})
 
-    async def __listen_to_messages(self, camera_subscriber: Subscription) -> None:
-        async for msg in camera_subscriber.messages:
-            try:
-                if not self.initialized:
-                    break
-
-                if len(msg.data) == 0:
-                    continue
-
-                message = unpack(msg.data)
-
-                if "type" in message:
-                    type = message["type"]
-                    if type == "removed":
-                        await self.cleanup()
-                    elif type == "updated":
-                        self.update_camera(message["data"])
-                    elif type == "cameraState":
-                        self.update_camera_state(message["data"])
-                    elif type == "prebufferState":
-                        self.update_prebuffer(
-                            message["data"]["sourceId"],
-                            message["data"]["container"],
-                            message["data"]["state"],
-                        )
-
-                    continue
-
-                state_name = message["stateName"]
-                new_data = message["data"]["newEvent"]
-
-                self.__update_state_internal(state_name, new_data, True)
-
-            except Exception as e:
-                if self.initialized:
-                    self.logger.error("Error while processing camera device message:", e)
-                else:
-                    break
+    async def __on_proxy_message(self, msg: Msg) -> None:
+        if not self.initialized:
+            return
 
-    async def __listen_to_signaling_messages(self) -> None:
-        if not self.signaling_subscriber:
-            raise Exception("Subscriber not initialized")
+        message = unpack(msg.data)
+
+        if "type" in message:
+            type = message["type"]
+            if type == "removed":
+                await self.cleanup()
+            elif type == "updated":
+                self.update_camera(message["data"])
+            elif type == "cameraState":
+                self.update_camera_state(message["data"])
+            elif type == "prebufferState":
+                self.update_prebuffer(
+                    message["data"]["sourceId"],
+                    message["data"]["container"],
+                    message["data"]["state"],
+                )
+        else:
+            state_name = message["stateName"]
+            new_data = message["data"]["newEvent"]
 
-        async for msg in self.signaling_subscriber.messages:
-            try:
-                if not self.initialized:
-                    break
+            self.__update_state_internal(state_name, new_data, True)
 
-                if len(msg.data) == 0:
-                    continue
+    async def __on_signaling_message(self, msg: Msg) -> None:
+        if not self.initialized:
+            return
 
-                message: Union[SignalingResponse, PingMessage] = unpack(msg.data)
+        message: Union[SignalingResponse, PingMessage] = unpack(msg.data)
 
-                if message["type"] == "ping":
-                    if message["requestId"] in self.active_requests:
-                        self.tasks.add(self.__respond_to_signaling_message(msg, message))
+        if message["type"] == "ping":
+            if message["requestId"] in self.active_requests:
+                self.tasks.add(self.__respond_to_signaling_message(msg, message))
 
-                elif message["type"] == "disconnect":
-                    if message["requestId"] in self.active_requests:
-                        self.active_requests.remove(message["requestId"])
+        elif message["type"] == "disconnect":
+            if message["requestId"] in self.active_requests:
+                self.active_requests.remove(message["requestId"])
 
-                    if len(self.active_requests) == 0:
-                        self.tasks.add(self.__close_frame_subscriber())
-            except Exception as e:
-                if self.initialized:
-                    self.logger.error("Error while processing ping/pong message:", e)
-                else:
-                    break
+            if len(self.active_requests) == 0:
+                self.tasks.add(self.__close_frame_subscriber())
 
     async def __respond_to_signaling_message(self, msg: Msg, message: PingMessage) -> None:
         try:

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

@@ -3,20 +3,20 @@ 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 decoder.typings import AuthConfig
+from message_queue import MessageQueue
 from nats.aio.msg import Msg
-from nats.aio.subscription import Subscription
 from plugin_api import PluginAPI
+from plugin_logger import PluginLogger
 from pyeecui.asyncio import AsyncIOEventEmitter
 from typings import PluginInfo, ProxyMessageStructure
+from utilities.connection import ProxyConnection
 from utilities.packer import unpack
+from utilities.subscriptions import ProxySubscription
 from utilities.task import TaskSet
 
 from .camera_device import CameraDeviceProxy
-from .message_queue import ClientMessageQueue
 
 
 class DeviceManager(AsyncIOEventEmitter):
@@ -26,7 +26,7 @@ class DeviceManager(AsyncIOEventEmitter):
         logger: PluginLogger,
         plugin: PluginInfo,
         proxy_endpoints: list[str],
-        auth: dict[str, str],
+        auth: AuthConfig,
     ):
         super().__init__()
 
@@ -44,14 +44,14 @@ class DeviceManager(AsyncIOEventEmitter):
         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.publisher: Optional[ProxyConnection] = None
+        self.dm_publisher: Optional[ProxyConnection] = None
 
-        self.subscriber: Optional[Subscription] = None
-        self.dm_subscriber: Optional[Subscription] = None
+        self.subscriber: Optional[ProxySubscription] = None
+        self.dm_subscriber: Optional[ProxySubscription] = None
 
         self.tasks: TaskSet = TaskSet(f"{self.plugin['name']} DeviceManager")
-        self.message_queue: Optional[ClientMessageQueue] = None
+        self.message_queue: Optional[MessageQueue] = None
 
         # print("DeviceManager", self.plugin["name"], self.dealer_id, self.subscriber_ids)
 
@@ -63,47 +63,24 @@ class DeviceManager(AsyncIOEventEmitter):
 
         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,
-        )
+        servers = [endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")]
 
-        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.publisher = ProxyConnection(self.subject, servers, self.auth)
+        await self.publisher.connect()
 
-        self.subscriber = await self.publisher.subscribe(subject=self.subject)
-        self.dm_subscriber = await self.dm_publisher.subscribe(subject=self.dm_subject)
+        self.dm_publisher = ProxyConnection(self.dm_subject, servers, self.auth)
+        await self.dm_publisher.connect()
 
-        self.message_queue = ClientMessageQueue(
+        self.subscriber = await self.publisher.subscribe(subject=self.subject)
+        self.message_queue = MessageQueue(
             self.logger,
             self.publisher,
             self.subscriber,
             self.__request_handler,
         )
 
-        self.tasks.add(self.message_queue.start())
-        self.tasks.add(self.__listen_to_messages())
+        self.dm_subscriber = await self.dm_publisher.subscribe(subject=self.dm_subject)
+        self.dm_subscriber.on("message", self.__on_proxy_message)
 
     async def get_camera_by_id(self, id: str) -> Optional[CameraDeviceProxy]:
         camera_device = await self.__add_or_get_camera(id)
@@ -175,27 +152,11 @@ class DeviceManager(AsyncIOEventEmitter):
 
             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_proxy_message(self, msg: Msg) -> None:
+        if not self.initialized:
+            return
+
+        self.tasks.add(self.__emit_event(msg))
 
     async def __on_request(self, fn: str, args: list[Any] = []) -> Any:
         if not self.message_queue:

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

@@ -2,13 +2,11 @@ from typing import Any, Optional
 
 from camera_storage import CameraStorage
 from camera_ui_types import PluginJsonSchemaForm
-from logger import PluginLogger
 from plugin_api import PluginAPI
 
 
 class StorageController:
-    def __init__(self, api: PluginAPI, logger: PluginLogger) -> None:
-        self.__logger = logger
+    def __init__(self, api: PluginAPI) -> None:
         self.__api = api
         self.__camera_storages: dict[str, CameraStorage] = {}
 
@@ -28,8 +26,9 @@ class StorageController:
         """
         if schema is None:
             schema = {}
+
         camera_storage = self.__camera_storages.get(camera_id) or CameraStorage(
-            self.__api, self.__logger, instance, camera_id, schema
+            self.__api, instance, camera_id, schema
         )
 
         camera_storage.initialize_storage()

package/dist/server/src/polyglot/python/utilities/connection.py

@@ -0,0 +1,86 @@
+from typing import Any, Optional
+
+import nats
+from decoder.typings import AuthConfig
+from nats.aio.client import Client as NatsConnection
+
+from .packer import pack, unpack
+from .subscriptions import ProxySubscription
+from .task import TaskSet
+
+
+class ProxyConnection:
+    def __init__(self, name: str, servers: list[str], auth: AuthConfig) -> None:
+        self.name = name
+        self.servers = servers
+        self.auth = auth
+
+        self.tasks: TaskSet = TaskSet(f"{self.name} NatsSubscriber")
+        self.publisher: Optional[NatsConnection] = None
+        self.subscribers: list[ProxySubscription] = []
+
+        self.closed = False
+
+    async def connect(self) -> NatsConnection:
+        async def ignore_cb(e: Optional[Any] = None):
+            pass
+
+        self.publisher = await nats.connect(
+            servers=self.servers,
+            name=self.name,
+            user=self.auth["user"],
+            password=self.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,
+        )
+
+        return self.publisher
+
+    async def subscribe(self, subject: str, skip_listening: bool = False) -> ProxySubscription:
+        if not self.publisher:
+            raise Exception("Connection not established")
+
+        subscriber = ProxySubscription(await self.publisher.subscribe(subject))
+
+        if not skip_listening:
+            self.tasks.add(subscriber.listen())
+
+        self.subscribers.append(subscriber)
+
+        return subscriber
+
+    async def publish(self, subject: str, message: Any) -> None:
+        if self.closed:
+            return
+
+        if not self.publisher:
+            raise Exception("Connection not established")
+
+        await self.publisher.publish(subject, pack(message))
+
+    async def request(self, subject: str, message: Any, timeout: float) -> Any:
+        if self.closed:
+            return
+
+        if not self.publisher:
+            raise Exception("Connection not established")
+
+        msg = await self.publisher.request(subject, pack(message), timeout)
+        response = unpack(msg.data)
+
+        return response
+
+    async def close(self) -> None:
+        self.closed = True
+
+        for subscriber in self.subscribers:
+            await subscriber.close()
+
+        if self.publisher:
+            await self.publisher.close()
+
+        self.tasks.remove_all()