cgse 0.16.7__tar.gz → 0.16.9__tar.gz

{cgse-0.16.7 → cgse-0.16.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.16.7
+Version: 0.16.9
 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.16.7 → cgse-0.16.9}/libs/cgse-common/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/libs/cgse-coordinates/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/libs/cgse-core/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/libs/cgse-core/src/egse/proxy.py

@@ -13,6 +13,7 @@ from types import MethodType
 
 import zmq
 
+from egse.connect import VERBOSE_DEBUG
 from egse.decorators import dynamic_interface
 from egse.log import logger
 from egse.mixin import DynamicClientCommandMixin
@@ -102,7 +103,7 @@ class BaseProxy(ControlServerConnectionInterface):
         for a reply from the control server.
         """
 
-        self._logger = logging.getLogger(self.__class__.__name__)
+        self._logger = logger
 
         self._ctx = zmq.Context.instance()
         self._poller = zmq.Poller()
@@ -123,7 +124,8 @@ class BaseProxy(ControlServerConnectionInterface):
             self.disconnect_cs()
 
     def connect_cs(self):
-        self._logger.log(0, f"Trying to connect {self.__class__.__name__} to {self._endpoint}")
+        if VERBOSE_DEBUG:
+            self._logger.debug(f"Trying to connect {self.__class__.__name__} to {self._endpoint}")
 
         self._socket = self._ctx.socket(zmq.REQ)
         self._socket.connect(self._endpoint)
@@ -135,7 +137,8 @@ class BaseProxy(ControlServerConnectionInterface):
         self._poller.unregister(self._socket)
 
     def reconnect_cs(self):
-        self._logger.log(20, f"Trying to reconnect {self.__class__.__name__} to {self._endpoint}")
+        if VERBOSE_DEBUG:
+            self._logger.debug(f"Trying to reconnect {self.__class__.__name__} to {self._endpoint}")
 
         if not self._socket.closed:
             self._socket.close(linger=0)
@@ -145,7 +148,8 @@ class BaseProxy(ControlServerConnectionInterface):
         self._poller.register(self._socket, zmq.POLLIN)
 
     def reset_cs_connection(self):
-        self._logger.debug(f"Trying to reset the connection from {self.__class__.__name__} to {self._endpoint}")
+        if VERBOSE_DEBUG:
+            self._logger.debug(f"Trying to reset the connection from {self.__class__.__name__} to {self._endpoint}")
 
         self.disconnect_cs()
         self.connect_cs()
@@ -191,7 +195,9 @@ class BaseProxy(ControlServerConnectionInterface):
         if self._socket.closed:
             self.reconnect_cs()
 
-        self._logger.log(0, f"Sending '{data}'")
+        if VERBOSE_DEBUG:
+            self._logger.debug(f"Sending '{data}'")
+
         self._socket.send(pickle_string)
 
         while True:
@@ -202,7 +208,8 @@ class BaseProxy(ControlServerConnectionInterface):
                 if not pickle_string:
                     break
                 response = pickle.loads(pickle_string)
-                self._logger.log(0, f"Receiving response: {response}")
+                if VERBOSE_DEBUG:
+                    self._logger.debug(f"Receiving response: {response}")
                 return response
             else:
                 # timeout - server unavailable
@@ -227,7 +234,8 @@ class BaseProxy(ControlServerConnectionInterface):
 
     def ping(self):
         return_code = self.send("Ping", retries=0, timeout=1.0)
-        self._logger.log(0, f"Check if control server is available: Ping - {return_code}")
+        if VERBOSE_DEBUG:
+            self._logger.debug(f"Check if control server is available: Ping - {return_code}")
         return return_code == "Pong"
 
     def get_endpoint(self) -> str:

{cgse-0.16.7 → cgse-0.16.9}/libs/cgse-core/src/egse/registry/client.py

@@ -329,7 +329,7 @@ class RegistryClient:
             metadata=self._service_info["metadata"],
         )
 
-    def discover_service(self, service_type: str, use_cache: bool = False) -> dict[str, Any] | None:
+    def discover_service(self, service_type: str) -> dict[str, Any] | None:
         """
         Discover a service of the specified type. The service is guaranteed to be healthy at the time of discovery.
 
