cgse-core 0.17.2__tar.gz → 0.17.3__tar.gz

{cgse_core-0.17.2 → cgse_core-0.17.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse-core
-Version: 0.17.2
+Version: 0.17.3
 Summary: Core services for the CGSE framework
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

{cgse_core-0.17.2 → cgse_core-0.17.3}/pyproject.toml

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

cgse_core-0.17.3/src/egse/connect.py

@@ -0,0 +1,55 @@
+from egse.env import bool_env
+from egse.log import logging
+from egse.zmq_ser import connect_address
+
+logger = logging.getLogger("egse.connect")
+
+# random.seed(time.monotonic())  # uncomment for testing only, main application should set a seed.
+
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
+
+
+def get_endpoint(
+    service_type: str,
+    protocol: str = "tcp",
+    hostname: str = "localhost",
+    port: int = 0,
+):
+    """
+    Returns the endpoint for a service, either from the registry or by constructing
+    it from protocol, hostname and port.
+
+    If port is 0 (the default), attempt to retrieve the endpoint from the service registry.
+
+    Args:
+        service_type: The service type to look up in the registry.
+        protocol: Protocol to use if constructing the endpoint, defaults to tcp.
+        hostname: Hostname to use if constructing the endpoint, defaults to localhost.
+        port: Port to use if constructing the endpoint, defaults to 0.
+
+    Returns:
+        The endpoint string.
+
+    Raises:
+        RuntimeError: If no endpoint can be determined.
+    """
+    endpoint = None
+    from egse.registry.client import RegistryClient
+
+    if port == 0:
+        with RegistryClient() as reg:
+            endpoint = reg.get_endpoint(service_type)
+        if endpoint:
+            if VERBOSE_DEBUG:
+                logger.debug(f"Endpoint for {service_type} found in registry: {endpoint}")
+        else:
+            logger.warning(f"No endpoint for {service_type} found in registry.")
+
+    if not endpoint:
+        if port == 0:
+            raise RuntimeError(f"No service registered as {service_type} and no port provided.")
+        endpoint = connect_address(protocol, hostname, port)
+        if VERBOSE_DEBUG:
+            logger.debug(f"Endpoint constructed from protocol/hostname/port: {endpoint}")
+
+    return endpoint

{cgse_core-0.17.2 → cgse_core-0.17.3}/src/egse/dummy.py

@@ -35,7 +35,6 @@ and stopped with:
 
 from __future__ import annotations
 
-import contextlib
 import multiprocessing
 import random
 import select
@@ -53,14 +52,12 @@ from egse.device import DeviceConnectionError
 from egse.device import DeviceConnectionInterface
 from egse.device import DeviceTimeoutError
 from egse.device import DeviceTransport
-from egse.env import bool_env
 from egse.log import logger
 from egse.protocol import CommandProtocol
 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
 
@@ -80,9 +77,6 @@ WRITE_TIMEOUT = 1.0
 CONNECT_TIMEOUT = 3.0
 """The maximum time in seconds to wait for establishing a socket connect."""
 
-
-VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG", default=False)
-
 # Especially DummyCommand and DummyController need to be defined in a known module
 # because those objects are pickled and when de-pickled at the clients side the class
 # definition must be known.
@@ -122,17 +116,14 @@ def is_dummy_cs_active() -> bool:
 
 
 def is_dummy_dev_active() -> bool:
-    if VERBOSE_DEBUG:
-        logger.debug("Checking if dummy device is active...")
     try:
         dev = DummyDeviceEthernetInterface(DEV_HOST, DEV_PORT)
         dev.connect()
         rc = dev.trans("ping\n")
         dev.disconnect()
         return rc.decode().strip() == "pong"
-    except (DeviceConnectionError, ConnectionResetError, DeviceTimeoutError) as exc:
-        if VERBOSE_DEBUG:
-            logger.debug(f"Caught {type_name(exc)}: {exc} - returning False")
+    except DeviceConnectionError as exc:
+        # logger.error(f"Caught {type_name(exc)}: {exc}")
         return False
 
 
@@ -589,18 +580,11 @@ def start_dev():
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
             s.bind((DEV_HOST, DEV_PORT))
             s.listen()
-            s.settimeout(CONNECT_TIMEOUT)
             logger.info(f"Ready to accept connection on {DEV_HOST}:{DEV_PORT}...")
-            while True:
-                with contextlib.suppress(socket.timeout):
-                    conn, addr = s.accept()
-                    break
-                if killer.term_signal_received:
-                    return
+            conn, addr = s.accept()
             with conn:
                 logger.info(f"Accepted connection from {addr}")
                 conn.sendall(f"Dummy Device {__version__}".encode())
-                conn.settimeout(READ_TIMEOUT)
                 try:
                     while True:
                         error_msg = ""

{cgse_core-0.17.2 → cgse_core-0.17.3}/src/egse/logger/__init__.py

@@ -57,7 +57,7 @@ COMMANDER_PORT = settings.get("COMMANDER_PORT", 0)  # dynamically assigned by th
 _initialised = False  # will be set to True in the setup_logging() function
 
 
-def get_log_file_name() -> str:
+def get_log_file_name():
     """
     Returns the filename of the log file as defined in the Settings or return the default name 'general.log'.
     """
@@ -315,7 +315,7 @@ def send_request(command_request: str):
     """Sends a request to the Logger Control Server and waits for a response."""
 
     if COMMANDER_PORT == 0:
-        endpoint = get_endpoint_from_registry(SERVICE_TYPE)
+        endpoint = get_endpoint_from_registry()
     else:
         endpoint = f"{PROTOCOL}://{HOSTNAME}:{COMMANDER_PORT}"
 

{cgse_core-0.17.2 → cgse_core-0.17.3}/src/egse/notifyhub/server.py

@@ -23,12 +23,10 @@ from egse.notifyhub import SERVICE_TYPE
 from egse.notifyhub import STATS_INTERVAL
 from egse.notifyhub.client import AsyncNotificationHubClient
 from egse.registry import MessageType
-from egse.registry.client import REQUEST_TIMEOUT
-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 egse.zmq_ser import get_port_number
-
 from .event import NotificationEvent
 
 REQUEST_POLL_TIMEOUT = 1.0

{cgse_core-0.17.2 → cgse_core-0.17.3}/src/egse/registry/client.py

@@ -639,8 +639,6 @@ class AsyncRegistryClient:
             The response from the registry as a dictionary.
         """
 
-        assert self.req_socket is not None, "REQ socket is not connected, cannot send request."
-
         timeout = timeout or self.timeout
         try:
             self.logger.debug(f"Sending request: {request}")
@@ -689,8 +687,6 @@ class AsyncRegistryClient:
             The response from the registry as a dictionary.
         """
 
-        assert self.hb_socket is not None, "HB socket is not connected, cannot send heartbeat request."
-
         try:
             self.logger.debug(f"Sending heartbeat request: {request}")
             await self.hb_socket.send_string(json.dumps(request))
@@ -871,8 +867,7 @@ class AsyncRegistryClient:
                                 await self.reregister()
 
                         else:
-                            if VERBOSE_DEBUG:
-                                self.logger.debug(f"Heartbeat succeeded: {response.get('message')}")
+                            VERBOSE_DEBUG and self.logger.debug(f"Heartbeat succeeded: {response.get('message')}")
 
                     except Exception as exc:
                         self.logger.error(f"Error in heartbeat loop: {exc}", exc_info=True)
@@ -905,7 +900,6 @@ class AsyncRegistryClient:
         try:
             await self._heartbeat_task
         except asyncio.CancelledError:
-            self.logger.info("Heartbeat task cancelled")
             pass
         self._tasks.discard(self._heartbeat_task)
         self._heartbeat_task = None
@@ -1152,8 +1146,8 @@ class AsyncRegistryClient:
             if hasattr(self, "context") and self.context:
                 self.logger.info(f"{self.context = !r}")
                 self.logger.info(f"{self.context._sockets = !r}")
-                # if not self.context.closed:
-                # self.context.term()
+                if not self.context.closed:
+                    self.context.term()
         except Exception as exc:
             self.logger.error(f"Error during cleanup: {exc}")
 

{cgse_core-0.17.2 → cgse_core-0.17.3}/src/egse/registry/server.py

@@ -218,18 +218,16 @@ class AsyncRegistryServer:
         """Task that handles incoming requests."""
         self.logger.info("Started request handler task")
 
-        assert self.req_socket is not None, "REQ socket is not connected, cannot handle requests."
-
         try:
             message_parts = None
             while self._running:
                 try:
                     # Wait for a request with timeout to allow checking if still running
                     try:
-                        self.logger.info("Waiting for a request with 1s timeout...")
+                        # self.logger.info("Waiting for a request with 1s timeout...")
                         message_parts = await asyncio.wait_for(self.req_socket.recv_multipart(), timeout=1.0)
                     except asyncio.TimeoutError:
-                        self.logger.debug("waiting for command request...")
+                        # self.logger.debug("waiting for command request...")
                         continue
 
                     if len(message_parts) >= 3:
@@ -243,9 +241,6 @@ class AsyncRegistryServer:
                         response = await self._process_request(message_data)
 
                         await self._send_response(client_id, message_type, response)
-                    else:
-                        self.logger.warning("Request handler: message corrupted, check debug messages.")
-                        self.logger.debug(f"{message_parts=}")
 
                 except zmq.ZMQError as exc:
                     self.logger.error(f"ZMQ error: {exc}", exc_info=True)
@@ -402,8 +397,6 @@ class AsyncRegistryServer:
         """Task that handles heartbeat messages."""
         self.logger.info("Started heartbeats handler task")
 
-        assert self.hb_socket is not None, "HB socket is not connected, cannot handle heartbeat messages."
-
         try:
             message_parts = None
             while self._running:
@@ -432,8 +425,7 @@ class AsyncRegistryServer:
                         self.logger.warning("Heartbeat request: message corrupted, check debug messages.")
 
                 except asyncio.TimeoutError:
-                    if VERBOSE_DEBUG:
-                        self.logger.debug("waiting for heartbeat...")
+                    VERBOSE_DEBUG and self.logger.debug("waiting for heartbeat...")
                     continue
 
                 except Exception as exc:

{cgse_core-0.17.2 → cgse_core-0.17.3}/src/egse/registry/service.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 import time
 from typing import Any
 from typing import Callable
@@ -9,14 +10,13 @@ from typing import Callable
 import zmq
 import zmq.asyncio
 
-from egse.log import logging
 from egse.registry import DEFAULT_RS_PUB_PORT
 from egse.registry import DEFAULT_RS_REQ_PORT
 from egse.registry.client import AsyncRegistryClient
 from egse.system import get_host_ip
 from egse.zmq_ser import get_port_number
 
-module_module_logger_name = "egse.async_microservice"
+module_module_logger_name = "async_microservice"
 module_logger = logging.getLogger(module_module_logger_name)
 
 
@@ -64,7 +64,7 @@ class ZMQMicroservice:
         self.registry_sub_endpoint = registry_sub_endpoint or f"tcp://localhost:{DEFAULT_RS_PUB_PORT}"
         self.metadata = metadata or {}
 
-        self.host_ip = get_host_ip() or "localhost"
+        self.host_ip = get_host_ip()
 
         # Service ID will be set when registered
         self.service_id = None
@@ -164,7 +164,6 @@ class ZMQMicroservice:
 
         if not self.service_id:
             module_logger.error("Failed to register with the service registry")
-            await self._cleanup()
             return True
 
         module_logger.info(f"Registered with service ID: {self.service_id}")
@@ -176,17 +175,12 @@ class ZMQMicroservice:
         # Start request handler
         request_task = asyncio.create_task(self._handle_requests())
         self._tasks.add(request_task)
-        # request_task.add_done_callback(self._tasks.discard)
+        request_task.add_done_callback(self._tasks.discard)
 
         # Wait for shutdown signal
         await self._shutdown.wait()
 
-        # request_task.cancel()
-        # try:
-        #     await request_task
-        # except asyncio.CancelledError:
-        #     module_logger.info("Request handler task cancelled during shutdown")
-
+        # Clean shutdown
         await self._cleanup()
 
         return False