cgse 0.16.5__tar.gz → 0.16.7__tar.gz

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

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

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

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-common/src/egse/signal.py

@@ -158,7 +158,7 @@ class FileBasedSignaling:
         """Terminate the monitoring loop thread."""
         self.running = False
         if self.thread.is_alive():
-            self.thread.join(timeout=1)
+            self.thread.join(timeout=1.0)
 
 
 def create_signal_command_file(signal_dir: Path, service_id: str, command: dict) -> None:

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-common/tests/test_influxdb_plugin.py

@@ -20,7 +20,9 @@ def test_influxdb_access():
     influxdb = get_metrics_repo("influxdb", {"host": "http://localhost:8181", "database": "ARIEL", "token": token})
     influxdb.connect()
 
-    result = influxdb.query("SELECT * FROM cm ORDER BY TIME DESC LIMIT 20", mode="pandas")
+    result = influxdb.query(
+        "SELECT * FROM cm WHERE time >= now() - INTERVAL '2 days' ORDER BY TIME DESC LIMIT 20", mode="pandas"
+    )
     print(result)
     assert isinstance(result, pd.DataFrame)
 

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-common/tests/test_metrics.py

@@ -9,7 +9,11 @@ def test_get_metrics_repo():
     influxdb = get_metrics_repo("influxdb", {"host": "http://localhost:8181", "database": "ARIEL", "token": token})
     influxdb.connect()
 
-    result = influxdb.query("SELECT * FROM cm ORDER BY TIME DESC LIMIT 20", mode="pandas")
+    # Don't use a too large time interval here, or you will get an error like:
+    # 'External error: Query would exceed file limit of 432 parquet files'
+    result = influxdb.query(
+        "SELECT * FROM cm WHERE time >= now() - INTERVAL '2 days' ORDER BY TIME DESC LIMIT 20", mode="pandas"
+    )
     print(result)
 
     # result = influxdb.query("SHOW TABLES;")

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

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

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

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

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/confman/__init__.py

@@ -177,11 +177,13 @@ HOSTNAME = settings.get("HOSTNAME", "localhost")
 COMMANDING_PORT = settings.get("COMMANDING_PORT", 0)
 SERVICE_PORT = settings.get("SERVICE_PORT", 0)
 MONITORING_PORT = settings.get("MONITORING_PORT", 0)
+STORAGE_MNEMONIC = settings.get("STORAGE_MNEMONIC", "CM")
+SERVICE_TYPE = settings.get("SERVICE_TYPE", "cm_cs")
 
 # CM_SETUP_ID = Gauge("CM_SETUP_ID", 'Setup ID')
 # CM_TEST_ID = Gauge("CM_TEST_ID", 'Test ID')
 
-PROXY_TIMEOUT = 10_000  # don't wait longer than 10s by default
+PROXY_TIMEOUT = 10.0  # don't wait longer than 10s by default
 
 
 def _push_setup_to_repo(filename: str, commit_msg: str) -> Failure | Success:
@@ -982,6 +984,7 @@ class ConfigurationManagerProxy(Proxy, ConfigurationManagerInterface):
             from settings file]
         port: TCP port on which the control server is listening for commands
             [default is taken from settings file]