@@ -341,15 +341,10 @@ class RegistryClient:
 
         Args:
             service_type: Type of service to discover
-            use_cache: Whether to use cached service information
 
         Returns:
             Service information if found, None otherwise
         """
-        # Try to use cache first if enabled
-        if use_cache:
-            self.logger.info("Cache not yet implemented.")
-
         request = {"action": "discover", "service_type": service_type}
 
         response = self._send_request(MessageType.REQUEST_WITH_REPLY, request)
@@ -363,14 +358,13 @@ class RegistryClient:
             self.logger.warning(f"Service discovery failed: {response.get('error')}")
             return None
 
-    def get_service(self, service_id: str | None = None, use_cache: bool = True) -> dict[str, Any] | None:
+    def get_service(self, service_id: str | None = None) -> dict[str, Any] | None:
         """
         Get information about a specific service. When no service_id is given,
         the service_id known to this client will be used.
 
         Args:
             service_id: ID of the service to get [default=None]
-            use_cache: Whether to use cached service information
 
         Returns:
             Service information if found, None otherwise.
@@ -461,6 +455,9 @@ class RegistryClient:
             self.logger.warning("Cannot start heartbeat: no service is registered")
             return None
 
+        # Cancel an existing heartbeat thread if present
+        self.stop_heartbeat()
+
         # If interval not specified, use 1/3 of TTL
         if interval is None:
             interval = max(1, self._ttl // 3)
@@ -479,7 +476,7 @@ class RegistryClient:
                         self.logger.warning("ServiceRegistry not responding.")
                         return
                     else:
-                        self.logger.info("Health check succeeded, reregistering ?")
+                        self.logger.info("Health check succeeded, reregistering...")
                         self.reregister()
 
                 else:
@@ -579,10 +576,6 @@ class AsyncRegistryClient:
 
         self._event_handlers = {}
 
-        # Service cache (for discovery)
-        self._service_cache = {}
-        self._service_cache_lock = None
-
         self.req_socket: zmq.asyncio.Socket | None = None
         self.sub_socket: zmq.asyncio.Socket | None = None
         self.hb_socket: zmq.asyncio.Socket | None = None
@@ -609,8 +602,6 @@ class AsyncRegistryClient:
         # Default to receiving all events
         self.sub_socket.setsockopt_string(zmq.SUBSCRIBE, "")
 
-        self._connect_hb_socket()
-
     def _connect_hb_socket(self):
         self.hb_socket = self.context.socket(zmq.REQ)
         self.hb_socket.setsockopt(zmq.LINGER, 0)  # Don't wait for unsent messages on close()
@@ -627,18 +618,12 @@ class AsyncRegistryClient:
             self.sub_socket.close(linger=0)
         self.sub_socket = None
 
-        self._disconnect_hb_socket()
-
     def _disconnect_hb_socket(self):
         if self.hb_socket:
-            self.hb_socket.close(linger=0)
+            self.hb_socket.setsockopt(zmq.LINGER, 0)
+            self.hb_socket.close()
         self.hb_socket = None
 
-    def _get_service_cache_lock(self):
-        if self._service_cache_lock is None:
-            self._service_cache_lock = asyncio.Lock()
-        return self._service_cache_lock
-
     async def _send_request(
         self, msg_type: MessageType, request: dict[str, Any], timeout: float = None
     ) -> dict[str, Any]:
@@ -653,10 +638,10 @@ class AsyncRegistryClient:
         Returns:
             The response from the registry as a dictionary.
         """
-        self.logger.debug(f"Sending request: {request}")
 
         timeout = timeout or self.timeout
         try:
+            self.logger.debug(f"Sending request: {request}")
             await self.req_socket.send_multipart([msg_type.value, json.dumps(request).encode()])
 
             try:
@@ -714,9 +699,9 @@ class AsyncRegistryClient:
             except asyncio.TimeoutError:
                 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)
-                self.hb_socket.connect(self.registry_req_endpoint)
+                self._disconnect_hb_socket()
+                await asyncio.sleep(HEART_BEAT_RECONNECT)
+                self._connect_hb_socket()
                 return {"success": False, "error": "Heartbeat request timed out"}
         except zmq.ZMQError as exc:
             self.logger.error(f"ZMQ error: {exc}", exc_info=True)
@@ -816,6 +801,25 @@ class AsyncRegistryClient:
             self.logger.error(f"Failed to deregister service: {response.get('error')}")
             return False
 
+    async def reregister(self) -> str | None:
+        if not self._service_id:
+            self.logger.warning("Cannot reregister: no service is registered")
+            return None
+
+        if not self._service_info:
+            self.logger.warning(
+                "Cannot reregister: no service info was saved by this registry client or service already deregistered."
+            )
+            return None
+
+        return await self.register(
+            name=self._service_info["name"],
+            host=self._service_info["host"],
+            port=self._service_info["port"],
+            service_type=self._service_info["type"],
+            metadata=self._service_info["metadata"],
+        )
+
     async def start_heartbeat(self, interval: int | None = None) -> asyncio.Task | None:
         """
         Start sending heartbeats to the registry.
@@ -840,6 +844,8 @@ class AsyncRegistryClient:
         self._running = True
 
         async def heartbeat_loop():
+            self._connect_hb_socket()
+
             try:
                 while self._running and self._service_id:
                     try:
@@ -849,8 +855,17 @@ class AsyncRegistryClient:
 
                         if not response.get("success"):
                             self.logger.warning(f"Heartbeat failed: {response.get('error')}")
+
+                            # Do a health check
+                            if not await self.health_check():
+                                self.logger.warning("ServiceRegistry not responding.")
+                                continue
+                            else:
+                                self.logger.info("Health check succeeded, reregistering...")
+                                await self.reregister()
+
                         else:
-                            self.logger.info(response.get("message"))
+                            self.logger.debug(response.get("message"))
                     except Exception as exc:
                         self.logger.error(f"Error in heartbeat loop: {exc}", exc_info=True)
 
@@ -858,6 +873,8 @@ class AsyncRegistryClient:
                     await asyncio.sleep(interval)
             except asyncio.CancelledError:
                 self.logger.info("Heartbeat task cancelled")
+            finally:
+                self._disconnect_hb_socket()
 
         # Start the heartbeat task
         self._heartbeat_task = task = asyncio.create_task(heartbeat_loop())
@@ -960,9 +977,6 @@ class AsyncRegistryClient:
 
                         self.logger.debug(f"Received event: {event_type}")
 
-                        # Update service cache based on events
-                        await self._update_cache_from_event(event_type, event)
-
                         # Call registered handlers
                         handlers = self._event_handlers.get(event_type, [])
                         for handler in handlers:
@@ -990,30 +1004,7 @@ class AsyncRegistryClient:
         self.logger.info("Started event listener task")
         return task
 
-    async def _update_cache_from_event(self, event_type: str, event: dict[str, Any]) -> None:
-        """
-        Update the service cache based on registry events.
-
-        Args:
-            event_type: Type of the event.
-            event: Event data
-        """
-        async with self._get_service_cache_lock():
-            data = event.get("data", {})
-            service_id = data.get("service_id")
-
-            if not service_id:
-                return
-
-            if event_type == "register":
-                service_info = data.get("service_info", {})
-                if service_info:
-                    self._service_cache[service_id] = service_info
-            elif event_type in ("deregister", "expire"):
-                if service_id in self._service_cache:
-                    del self._service_cache[service_id]
-
-    async def discover_service(self, service_type: str, use_cache: bool = True) -> dict[str, Any] | None:
+    async def discover_service(self, service_type: str) -> dict[str, Any] | None:
         """
         Discover a service of the specified type. The service is guaranteed to be healthy at the time of discovery.
 
@@ -1025,27 +1016,11 @@ class AsyncRegistryClient:
 
         Args:
             service_type: Type of service to discover
-            use_cache: Whether to use cached service information
 
         Returns:
             Service information if found, None otherwise
         """
-        # Try to use cache first if enabled
-        if use_cache:
-            async with self._get_service_cache_lock():
-                # Find services of the specified type
-                matching_services = []
-                for service_id, service_info in self._service_cache.items():
-                    if service_info.get("type") == service_type or service_type in service_info.get("tags", []):
-                        matching_services.append(service_info)
-
-                if matching_services:
-                    # Simple load balancing - random selection
-                    import random
-
-                    return random.choice(matching_services)
-
-        # If not found in cache or cache disabled, ask the registry
+
         request = {"action": "discover", "service_type": service_type}
 
         response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request)
