cgse-core 0.17.2__py3-none-any.whl → 0.17.3__py3-none-any.whl

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

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}")
 

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:

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