+        timeout: number of fractional seconds before a timeout is triggered
     """
 
     def __init__(

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/confman/confman_cs.py

@@ -22,12 +22,16 @@ from rich.console import Console
 
 from egse.confman import ConfigurationManagerProtocol
 from egse.confman import ConfigurationManagerProxy
-from egse.confman import PROCESS_NAME
-from egse.confman import PROTOCOL
-from egse.confman import HOSTNAME
-from egse.confman import COMMANDING_PORT
-from egse.confman import SERVICE_PORT
-from egse.confman import MONITORING_PORT
+from egse.confman import (
+    PROCESS_NAME,
+    PROTOCOL,
+    HOSTNAME,
+    COMMANDING_PORT,
+    SERVICE_PORT,
+    MONITORING_PORT,
+    STORAGE_MNEMONIC,
+    SERVICE_TYPE,
+)
 
 from egse.control import ControlServer
 from egse.env import get_conf_data_location
@@ -66,7 +70,7 @@ class ConfigurationManagerControlServer(ControlServer):
 
         self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
 
-        self.register_service(service_type=settings.SERVICE_TYPE)
+        self.register_service(service_type=SERVICE_TYPE)
 
         self.set_hk_delay(10.0)
 
@@ -85,10 +89,7 @@ class ConfigurationManagerControlServer(ControlServer):
         return get_port_number(self.dev_ctrl_mon_sock) or MONITORING_PORT
 
     def get_storage_mnemonic(self):
-        try:
-            return settings.STORAGE_MNEMONIC
-        except AttributeError:
-            return "CM"
+        return STORAGE_MNEMONIC
 
     def is_storage_manager_active(self):
         from egse.storage import is_storage_manager_active

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/control.py

@@ -132,8 +132,6 @@ class ControlServer(metaclass=abc.ABCMeta):
         self.registry = RegistryClient()
         self.registry.connect()
 
-        self.service_id = None
-
         # These instance variables will probably be overwritten by the subclass __init__
         self.service_type = camel_to_kebab(type(self).__name__)
         self.service_name = camel_to_snake(type(self).__name__)
@@ -620,27 +618,15 @@ class ControlServer(metaclass=abc.ABCMeta):
     def setup_signaling(self):
         self.signaling = FileBasedSignaling(self.service_name)
         self.signaling.start_monitoring()
-        self.signaling.register_handler("reregister", self._reregister_service)
-
-    def _reregister_service(self, force: bool = False):
-        self.logger.info(f"Re-registration of service: {self.service_name} ({force=})")
-
-        if self.registry.get_service(self.service_id):
-            if force:
-                self.deregister_service()
-            else:
-                return
-
-        # FIXME: not sure if the stop heartbeat is necessary here, but I see that after
-        #        a re-registration signal, the heartbeat socket is None.
-        # self.registry.stop_heartbeat()
-
-        self.register_service(self.service_type)
+        self.signaling.register_handler("reregister", self.reregister_service)
 
-    def register_service(self, service_type: str):
+    def register_service(self, service_type: str) -> None:
         self.logger.info(f"Registering service {self.service_name} as type {service_type}")
+
         self.service_type = service_type
-        self.service_id = self.registry.register(
+
+        self.registry.stop_heartbeat()
+        self.registry.register(
             name=self.service_name,
             host=get_host_ip() or "127.0.0.1",
             port=get_port_number(self.dev_ctrl_cmd_sock),
@@ -655,7 +641,18 @@ class ControlServer(metaclass=abc.ABCMeta):
     def deregister_service(self):
         if self.registry:
             self.registry.stop_heartbeat()
-            self.registry.deregister(self.service_id)
+            self.registry.deregister()
+
+    def reregister_service(self, force: bool = False) -> None:
+        self.logger.info(f"Re-registration of service: {self.service_name} ({force=})")
+
+        if self.registry.get_service():
+            if force:
+                self.deregister_service()
+            else:
+                return
+
+        self.register_service(self.service_type)
 
     def store_housekeeping_information(self, data: dict) -> None:
         """Sends housekeeping information to the Storage Manager.

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/dummy.py

@@ -35,15 +35,11 @@ and stopped with:
 
 from __future__ import annotations
 
-import contextlib
 import multiprocessing
 import random
 import select
 import socket
 import sys
-import threading
-import time
-from functools import partial
 
 import typer
 import zmq
@@ -62,7 +58,6 @@ from egse.proxy import Proxy
 from egse.system import SignalCatcher
 from egse.system import attrdict
 from egse.system import format_datetime
-from egse.system import type_name
 from egse.zmq_ser import bind_address
 from egse.zmq_ser import connect_address
 
@@ -96,7 +91,7 @@ ctrl_settings = attrdict(
         "SERVICE_PORT": 4444,
         "MONITORING_PORT": 4445,
         "PROTOCOL": "tcp",
-        "TIMEOUT": 10_000,  # milliseconds
+        "TIMEOUT": 10.0,
         "HK_DELAY": 1.0,
     }
 )