@@ -1055,34 +1030,25 @@ class AsyncRegistryClient:
         if response.get("success"):
             service = response.get("service")
 
-            # Update cache
-            if service and "id" in service:
-                async with self._get_service_cache_lock():
-                    self._service_cache[service["id"]] = service
-
             return service
         else:
             self.logger.warning(f"Service discovery failed: {response.get('error')}")
             return None
 
-    async def get_service(self, service_id: str, use_cache: bool = True) -> dict[str, Any] | None:
+    async def get_service(self, service_id: str | None = None) -> dict[str, Any] | None:
         """
-        Get information about a specific service.
+        Get information about a specific service.  When no service_id is given,
+        the service_id known to this client will be used.
 
         Args:
             service_id: ID of the service to get
-            use_cache: Whether to use cached service information
 
         Returns:
             Service information if found, None otherwise
         """
-        # Try to use cache first if enabled
-        if use_cache:
-            async with self._get_service_cache_lock():
-                if service_id in self._service_cache:
-                    return self._service_cache[service_id]
 
-        # If not found in cache or cache disabled, ask the registry
+        service_id = service_id or self._service_id
+
         request = {"action": "get", "service_id": service_id}
 
         response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request)
@@ -1090,11 +1056,6 @@ class AsyncRegistryClient:
         if response.get("success"):
             service = response.get("service")
 
