cgse 0.14.1__tar.gz → 0.15.0__tar.gz

{cgse-0.14.1 → cgse-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.14.1
+Version: 0.15.0
 Summary: Generic Common-EGSE: Commanding and monitoring lab equipment
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-common/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-common"
-version = "0.14.1"
+version = "0.15.0"
 description = "Software framework to support hardware testing"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-coordinates/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-coordinates"
-version = "0.14.1"
+version = "0.15.0"
 description = "Reference Frames and Coordinate Transofrmations for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-core/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-core"
-version = "0.14.1"
+version = "0.15.0"
 description = "Core services for the CGSE framework"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-core/src/egse/logger/__init__.py

@@ -67,7 +67,7 @@ def get_endpoint_from_registry(port: str = "commander"):
     from egse.registry.client import RegistryClient
 
     try:
-        with RegistryClient(request_timeout=500) as reg:
+        with RegistryClient() as reg:
             if port == "commander":
                 endpoint = reg.get_endpoint(SERVICE_TYPE)
             elif port == "receiver":

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-core/src/egse/logger/log_cs.py

@@ -317,7 +317,7 @@ def handle_command(command) -> dict:
 
     elif command.lower() == "status":
         with RegistryClient() as client:
-            service = client.discover_service("LOGGER")
+            service = client.discover_service(SERVICE_TYPE)
         if service:
             response.update(
                 dict(

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-core/src/egse/notifyhub/server.py

@@ -19,12 +19,13 @@ from egse.notifyhub import DEFAULT_REQUESTS_PORT
 from egse.notifyhub import STATS_INTERVAL
 from egse.notifyhub.client import AsyncNotificationHubClient
 from egse.registry import MessageType
-from egse.registry.client import AsyncRegistryClient
+from egse.registry.client import AsyncRegistryClient, REQUEST_TIMEOUT
 from egse.system import TyperAsyncCommand
 from egse.system import get_host_ip
 from .event import NotificationEvent
 
-RECV_REQUEST_TIMEOUT = 1.0
+REQUEST_POLL_TIMEOUT = 1.0
+"""time to wait for while listening for requests [seconds]."""
 
 app = typer.Typer(name="notify_hub")
 
@@ -45,7 +46,7 @@ class AsyncNotificationHub:
         self.requests_socket: zmq.asyncio.Socket = self.context.socket(zmq.ROUTER)
 
         # Register notification hub to the service registry
-        self.registry_client = AsyncRegistryClient(request_timeout=200)  # FIXME: ms -> s and CONSTANT
+        self.registry_client = AsyncRegistryClient(timeout=REQUEST_TIMEOUT)
         self.service_id = None
         self.service_name = "Notification Hub"
         self.service_type = "notification-hub"
@@ -206,14 +207,14 @@ class AsyncNotificationHub:
                 self.running = False
 
     async def _handle_requests(self):
-        """Simple health check endpoint simulation"""
+        """Handle basic requests like e.g. health check."""
         self.logger.info("Started request handler task")
 
         while self.running:
             try:
                 try:
                     message_parts = await asyncio.wait_for(
-                        self.requests_socket.recv_multipart(), timeout=RECV_REQUEST_TIMEOUT
+                        self.requests_socket.recv_multipart(), timeout=REQUEST_POLL_TIMEOUT
                     )
                 except asyncio.TimeoutError:
                     # self.logger.debug("waiting for command request...")

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-core/src/egse/registry/__init__.py

@@ -13,8 +13,8 @@ class MessageType(Enum):
     """Message types using the envelope frame in the ROUTER-DEALER protocol."""
 
     REQUEST_WITH_REPLY = b"REQ"  # Client expects a reply
-    REQUEST_NO_REPLY = b"NO-REQ"  # No reply expected by the client
-    RESPONSE = b"REP"  # Response to a request
+    REQUEST_NO_REPLY = b"REQ_NO_REPLY"  # No reply expected by the client
+    RESPONSE = b"RESPONSE"  # Response to a request
     NOTIFICATION = b"NOTIF"  # Server-initiated notification
     HEARTBEAT = b"HB"  # Heartbeat/health check
 
@@ -34,7 +34,7 @@ def is_service_registry_active(timeout: float = 0.5):
 
     from egse.registry.client import RegistryClient  # prevent circular import
 
-    with RegistryClient(request_timeout=int(timeout * 1000)) as client:
+    with RegistryClient(timeout=timeout) as client:
         if not client.health_check():
             return False
         else:

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-core/src/egse/registry/client.py

@@ -22,8 +22,22 @@ from egse.registry import DEFAULT_RS_REQ_PORT
 from egse.registry import MessageType
 from egse.system import do_every
 
-REQUEST_TIMEOUT = 5000  # milliseconds
-
+REQUEST_TIMEOUT = 0.5
+"""time to wait for a request-reply [seconds]. For responsive message handling."""
+EVENT_POLL_TIMEOUT = 0.5
+"""time to wait for while listening for events [seconds]."""
+TASK_COMPLETION_TIMEOUT = 5.0
+"""time to wait for Tasks to complete [seconds]."""
+HEALTH_CHECK_TIMEOUT = 2.0
+"""Health checks shouldn't take too long. Recommended: 1-5s."""
+HEART_BEAT_TIMEOUT = 1.0
+"""Heart beat should fail fast to detect network issues. Recommended: 0.5-2s."""
+HEART_BEAT_RECONNECT = 1.0
+"""Time to wait between a disconnect an a connect to the heartbeat socket."""
+THREAD_JOIN_TIMEOUT = 10.0
+"""Joining threads should be longer, but the key is balancing graceful cleanup with reasonable shutdown times."""
+PROCESS_SHUTDOWN_TIMEOUT = 10.0
+"""Waiting for a process shutdown confirmation message."""
 
 class RegistryClient:
     """
@@ -35,7 +49,7 @@ class RegistryClient:
         registry_req_endpoint: str = None,
         registry_sub_endpoint: str = None,
         registry_hb_endpoint: str = None,
-        request_timeout: int = REQUEST_TIMEOUT,
+        timeout: float = REQUEST_TIMEOUT,
         client_id: str = "registry-client",
     ):
         """
@@ -45,14 +59,15 @@ class RegistryClient:
             registry_req_endpoint: ZeroMQ endpoint for REQ-REP socket, defaults to DEFAULT_RS_REQ_PORT on localhost.
             registry_sub_endpoint: ZeroMQ endpoint for SUB socket, defaults to DEFAULT_RS_PUB_PORT on localhost.
             registry_hb_endpoint: ZeroMQ endpoint for Heartbeat socket, defaults to DEFAULT_RS_HB_PORT on localhost.
-            request_timeout: Timeout for requests in milliseconds, defaults to 5000.
+            timeout: Timeout for requests in seconds, defaults to 0.5s.
             client_id: client identification, default='registry-client'
         """
         self.registry_req_endpoint = registry_req_endpoint or f"tcp://localhost:{DEFAULT_RS_REQ_PORT}"
         self.registry_sub_endpoint = registry_sub_endpoint or f"tcp://localhost:{DEFAULT_RS_PUB_PORT}"
         self.registry_hb_endpoint = registry_hb_endpoint or f"tcp://localhost:{DEFAULT_RS_HB_PORT}"
 
-        self.request_timeout = request_timeout
+        self.timeout = timeout
+        self.timeout_ms = int(timeout * 1000)
         self.logger = logger
 
         # Service state
@@ -122,17 +137,20 @@ class RegistryClient:
             self.hb_socket.close()
         self.hb_socket = None
 
-    def _send_request(self, msg_type: MessageType, request: dict[str, Any]) -> dict[str, Any]:
+    def _send_request(self, msg_type: MessageType, request: dict[str, Any], timeout: float = None) -> dict[str, Any]:
         """
         Send a request to the registry and get the response.
 
         Args:
             msg_type: the type of message and reply
             request: The request to send
+            timeout: The number of seconds to wait, if None, instance variable is used.
 
         Returns:
             The response from the registry.
         """
+        timeout_ms = int(timeout * 1000) if timeout else self.timeout_ms
+
         try:
             self.logger.debug(f"Sending request: {request}")
             self.req_socket.send_multipart([msg_type.value, json.dumps(request).encode()])
@@ -140,7 +158,7 @@ class RegistryClient:
             if msg_type == MessageType.REQUEST_NO_REPLY:
                 return {"success": True}
 
-            if self.poller.poll(timeout=self.request_timeout):
+            if self.poller.poll(timeout=timeout_ms):
                 message_parts = self.req_socket.recv_multipart()
 
                 if len(message_parts) >= 2:
@@ -163,7 +181,7 @@ class RegistryClient:
                         "data": message_parts,
                     }
             else:
-                self.logger.error(f"Request timed out after {self.request_timeout / 1000:.2f}s")
+                self.logger.error(f"Request timed out after {self.timeout:.2f}s")
                 return {"success": False, "error": "Request timed out"}
         except zmq.ZMQError as exc:
             self.logger.error(f"ZMQ error: {exc}", exc_info=True)
@@ -187,7 +205,7 @@ class RegistryClient:
             self.logger.debug(f"Sending heartbeat request: {request}")
             self.hb_socket.send_string(json.dumps(request))
 
-            ready_sockets, _, _ = zmq.select([self.hb_socket], [], [], timeout=self.request_timeout)
+            ready_sockets, _, _ = zmq.select([self.hb_socket], [], [], timeout=HEART_BEAT_TIMEOUT)
 
             if ready_sockets:
                 response_json = self.hb_socket.recv_string()
@@ -195,9 +213,9 @@ class RegistryClient:
                 self.logger.debug(f"Received response: {response}")
                 return response
             else:
-                self.logger.error(f"Request timed out after {self.request_timeout / 1000:.2f}s")
+                self.logger.error(f"Request timed out after {HEART_BEAT_TIMEOUT:.2f}s")
                 self._disconnect_hb_socket()
-                time.sleep(1.0)
+                time.sleep(HEART_BEAT_RECONNECT)
                 self._connect_hb_socket()
                 return {"success": False, "error": "Request timed out"}
 
@@ -392,7 +410,7 @@ class RegistryClient:
         """
         request = {"action": "health"}
 
-        response = self._send_request(MessageType.REQUEST_WITH_REPLY, request)
+        response = self._send_request(MessageType.REQUEST_WITH_REPLY, request, timeout=HEALTH_CHECK_TIMEOUT)
         return response.get("success", False)
 
     def terminate_registry_server(self) -> bool:
@@ -400,7 +418,7 @@ class RegistryClient:
         Send a terminate request to the service registry server. Returns True when successful.
         """
         request = {"action": "terminate"}
-        response = self._send_request(MessageType.REQUEST_WITH_REPLY, request)
+        response = self._send_request(MessageType.REQUEST_WITH_REPLY, request, timeout=PROCESS_SHUTDOWN_TIMEOUT)
         return response.get("success", False)
 
     def server_status(self) -> dict[str, Any]:
@@ -459,7 +477,7 @@ class RegistryClient:
     def stop_heartbeat(self) -> None:
         self._hb_stop_event.set()
         if self._hb_thread.is_alive():
-            self._hb_thread.join(timeout=1)
+            self._hb_thread.join(timeout=THREAD_JOIN_TIMEOUT)
 
     def close(self) -> None:
         """Clean up resources."""
@@ -488,7 +506,7 @@ class AsyncRegistryClient:
         registry_req_endpoint: str = None,
         registry_sub_endpoint: str = None,
         registry_hb_endpoint: str = None,
-        request_timeout: int = REQUEST_TIMEOUT,
+        timeout: float = REQUEST_TIMEOUT,
         client_id: str = "registry-client",
     ):
         """
@@ -498,14 +516,15 @@ class AsyncRegistryClient:
             registry_req_endpoint: ZeroMQ endpoint for REQ-REP socket, defaults to DEFAULT_RS_REQ_PORT on localhost.
             registry_sub_endpoint: ZeroMQ endpoint for SUB socket, defaults to DEFAULT_RS_PUB_PORT on localhost.
             registry_hb_endpoint: ZeroMQ endpoint for heartbeat socket, defaults to DEFAULT_RS_HB_PORT on localhost.
-            request_timeout: Timeout for requests in milliseconds, defaults to 5000.
+            timeout: Timeout for requests in seconds, defaults to 5000.
             client_id: client identification, default='registry-client'
         """
         self.registry_req_endpoint = registry_req_endpoint or f"tcp://localhost:{DEFAULT_RS_REQ_PORT}"
         self.registry_sub_endpoint = registry_sub_endpoint or f"tcp://localhost:{DEFAULT_RS_PUB_PORT}"
         self.registry_hb_endpoint = registry_hb_endpoint or f"tcp://localhost:{DEFAULT_RS_HB_PORT}"
 
-        self.request_timeout = request_timeout
+        self.timeout = timeout
+        self.timeout_ms = int(timeout * 1000)
         self.logger = logging.getLogger("egse.registry.client")
 
         # Service state
@@ -585,7 +604,7 @@ class AsyncRegistryClient:
         return self._service_cache_lock
 
     async def _send_request(
-        self, msg_type: MessageType, request: dict[str, Any], timeout: int = None
+        self, msg_type: MessageType, request: dict[str, Any], timeout: float = None
     ) -> dict[str, Any]:
         """
         Send a request to the registry and get the response.
@@ -593,14 +612,14 @@ class AsyncRegistryClient:
         Args:
             msg_type: the type of message and reply
             request: The request to send to the service registry server.
-            timeout: The number of milliseconds to wait
+            timeout: The number of seconds to wait, if None, instance variable is used.
 
         Returns:
             The response from the registry as a dictionary.
         """
         self.logger.debug(f"Sending request: {request}")
 
-        timeout = (timeout or self.request_timeout) / 1000
+        timeout = timeout or self.timeout
         try:
             await self.req_socket.send_multipart([msg_type.value, json.dumps(request).encode()])
 
@@ -636,32 +655,28 @@ class AsyncRegistryClient:
             self.logger.error(f"Error sending request: {exc}", exc_info=True)
             return {"success": False, "error": str(exc)}
 
-    async def _send_heartbeat(self, request: dict[str, Any], timeout: int = None) -> dict[str, Any]:
+    async def _send_heartbeat(self, request: dict[str, Any]) -> dict[str, Any]:
         """
         Send a heartbreak request to the registry and get the response.
 
         Args:
             request: The request to send to the service registry server.
-            timeout: The number of milliseconds to wait
 
         Returns:
             The response from the registry as a dictionary.
         """
 
-        timeout = (timeout or self.request_timeout) / 1000
         try:
-            # Send the request
             self.logger.debug(f"Sending heartbeat request: {request}")
             await self.hb_socket.send_string(json.dumps(request))
 
-            # Wait for the response with timeout
             try:
-                response_json = await asyncio.wait_for(self.hb_socket.recv_string(), timeout=timeout)
+                response_json = await asyncio.wait_for(self.hb_socket.recv_string(), timeout=HEART_BEAT_TIMEOUT)
                 response = json.loads(response_json)
                 self.logger.debug(f"Received heartbeat response: {response = }")
                 return response
             except asyncio.TimeoutError:
-                self.logger.error(f"Heartbeat request timed out after {timeout:.2f}s")
+                self.logger.error(f"Heartbeat request timed out after {HEART_BEAT_TIMEOUT:.2f}s")
                 # Reset the socket to avoid invalid state
                 self.hb_socket.close()
                 self.hb_socket = self.context.socket(zmq.REQ)
@@ -698,7 +713,7 @@ class AsyncRegistryClient:
             The service ID if successful, None otherwise
         """
         # Prepare service info
-        service_info = {"name": name, "host": host, "port": port}
+        service_info: dict[str, Any] = {"name": name, "host": host, "port": port}
 
         # Add optional fields
         if service_type:
@@ -854,7 +869,7 @@ class AsyncRegistryClient:
         # Wait for tasks to complete (with timeout)
         if self._tasks:
             try:
-                await asyncio.wait(self._tasks, timeout=2.0)
+                await asyncio.wait(self._tasks, timeout=TASK_COMPLETION_TIMEOUT)
             except asyncio.CancelledError:
                 pass
 
@@ -896,7 +911,9 @@ class AsyncRegistryClient:
                     try:
                         # Use a timeout to allow for clean shutdown
                         try:
-                            message = await asyncio.wait_for(self.sub_socket.recv_multipart(), timeout=1.0)
+                            message = await asyncio.wait_for(
+                                self.sub_socket.recv_multipart(), timeout=EVENT_POLL_TIMEOUT
+                            )
                         except asyncio.TimeoutError:
                             continue
 
@@ -942,7 +959,7 @@ class AsyncRegistryClient:
         Update the service cache based on registry events.
 
         Args:
-            event_type: Type of event
+            event_type: Type of the event.
             event: Event data
         """
         async with self._get_service_cache_lock():
@@ -1097,7 +1114,7 @@ class AsyncRegistryClient:
         """
         request = {"action": "health"}
 
-        response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request)
+        response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request, timeout=HEALTH_CHECK_TIMEOUT)
         return response.get("success", False)
 
     async def terminate_registry_server(self) -> bool:
@@ -1105,7 +1122,7 @@ class AsyncRegistryClient:
         Send a terminate request to the service registry server. Returns True when successful.
         """
         request = {"action": "terminate"}
-        response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request)
+        response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request, timeout=PROCESS_SHUTDOWN_TIMEOUT)
         return response.get("success", False)
 
     async def server_status(self) -> dict[str, Any]:
@@ -1115,7 +1132,7 @@ class AsyncRegistryClient:
         request = {
             "action": "info",
         }
-        response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request, timeout=500)
+        response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request)
         return response
 
     async def close(self) -> None:

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-core/src/egse/registry/server.py

@@ -554,7 +554,6 @@ async def status(
         registry_req_endpoint=f"tcp://{host}:{req_port}",
         registry_sub_endpoint=f"tcp://{host}:{pub_port}",
         registry_hb_endpoint=f"tcp://{host}:{hb_port}",
-        request_timeout=5000,  # 5 second timeout
     ) as client:
         response = await client.server_status()
 
@@ -585,7 +584,6 @@ async def stop(
         registry_req_endpoint=f"tcp://{host}:{req_port}",
         registry_sub_endpoint=f"tcp://{host}:{pub_port}",
         registry_hb_endpoint=f"tcp://{host}:{hb_port}",
-        request_timeout=5000,  # 5 second timeout
     ) as client:
         response = await client.terminate_registry_server()
 

{cgse-0.14.1 → cgse-0.15.0}/libs/cgse-gui/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-gui"
-version = "0.14.1"
+version = "0.15.0"
 description = "GUI components for CGSE"
 authors = [
     {name = "Rik Huygen", email = "rik.huygen@kuleuven.be"},

{cgse-0.14.1 → cgse-0.15.0}/projects/generic/cgse-tools/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-tools"
-version = "0.14.1"
+version = "0.15.0"
 description = "Tools for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/projects/generic/keithley-tempcontrol/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "keithley-tempcontrol"
-version = "0.14.1"
+version = "0.15.0"
 description = "Keithley Temperature Control for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/projects/generic/lakeshore-tempcontrol/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lakeshore-tempcontrol"
-version = "0.14.1"
+version = "0.15.0"
 description = "Lakeshore Temperature Control for CGSE"
 authors = [
     {name = "IVS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/projects/generic/symetrie-hexapod/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "symetrie-hexapod"
-version = "0.14.1"
+version = "0.15.0"
 description = "Symetrie Hexapod implementation for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/projects/plato/plato-fits/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plato-fits"
-version = "0.14.1"
+version = "0.15.0"
 description = "FITS Persistence implementation for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/projects/plato/plato-hdf5/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plato-hdf5"
-version = "0.14.1"
+version = "0.15.0"
 description = "HDF5 Persistence sub-class for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/projects/plato/plato-spw/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plato-spw"
-version = "0.14.1"
+version = "0.15.0"
 description = "SpaceWire implementation for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.14.1 → cgse-0.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse"
-version = "0.14.1"
+version = "0.15.0"
 description = "Generic Common-EGSE: Commanding and monitoring lab equipment"
 authors = [
     {name = "IvS KU Leuven"}