@@ -172,7 +167,7 @@ class DummyProxy(Proxy, DummyInterface):
         protocol: the transport protocol [default is taken from settings file]
         hostname: location of the control server (IP address) [default is taken from settings file]
         port: TCP port on which the control server is listening for commands [default is taken from settings file]
-        timeout: a socket timeout in milliseconds
+        timeout: a socket timeout in seconds
     """
 
     def __init__(
@@ -180,7 +175,7 @@ class DummyProxy(Proxy, DummyInterface):
         protocol: str = ctrl_settings.PROTOCOL,
         hostname: str = ctrl_settings.HOSTNAME,
         port: int = ctrl_settings.COMMANDING_PORT,
-        timeout: int = ctrl_settings.TIMEOUT,
+        timeout: float = ctrl_settings.TIMEOUT,
     ):
         super().__init__(connect_address(protocol, hostname, port), timeout=timeout)
 

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/logger/log_cs.py

@@ -254,7 +254,7 @@ def start():
     commander.close(linger=0)
     receiver.close(linger=0)
 
-    if not is_service_registered:
+    if is_service_registered:
         client.stop_heartbeat()
         client.deregister(service_id)
 

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/notifyhub/services.py

@@ -111,7 +111,7 @@ class AsyncEventSubscriber:
 
         while self.running:
             try:
-                if await self.subscriber.poll(timeout=1000):
+                if await self.subscriber.poll(timeout=1000):  # timeout in milliseconds
                     topic, message_bytes = await self.subscriber.recv_multipart()
 
                     event_type = topic.decode()
@@ -269,7 +269,7 @@ class EventSubscriber:
         return self.subscriber
 
     def poll(self, timeout=1000):
-        return self.subscriber.poll(timeout=timeout)
+        return self.subscriber.poll(timeout=timeout)  # timeout in milliseconds
 
     def handle_event(self, return_event_data: bool = False) -> dict:
         topic, message_bytes = self.subscriber.recv_multipart()

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/procman/__init__.py

@@ -22,12 +22,17 @@ LOGGER = logging.getLogger("egse.procman")
 
 settings = Settings.load("Process Manager Control Server")
 COMMAND_SETTINGS = Settings.load(location=HERE, filename="procman.yaml")
-PROXY_TIMEOUT = 10_000
 
+PROXY_TIMEOUT = 10.0  # don't wait longer than 10s
+
+PROCESS_NAME = settings.get("PROCESS_NAME", "pm_cs")
 SERVICE_TYPE = settings.get("SERVICE_TYPE", "pm_cs")
 PROTOCOL = settings.get("PROTOCOL", "tcp")
 HOSTNAME = settings.get("HOSTNAME", "localhost")
 COMMANDING_PORT = settings.get("COMMANDING_PORT", 0)  # dynamically assigned by the system if 0
+SERVICE_PORT = settings.get("SERVICE_PORT", 0)
+MONITORING_PORT = settings.get("MONITORING_PORT", 0)
+STORAGE_MNEMONIC = settings.get("STORAGE_MNEMONIC", "PM")
 
 
 def is_process_manager_active(timeout: float = 0.5) -> bool:
@@ -394,7 +399,11 @@ class ProcessManagerProxy(Proxy, ProcessManagerInterface):
     """Proxy for process management, used to connect to the Process Manager Control Server and send commands remotely."""
 
     def __init__(
-        self, protocol: str = PROTOCOL, hostname: str = HOSTNAME, port: int = COMMANDING_PORT, timeout=PROXY_TIMEOUT
+        self,
+        protocol: str = PROTOCOL,
+        hostname: str = HOSTNAME,
+        port: int = COMMANDING_PORT,
+        timeout: float = PROXY_TIMEOUT,
     ):
         """
         Initialisation of a new Proxy for Process Management.
@@ -406,6 +415,7 @@ class ProcessManagerProxy(Proxy, ProcessManagerInterface):
             protocol (str): Transport protocol
             hostname (str): Location of the control server (IP address)
             port (int): TCP port on which the Control Server is listening for commands