-            # Update cache
-            if service:
-                async with self._get_service_cache_lock():
-                    self._service_cache[service_id] = service
-
             return service
         else:
             self.logger.warning(f"Get service failed: {response.get('error')}")
@@ -1117,12 +1078,6 @@ class AsyncRegistryClient:
         if response.get("success"):
             services = response.get("services", [])
 
-            # Update cache
-            async with self._get_service_cache_lock():
-                for service in services:
-                    if "id" in service:
-                        self._service_cache[service["id"]] = service
-
             return services
         else:
             self.logger.warning(f"List services failed: {response.get('error')}")
@@ -1192,35 +1147,6 @@ class AsyncRegistryClient:
         except Exception as exc:
             self.logger.error(f"Error during cleanup: {exc}")
 
-    @asynccontextmanager
-    async def register_context(self, *args, **kwargs):
-        """
-        Async context manager for service registration.
-
-        Example:
-            async with client.register_context("my-service", "localhost", 8080):
-                # Service is registered
-                await app.start()
-            # Service is automatically deregistered
-        """
-        service_id = await self.register(*args, **kwargs)
-
-        if not service_id:
-            raise RuntimeError("Failed to register service")
-
-        # Start heartbeat and event listener
-        await self.start_heartbeat()
-        await self.start_event_listener()
-
-        try:
-            yield service_id
-        finally:
-            # Clean up
-            await self.stop_event_listener()
-            await self.stop_heartbeat()
-            await self.deregister()
-            # await self.close()  # client shall not be closed by this context manager !!
-
 
 def is_service_registered(service_type: str):
     """Convenience function to check if a service is registered."""

{cgse-0.16.7 → cgse-0.16.9}/libs/cgse-core/src/egse/registry/server.py

@@ -490,6 +490,7 @@ class AsyncRegistryServer:
             "status": "ok",
             "req_port": self.req_port,
             "pub_port": self.pub_port,
+            "hb_port": self.hb_port,
             "services": services,
         }
 