+            timeout (float): number of fractional seconds before a timeout occurs
         """
 
         endpoint = get_endpoint(settings.SERVICE_TYPE, protocol, hostname, port)

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/procman/procman_cs.py

@@ -21,7 +21,16 @@ from egse.process import SubProcess
 from egse.procman.procman_protocol import ProcessManagerProtocol
 from egse.registry.client import RegistryClient
 from egse.services import ServiceProxy
-from egse.settings import Settings
+from egse.procman import (
+    PROCESS_NAME,
+    SERVICE_TYPE,
+    PROTOCOL,
+    COMMANDING_PORT,
+    SERVICE_PORT,
+    MONITORING_PORT,
+    HOSTNAME,
+    STORAGE_MNEMONIC,
+)
 from egse.storage import store_housekeeping_information
 from egse.zmq_ser import get_port_number
 
@@ -29,15 +38,6 @@ from egse.zmq_ser import get_port_number
 
 logger = logging.getLogger("egse.procman")
 
-settings = Settings.load("Process Manager Control Server")
-
-PROCESS_NAME = settings.get("PROCESS_NAME", "cm_cs")
-PROTOCOL = settings.get("PROTOCOL", "tcp")
-HOSTNAME = settings.get("HOSTNAME", "localhost")
-COMMANDING_PORT = settings.get("COMMANDING_PORT", 0)
-SERVICE_PORT = settings.get("SERVICE_PORT", 0)
-MONITORING_PORT = settings.get("MONITORING_PORT", 0)
-
 
 class ProcessManagerControlServer(ControlServer):
     def __init__(self):
@@ -47,7 +47,7 @@ class ProcessManagerControlServer(ControlServer):
 
         self.logger = logger
         self.service_name = PROCESS_NAME
-        self.service_type = settings.SERVICE_TYPE
+        self.service_type = SERVICE_TYPE
 
         self.device_protocol = ProcessManagerProtocol(self)
 
@@ -57,7 +57,7 @@ class ProcessManagerControlServer(ControlServer):
 
         self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
 
-        self.register_service(service_type=settings.SERVICE_TYPE)
+        self.register_service(service_type=SERVICE_TYPE)
 
         self.set_hk_delay(10.0)
 
@@ -76,10 +76,7 @@ class ProcessManagerControlServer(ControlServer):
         return get_port_number(self.dev_ctrl_mon_sock) or MONITORING_PORT
 
     def get_storage_mnemonic(self):
-        try:
-            return settings.STORAGE_MNEMONIC
-        except AttributeError:
-            return "PM"
+        return STORAGE_MNEMONIC
 
     def is_storage_manager_active(self):
         from egse.storage import is_storage_manager_active

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

@@ -31,7 +31,7 @@ def set_docstring(func, cmd):
     return wrap_func
 
 
-REQUEST_TIMEOUT = 30 * 1000  # timeout in millisecond
+REQUEST_TIMEOUT = 30.0  # timeout in seconds
 REQUEST_RETRIES = 0
 
 
@@ -93,10 +93,13 @@ class ControlServerConnectionInterface:
 
 
 class BaseProxy(ControlServerConnectionInterface):
-    def __init__(self, endpoint: str, timeout: int = REQUEST_TIMEOUT):
+    def __init__(self, endpoint: str, timeout: float = REQUEST_TIMEOUT):
         """
-        The `timeout` argument specifies the number of milliseconds to wait for a reply from the
-        control server.
+        The endpoint is a string that is constructed from the protocol, hostname
+         and port number and has the format: `protocol://hostname:port`.
+
+        The `timeout` argument specifies the number of fractional seconds to wait
+        for a reply from the control server.
         """
 
         self._logger = logging.getLogger(self.__class__.__name__)
@@ -150,7 +153,7 @@ class BaseProxy(ControlServerConnectionInterface):
     def is_cs_connected(self) -> bool:
         return self.ping()
 
-    def send(self, data, retries: int = REQUEST_RETRIES, timeout: int = None):
+    def send(self, data, retries: int = REQUEST_RETRIES, timeout: float | None = None):
         """
         Sends a command to the control server and waits for a response.
 
@@ -166,14 +169,14 @@ class BaseProxy(ControlServerConnectionInterface):
         Args:
             data (str): the command that is sent to the control server, usually a
                 string, but that is not enforced.
-            timeout (int): the time to wait for a reply [in milliseconds]
+            timeout (int): the time to wait for a reply [in seconds]
             retries (int): the number of time we should retry to send the message
 
         Returns:
             response: the response from the control server or ``None`` when there was
                 a problem or a timeout.
         """
-        timeout = timeout or self._timeout
+        timeout_ms = int((timeout or self._timeout) * 1000)
 
         pickle_string = pickle.dumps(data)
 
@@ -192,7 +195,7 @@ class BaseProxy(ControlServerConnectionInterface):
         self._socket.send(pickle_string)
 
         while True:
-            socks = dict(self._poller.poll(timeout))
+            socks = dict(self._poller.poll(timeout_ms))
 
             if self._socket in socks and socks[self._socket] == zmq.POLLIN:
                 pickle_string = self._socket.recv()
@@ -223,7 +226,7 @@ class BaseProxy(ControlServerConnectionInterface):
                 self._socket.send(pickle_string)
 
     def ping(self):
-        return_code = self.send("Ping", retries=0, timeout=1000)
+        return_code = self.send("Ping", retries=0, timeout=1.0)
         self._logger.log(0, f"Check if control server is available: Ping - {return_code}")
         return return_code == "Pong"
 
@@ -278,7 +281,7 @@ class Proxy(BaseProxy, ControlServerConnectionInterface):
     during initialization, a ConnectionError will be raised.
     """
 
-    def __init__(self, endpoint, timeout: int = REQUEST_TIMEOUT):
+    def __init__(self, endpoint, timeout: float = REQUEST_TIMEOUT):
         """
         During initialization, the Proxy will connect to the control server and send a
         handshaking `Ping` command. When that succeeds the Proxy will request and load the
@@ -287,7 +290,7 @@ class Proxy(BaseProxy, ControlServerConnectionInterface):
         can fix the problem with the control server and call `connect_cs()`, followed by a call to
         `load_commands()`.
 
-        The `timeout` argument specifies the number of milliseconds
+        The `timeout` argument specifies the number of seconds
         """
 
         super().__init__(endpoint, timeout)

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

@@ -310,6 +310,25 @@ class RegistryClient:
             self.logger.error(f"Failed to deregister service: {response.get('error')}")
             return False
 
+    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 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"],
+        )
+
     def discover_service(self, service_type: str, use_cache: bool = False) -> dict[str, Any] | None:
         """
         Discover a service of the specified type. The service is guaranteed to be healthy at the time of discovery.
@@ -344,17 +363,23 @@ class RegistryClient:
             self.logger.warning(f"Service discovery failed: {response.get('error')}")
             return None
 
-    def get_service(self, service_id: str, use_cache: bool = True) -> dict[str, Any] | None:
+    def get_service(self, service_id: str | None = None, use_cache: bool = True) -> 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
+            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.
         """
+        service_id = service_id or self._service_id
+
+        if not service_id:
+            self.logger.warning("Cannot get service: no service id is given or known.")
+            return None
 
         request = {"action": "get", "service_id": service_id}
 
@@ -453,6 +478,9 @@ class RegistryClient:
                     if not self.health_check():
                         self.logger.warning("ServiceRegistry not responding.")
                         return
+                    else:
+                        self.logger.info("Health check succeeded, reregistering ?")
+                        self.reregister()
 
                 else:
                     self.logger.debug(response.get("message"))

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

@@ -22,6 +22,7 @@ import typer
 import zmq
 import zmq.asyncio
 
+from egse.env import bool_env
 from egse.logger import remote_logging
 from egse.registry import DEFAULT_RS_DB_PATH
 from egse.registry import DEFAULT_RS_HB_PORT
@@ -39,6 +40,8 @@ from egse.system import get_logging_level
 
 settings = Settings.load("Service Registry")
 
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
+
 app = typer.Typer(name="rs_cs")
 
 