@@ -577,6 +578,7 @@ async def status(
                 Status: {response["status"]}
                 Requests port: {response["req_port"]}
                 Notifications port: {response["pub_port"]}
+                Heartbeat port: {response["hb_port"]}
                 Registrations: {", ".join([f"({x['name']}, {x['health']})" for x in response["services"]])}\
             """
         )

{cgse-0.16.7 → cgse-0.16.9}/libs/cgse-core/src/egse/storage/storage_cs.py

@@ -62,6 +62,8 @@ class StorageControlServer(ControlServer):
 
         multiprocessing.current_process().name = PROCESS_NAME
 
+        self.scheduler: BackgroundScheduler | None = None
+
         self.logger = logger
         self.service_name = PROCESS_NAME
         self.service_type = SERVICE_TYPE
@@ -76,13 +78,6 @@ class StorageControlServer(ControlServer):
 
         self.register_service(service_type=SERVICE_TYPE)
 
-        # NOTE:
-        #     Since the CM CS is started after the SM CS in the normal startup sequence, delay the task to load
-        #     the Setup until after the CM CS has been properly started. We do that now with a delay time of 30s,
-        #     but we might in the future use a function returning a boolean, until...
-        # from egse.confman import is_configuration_manager_active
-        # self.schedule_task(self.device_protocol.controller.load_setup, after=10.0, when=is_configuration_manager_active)
-
     def before_serve(self):
         self.scheduler = BackgroundScheduler(timezone=utc)
         self.scheduler.start()

{cgse-0.16.7 → cgse-0.16.9}/libs/cgse-core/tests/test_registry_service.py

@@ -787,70 +787,3 @@ async def test_client_health_check(client, server):
     """Test health check."""
     health = await client.health_check()
     assert health is True
-
-
-@pytest.mark.asyncio
-async def test_client_caching(client, server):
-    """Test client's service caching."""
-
-    service_id = await client.register("cache-test-service", "localhost", 8080, service_type="cache-test")
-
-    # Look up the service (should populate cache)
-    service = await client.get_service(service_id)
-    assert service is not None
-
-    # Check if it's in the cache
-    async with client._service_cache_lock:
-        assert service_id in client._service_cache
-
-    # Look up by type (should use cache when use_cache=True)
-    with patch.object(client, "_send_request", new_callable=AsyncMock) as mock_send:
-        # First call with use_cache=True should check cache
-        service = await client.discover_service("cache-test", use_cache=True)
-        assert service is not None
-        assert service["id"] == service_id
-
-        # Configure the mock to return a dictionary that matches what _send_request would return
-        mock_send.return_value = {
-            "success": True,
-            "service": {
-                "id": service_id,
-                "name": "cache-test-service",
-                "host": "localhost",
-                "port": 8080,
-                "type": "cache-test",
-            },
-        }
-
-        # Second call with use_cache=False should make a request
-        service = await client.discover_service("cache-test", use_cache=False)
-        assert service is not None
-        assert mock_send.called
-
-
-@pytest.mark.asyncio
-async def test_client_register_context(client, server, req_socket):
-    """Test the register_context context manager."""
-
-    # Use the context manager
-    async with client.register_context(
-        "context-test-service", "localhost", 8080, service_type="context-test"
-    ) as service_id:
-        # Verify the service was registered
-        response = await send_request(
-            MessageType.REQUEST_WITH_REPLY, req_socket, {"action": "get", "service_id": service_id}
-        )
-
-        logger.info(f"----- In test_client_register_context: {response}")
-
-        assert response["success"] is True
-        assert response["service"]["name"] == "context-test-service"
-
-    logger.info("----- In test_client_register_context: after context...")
-
-    # After exiting the context, the service should be deregistered
-    response = await send_request(
-        MessageType.REQUEST_WITH_REPLY, req_socket, {"action": "get", "service_id": service_id}
-    )
-
-    assert response["success"] is False

{cgse-0.16.7 → cgse-0.16.9}/libs/cgse-gui/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/projects/generic/cgse-tools/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/projects/generic/keithley-tempcontrol/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/projects/generic/lakeshore-tempcontrol/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/projects/generic/symetrie-hexapod/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/projects/plato/plato-fits/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/projects/plato/plato-hdf5/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/projects/plato/plato-spw/pyproject.toml

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

{cgse-0.16.7 → cgse-0.16.9}/pyproject.toml

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