@@ -234,7 +237,9 @@ class AsyncRegistryServer:
                         message_type = MessageType(message_parts[1])
                         message_data = message_parts[2]
 
-                        self.logger.info(f"{client_id = }, {message_type = }, {message_data = }")
+                        if VERBOSE_DEBUG:
+                            self.logger.debug(f"{client_id = }, {message_type = }, {message_data = }")
+
                         response = await self._process_request(message_data)
 
                         await self._send_response(client_id, message_type, response)
@@ -274,7 +279,7 @@ class AsyncRegistryServer:
         """
         try:
             request = json.loads(msg_data.decode())
-            self.logger.info(f"Received request: {request}")
+            self.logger.debug(f"Received request: {request}")
 
         except json.JSONDecodeError as exc:
             self.logger.error(f"Invalid JSON received: {exc}")
@@ -377,7 +382,7 @@ class AsyncRegistryServer:
         """Handle a service heartbeat request."""
         service_id = request.get("service_id")
 
-        self.logger.info(f"Handle renew request: {request}")
+        self.logger.debug(f"Handle renew request: {request}")
 
         if not service_id:
             return {"success": False, "error": "Missing required field: service_id"}
@@ -428,7 +433,7 @@ class AsyncRegistryServer:
 
         service_id = request.get("service_id")
 
-        self.logger.info(f"Handle get request: {request}")
+        self.logger.debug(f"Handle get request: {request}")
 
         if not service_id:
             return {"success": False, "error": "Missing required field: service_id"}
@@ -445,7 +450,7 @@ class AsyncRegistryServer:
         """Handle a request to list services."""
         service_type = request.get("service_type")
 
-        self.logger.info(f"Handle list request: {request}")
+        self.logger.debug(f"Handle list request: {request}")
 
         # List the services
         services = await self.backend.list_services(service_type)
@@ -459,7 +464,7 @@ class AsyncRegistryServer:
         """Handle a service discovery request."""
         service_type = request.get("service_type")
 
-        self.logger.info(f"Handle discover request for service type: {service_type}")
+        self.logger.debug(f"Handle discover request for service type: {service_type}")
 
         if not service_type:
             return {"success": False, "error": "Missing required field: service_type"}
@@ -475,7 +480,7 @@ class AsyncRegistryServer:
     async def _handle_info(self, request: dict[str, Any]) -> dict[str, Any]:
         """Handle the info request and send information about the registry server."""
 
-        self.logger.info(f"Handle info request: {request}")
+        self.logger.debug(f"Handle info request: {request}")
 
         # List the services
         services = await self.backend.list_services()
@@ -491,14 +496,14 @@ class AsyncRegistryServer:
     async def _handle_health(self, request: dict[str, Any]) -> dict[str, Any]:
         """Handle a health check request."""
 
-        self.logger.info(f"Handle health request: {request}")
+        self.logger.debug(f"Handle health request: {request}")
 
         return {"success": True, "status": "ok", "timestamp": int(time.time())}
 
     async def _handle_terminate(self, request: dict[str, Any]) -> dict[str, Any]:
         """Handle a termination request."""
 
-        self.logger.info(f"Handle termination request: {request}")
+        self.logger.debug(f"Handle termination request: {request}")
 
         self.stop()
 

{cgse-0.16.5 → cgse-0.16.7}/libs/cgse-core/src/egse/services.py

@@ -227,7 +227,7 @@ class ServiceProxy(Proxy, ServiceInterface):
         protocol: str = "tcp",
         hostname: str = None,
         port: int = None,
-        timeout: int = REQUEST_TIMEOUT,
+        timeout: float = REQUEST_TIMEOUT,
     ):
         """
         The Service Proxy class is used to send service commands to the control server.
@@ -237,7 +237,7 @@ class ServiceProxy(Proxy, ServiceInterface):
             protocol: the transport protocol [default: tcp]
             hostname: the IP address of the control server
             port: the port on which the control server is listening for service commands
-            timeout: number of milliseconds before a timeout is triggered
+            timeout: number of fractional seconds before a timeout is triggered
         """
 
         if hostname is None or port is None: