cgse 0.16.3__tar.gz → 0.16.4__tar.gz

{cgse-0.16.3 → cgse-0.16.4}/PKG-INFO

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

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

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-coordinates/pyproject.toml

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

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/pyproject.toml

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

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/async_control_claude.py

@@ -805,91 +805,3 @@ class ControlServer(abc.ABC):
             the `egse.storage` module might not be available, it is provided by the `cgse-core` package.
         """
         pass
-
-    async def notify_listeners(self, event_id: int = 0, context: dict = None):
-        """
-        Notifies registered listeners about an event.
-
-        This function creates an Event object with the provided `event_id` and `context`
-        and notifies all registered listeners with the created event.
-
-        Args:
-            event_id (int, optional): The identifier for the event. Defaults to 0.
-            context (dict, optional): Additional context information associated with the event.
-                Defaults to None.
-
-        Note:
-            The notification is performed by the `notify_listeners` method of the `listeners` object
-            associated with this instance.
-            The notification is executed as a task to avoid blocking the commanding chain.
-        """
-        self.logger.info(f"Notifying listeners for {EVENT_ID(event_id).name}")
-
-        # Create a task for notification instead of a daemon thread
-        event = Event(event_id=event_id, context=context)
-        asyncio.create_task(self.listeners.notify_listeners_async(event))
-
-    def get_listener_names(self):
-        return self.listeners.get_listener_names()
-
-    async def register_as_listener(self, proxy: Type, listener: dict):
-        """
-        Registers a listener with the specified proxy.
-
-        This function attempts to add the provided listener to the specified proxy.
-        It employs a retry mechanism to handle potential ConnectionError exceptions.
-
-        Args:
-            proxy: A callable object representing the proxy to which the listener will be added.
-            listener (dict): The listener to be registered. Should be a dictionary containing
-                listener details.
-
-        Raises:
-            ConnectionError: If the connection to the proxy encounters issues even after
-                multiple retry attempts.
-        """
-
-        @retry_with_exponential_backoff(exceptions=[ConnectionError])
-        async def _add_listener(proxy, listener):
-            async with proxy() as x, x.get_service_proxy() as srv:
-                rc = await srv.add_listener_async(listener)
-                _LOGGER.info(f"Response from {proxy.__name__} service add_listener: {rc}")
-
-        _LOGGER.info(f"Registering {self.__class__.__name__} as a listener to {proxy.__name__}")
-        await _add_listener(proxy, listener)
-
-    async def unregister_as_listener(self, proxy: Type, listener: dict):
-        """
-        Removes a registered listener from the specified proxy.
-
-        This function attempts to remove the provided listener from the specified proxy.
-        It employs a retry mechanism to handle potential ConnectionError exceptions.
-
-        Args:
-            proxy: A callable object representing the proxy from which the listener will be removed.
-            listener (dict): The listener to be removed. Should be a dictionary containing
-                listener details.
-
-        Raises:
-            ConnectionError: If the connection to the proxy encounters issues even after
-                multiple retry attempts.
-        """
-
-        @retry(times=5, exceptions=[ConnectionError])
-        async def _remove_listener(proxy, listener):
-            async with proxy() as x, x.get_service_proxy() as srv:
-                rc = await srv.remove_listener_async(listener)
-                _LOGGER.debug(f"Response from remove_listener: {rc=}")
-
-        # Check if the CS is available
-        try:
-            async with proxy():
-                pass
-        except ConnectionError:
-            _LOGGER.warning(
-                f"The {proxy.__class__.__name__} endpoint is not responding, {listener['name']} not un-registered."
-            )
-            return
-
-        _LOGGER.info(f"Removing {self.__class__.__name__} as a listener from {proxy.__name__}")
-        await _remove_listener(proxy, listener)

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/confman/__init__.py

@@ -138,7 +138,6 @@ from egse.env import get_conf_repo_location
 from egse.env import get_project_name
 from egse.env import get_site_id
 from egse.exceptions import InternalError
-from egse.listener import EVENT_ID
 from egse.log import logger
 from egse.notifyhub.event import NotificationEvent
 from egse.notifyhub.services import EventPublisher
@@ -552,10 +551,6 @@ class ConfigurationManagerInterface:
     def get_setup_for_obsid(self, obsid):
         raise NotImplementedError
 
-    @dynamic_interface
-    def get_listener_names(self):
-        raise NotImplementedError
-
 
 class ConfigurationManagerController(ConfigurationManagerInterface):
     """Handles the commands that are sent to the configuration manager.
@@ -763,12 +758,6 @@ class ConfigurationManagerController(ConfigurationManagerInterface):
             self._sut_name = _get_sut_id_for_setup(self._setup)
             logger.info(f"New Setup loaded from {setup_file}")
             save_last_setup_id(self._setup_id)
-            if self._control_server:
-                logger.info("Notifying listeners for a new Setup!")
-                with Timer(f"Notify Listeners for Setup change, Setup={self._setup_id}"):
-                    self._control_server.notify_listeners(
-                        EVENT_ID.SETUP, {"event_type": "new_setup", "setup_id": self._setup_id}
-                    )
 
             with EventPublisher() as pub:
                 pub.publish(
@@ -952,12 +941,6 @@ class ConfigurationManagerController(ConfigurationManagerInterface):
             logger.info(f"New Setup was submitted and loaded: {setup_id=}")
             self._sut_name = self._setup.camera.ID.lower()
             save_last_setup_id(setup_id)
-            if self._control_server:
-                logger.info("Notifying listeners for a new Setup!")
-                with Timer(f"Notify Listeners for Setup change, Setup={self._setup_id}"):
-                    self._control_server.notify_listeners(
-                        EVENT_ID.SETUP, {"event_type": "new_setup", "setup_id": setup_id}
-                    )
 
             with EventPublisher() as pub:
                 pub.publish(
@@ -980,10 +963,6 @@ class ConfigurationManagerController(ConfigurationManagerInterface):
 
         return int(setup_id) + 1
 
-    def get_listener_names(self):
-        """Returns the names of the control servers that are listening for a new Setup."""
-        return self._control_server.get_listener_names()
-
 
 class ConfigurationManagerCommand(ClientServerCommand):
     pass
@@ -1119,7 +1098,6 @@ def get_status():
                     Monitoring port: {cm.get_monitoring_port()}
                     Commanding port: {cm.get_commanding_port()}
                     Service port: {cm.get_service_port()}
-                    Listeners: {", ".join(cm.get_listener_names())}
                 """
             )
     except ConnectionError as exc:

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/confman/confman.yaml

@@ -62,9 +62,6 @@ Commands:
         description:    Submit a (new) Setup to the configuration manager. The Setup will be
                         assigned a unique identifier and committed to the git repository.
         cmd:            "{setup} {description} {replace}"
-
-    get_listener_names:
-        description:    Returns a list of names of listeners that need to be notified when a new Setup is loaded.
     
     # Commands that are mainly used by the ProcessManager
 

cgse-0.16.4/libs/cgse-core/src/egse/connect.py

@@ -0,0 +1,50 @@
+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.
+
+
+def get_endpoint(
+    service_type: str,
+    protocol: str = None,
+    hostname: str = None,
+    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.
+        hostname: Hostname to use if constructing the endpoint.
+        port: Port to use if constructing the endpoint.
+
+    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:
+            logger.info(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)
+        logger.info(f"Endpoint constructed from protocol/hostname/port: {endpoint}")
+
+    return endpoint

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/control.py

@@ -634,6 +634,7 @@ class ControlServer(metaclass=abc.ABCMeta):
         # 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)
 
     def register_service(self, service_type: str):
@@ -748,127 +749,3 @@ class ControlServer(metaclass=abc.ABCMeta):
         """
 
         pass
-
-    def notify_listeners(self, event_id: int = 0, context: dict = None):
-        """
-        Notifies registered listeners about an event.
-
-        This function creates an Event object with the provided `event_id` and `context`
-        and notifies all registered listeners with the created event.
-
-        Args:
-            event_id (int, optional): The identifier for the event. Defaults to 0.
-            context (dict, optional): Additional context information associated with the event.
-                Defaults to None.
-
-        Note:
-            The notification is performed by the `notify_listeners` method of the `listeners` object
-            associated with this instance.
-            The notification is executed in a daemon thread to avoid blocking the commanding
-            chain.
-
-        """
-        from egse.listener import Event, EVENT_ID
-
-        self.logger.info(f"Notifying listeners for {EVENT_ID(event_id).name}")
-
-        retry_thread = threading.Thread(
-            target=self.listeners.notify_listeners, args=(Event(event_id=event_id, context=context),)
-        )
-        retry_thread.daemon = True
-        retry_thread.start()
-
-    def get_listener_names(self):
-        return self.listeners.get_listener_names()
-
-    def register_as_listener(self, proxy: Type, listener: dict):
-        """
-        Registers a listener with the specified proxy.
-
-        This function attempts to add the provided listener to the specified proxy.
-        It employs a retry mechanism to handle potential ConnectionError exceptions,
-        making up to 5 attempts to add the listener.
-
-        Args:
-            proxy: A callable object representing the proxy to which the listener will be added.
-            listener (dict): The listener to be registered. Should be a dictionary containing
-                listener details.
-
-        Raises:
-            ConnectionError: If the connection to the proxy encounters issues even after
-                multiple retry attempts.
-
-        Note:
-            The function runs in a separate daemon thread to avoid blocking the main thread.
-
-        """
-
-        @retry_with_exponential_backoff(exceptions=[ConnectionError])
-        def _add_listener(proxy, listener):
-            try:
-                with proxy() as x, x.get_service_proxy() as srv:
-                    response = srv.add_listener(listener)
-                    logger.info(f"Response from {proxy.__name__} service add_listener: {response}")
-            except Exception as exc:
-                logger.error(f"Caught {type_name(exc)}: {exc} – listener '{listener['name']}' could not be registered")
-
-        logger.info(f"Registering {self.__class__.__name__} as a listener to {proxy.__name__}")
-
-        retry_thread = threading.Thread(target=_add_listener, args=(proxy, listener))
-        retry_thread.daemon = True
-        retry_thread.start()
-
-    def unregister_as_listener(self, proxy: Type, listener: dict):
-        """
-        Removes a registered listener from the specified proxy.
-
-        This function attempts to remove the provided listener from the specified proxy.
-        It employs a retry mechanism to handle potential ConnectionError exceptions,
-        making up to 5 attempts to add the listener.
-
-        Args:
-            proxy: A callable object representing the proxy from which the listener will be removed.
-            listener (dict): The listener to be removed. Should be a dictionary containing
-                listener details.
-
-        Raises:
-            ConnectionError: If the connection to the proxy encounters issues even after
-                multiple retry attempts.
-
-        Note:
-            The function runs in a separate thread but will block until the de-registration is finished.
-            The reason being that this method is usually called in a `after_serve` block so it needs to
-            finish before the ZeroMQ context is destroyed.
-
-        """
-
-        @retry(times=5, exceptions=[ConnectionError])
-        def _remove_listener(proxy, listener):
-            with proxy() as x, x.get_service_proxy() as srv:
-                rc = srv.remove_listener(listener)
-                logger.debug(f"Response from remove_listener: {rc=}")
-
-        # Since we do not have the endpoint available, we can not check if the CS is active, and to get the endpoint
-        # we have to use the proxy anyway. So, let's use the proxy object to check if the CS is available.
-
-        try:
-            with proxy():
-                pass
-        except ConnectionError:
-            logger.warning(
-                f"The {proxy.__class__.__name__} endpoint is not responding, {listener['name']} not un-registered."
-            )
-            return
-
-        logger.info(f"Removing {self.__class__.__name__} as a listener from {proxy.__name__}")
-
-        retry_thread = threading.Thread(target=_remove_listener, args=(proxy, listener))
-        retry_thread.daemon = False
-        retry_thread.start()
-
-        # Block until the listener has been removed. This is needed because this unregister function will usually
-        # be called in the `after_server()` method of the control server (which is the listener) and if we do not
-        # wait until the thread is finished the ZeroMQ Context will be destroyed before the reply can be sent.
-        # Note: we could probably do without the thread, and directly call the `_remove_listener()` function.
-
-        retry_thread.join()

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/dummy.py

@@ -56,8 +56,6 @@ from egse.device import DeviceConnectionError
 from egse.device import DeviceConnectionInterface
 from egse.device import DeviceTimeoutError
 from egse.device import DeviceTransport
-from egse.listener import Event
-from egse.listener import EventInterface
 from egse.log import logger
 from egse.protocol import CommandProtocol
 from egse.proxy import Proxy
@@ -110,12 +108,6 @@ commands = attrdict(
             "description": "Read a value from the device.",
         },
         "division": {"description": "Return a / b", "cmd": "{a} {b}"},
-        "handle_event": {
-            "description": "Notification of an event",
-            "device_method": "handle_event",
-            "cmd": "{event}",
-            "response": "handle_device_method",
-        },
     }
 )
 
@@ -172,7 +164,7 @@ class DummyInterface:
         raise NotImplementedError("The division() method has not been loaded from the service.")
 
 
-class DummyProxy(Proxy, DummyInterface, EventInterface):
+class DummyProxy(Proxy, DummyInterface):
     """
     The Proxy class for the dummy device.
 
@@ -193,7 +185,7 @@ class DummyProxy(Proxy, DummyInterface, EventInterface):
         super().__init__(connect_address(protocol, hostname, port), timeout=timeout)
 
 
-class DummyController(DummyInterface, EventInterface):
+class DummyController(DummyInterface):
     """
     The controller class for the dummy device.
 
@@ -214,32 +206,6 @@ class DummyController(DummyInterface, EventInterface):
     def division(self, a, b) -> float:
         return a / b
 
-    def handle_event(self, event: Event) -> str:
-        _exec_in_thread = False
-
-        def _handle_event(_event):
-            logger.info(f"An event is received, {_event=}")
-            logger.info(f"CM CS active? {is_control_server_active()}")
-            time.sleep(5.0)
-            logger.info(f"CM CS active? {is_control_server_active()}")
-            logger.info(f"An event is processed, {_event=}")
-
-        if _exec_in_thread:
-            # We execute this function in a daemon thread so the acknowledgment is
-            # sent back immediately (the ACK means 'command received and will be
-            # executed').
-
-            retry_thread = threading.Thread(target=_handle_event, args=(event,))
-            retry_thread.daemon = True
-            retry_thread.start()
-        else:
-            # An alternative to the daemon thread is to create a scheduled task that will be executed
-            # after the event is acknowledged.
-
-            self._cs.schedule_task(partial(_handle_event, event))
-
-        return "ACK"
-
 
 class DummyProtocol(CommandProtocol):
     """
@@ -319,21 +285,6 @@ class DummyControlServer(ControlServer):
 
         self.set_hk_delay(ctrl_settings.HK_DELAY)
 
-        from egse.confman import ConfigurationManagerProxy
-        from egse.listener import EVENT_ID
-
-        # The following import is needed because without this import, DummyProxy would
-        # be <class '__main__.DummyProxy'> instead of `egse.dummy.DummyProxy` and the
-        # ConfigurationManager control server will not be able to de-pickle
-        # the register message.
-
-        from egse.dummy import DummyProxy  # noqa
-
-        self.register_as_listener(
-            proxy=ConfigurationManagerProxy,
-            listener={"name": "Dummy CS", "proxy": DummyProxy, "event_id": EVENT_ID.SETUP},
-        )
-
     def get_communication_protocol(self):
         return "tcp"
 
@@ -349,13 +300,11 @@ class DummyControlServer(ControlServer):
     def get_storage_mnemonic(self):
         return "DUMMY-HK"
 
-    def after_serve(self):
-        logger.debug("After Serve: unregistering Dummy CS")
-
-        with contextlib.suppress(ModuleNotFoundError):
-            from egse.confman import ConfigurationManagerProxy
+    def before_serve(self) -> None:
+        logger.debug("Before Serve ...")
 
-            self.unregister_as_listener(proxy=ConfigurationManagerProxy, listener={"name": "Dummy CS"})
+    def after_serve(self):
+        logger.debug("After Serve ...")
 
 
 class DummyDeviceEthernetInterface(DeviceConnectionInterface, DeviceTransport):

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/logger/log_cs.py

@@ -62,7 +62,7 @@ LOG_NAME_TO_LEVEL = {
 
 # LOG_FORMAT_FILE = "%(asctime)s:%(processName)s:%(process)s:%(levelname)s:%(lineno)d:%(name)s:%(message)s"
 LOG_FORMAT_FILE = (
-    "{asctime} [{levelname:>8s}] [{processName:>12s}] {message} ({process}:{package_name}:{filename}:{lineno:d})"
+    "{asctime} [{levelname:>8s}] [{processName:>12s}] {message} ({name}:{process}:{package_name}:{filename}:{lineno:d})"
 )
 LOG_FORMAT_FILE_STYLE = "{"
 

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/procman/__init__.py

@@ -8,15 +8,14 @@ from egse.command import ClientServerCommand
 from egse.connect import get_endpoint
 from egse.control import is_control_server_active
 from egse.decorators import dynamic_interface
-from egse.listener import EventInterface, Event
 from egse.plugin import entry_points
 from egse.process import SubProcess
 from egse.proxy import Proxy
 from egse.registry.client import RegistryClient
 from egse.settings import Settings
-from egse.setup import Setup, load_setup
+from egse.setup import Setup
+from egse.setup import load_setup
 from egse.storage import is_storage_manager_active
-from egse.zmq_ser import connect_address
 
 HERE = Path(__file__).parent
 LOGGER = logging.getLogger("egse.procman")
@@ -210,7 +209,7 @@ class ProcessManagerCommand(ClientServerCommand):
     pass
 
 
-class ProcessManagerInterface(EventInterface):
+class ProcessManagerInterface:
     def __init__(self):
         super().__init__()
         self.setup = load_setup()
@@ -358,12 +357,6 @@ class ProcessManagerController(ProcessManagerInterface):
         except AttributeError:
             return {}
 
-    def handle_event(self, event: Event):
-        LOGGER.info(f"An event is received, {event=}")
-        LOGGER.info(f"Setup ID: {event.context['setup_id']}")
-
-        self.setup = load_setup(setup_id=event.context["setup_id"])
-
     def start_process(self, start_cmd: StartCommand):
         # subprocess.call(start_cmd.cmd, shell=True) -> PM hangs
         process = SubProcess("MyApp", [start_cmd.cmd], shell=True)

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/procman/procman.yaml

@@ -12,10 +12,6 @@ Commands:
     get_device_ids:
         description:    Returns a list of the identifiers of the devices in the current setup.
 
-    handle_event:
-        description:    Notification of an event
-        cmd:            '{event}'
-
     start_process:
         description:    Starts a process
         cmd:            '{start_cmd}'
@@ -30,4 +26,4 @@ Commands:
 
     get_device_process_status:
         description:    Returns the status of a process
-        cmd:            '{status_cmd}'
+        cmd:            '{status_cmd}'

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/procman/procman_cs.py

@@ -6,7 +6,6 @@ Manager (from the setup).
 The Process Manager Control Server is implemented as a standard control server.
 """
 
-import logging
 import multiprocessing
 import sys
 
@@ -15,12 +14,10 @@ import typer
 import zmq
 from rich.console import Console
 
-from egse.confman import ConfigurationManagerProxy
 from egse.control import ControlServer
-from egse.listener import EVENT_ID
+from egse.log import logging
 from egse.logger import remote_logging
 from egse.process import SubProcess
-from egse.procman import ProcessManagerProxy
 from egse.procman.procman_protocol import ProcessManagerProtocol
 from egse.registry.client import RegistryClient
 from egse.services import ServiceProxy
@@ -56,10 +53,6 @@ class ProcessManagerControlServer(ControlServer):
 
         self.logger.debug(f"Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}")
 
-        self.register_as_listener(
-            proxy=ConfigurationManagerProxy,
-            listener={"name": "Process Manager CS", "proxy": ProcessManagerProxy, "event_id": EVENT_ID.SETUP},
-        )
         self.device_protocol.bind(self.dev_ctrl_cmd_sock)
 
         self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
@@ -116,10 +109,6 @@ class ProcessManagerControlServer(ControlServer):
         unregister_from_storage_manager(origin=self.get_storage_mnemonic())
 
     def after_serve(self):
-        from egse.confman import ConfigurationManagerProxy
-
-        self.unregister_as_listener(proxy=ConfigurationManagerProxy, listener={"name": "Process Manager CS"})
-
         self.deregister_service()
 
 

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/registry/client.py

@@ -477,8 +477,15 @@ class RegistryClient:
     def stop_heartbeat(self) -> None:
         if self._hb_stop_event:
             self._hb_stop_event.set()
-        if self._hb_thread and self._hb_thread.is_alive():
-            self._hb_thread.join(timeout=THREAD_JOIN_TIMEOUT)
+        if self._hb_thread:
+            if self._hb_thread.is_alive():
+                self.logger.debug(f"Heartbeat thread is alive, joining with timeout={THREAD_JOIN_TIMEOUT}s")
+                self._hb_thread.join(timeout=THREAD_JOIN_TIMEOUT)
+            else:
+                self.logger.debug("Heartbeat thread is not alive.")
+                self._hb_thread = None
+        else:
+            self.logger.debug("No heartbeat thread defined.")
 
     def close(self) -> None:
         """Clean up resources."""

{cgse-0.16.3 → cgse-0.16.4}/libs/cgse-core/src/egse/storage/__init__.py

@@ -128,8 +128,6 @@ from egse.decorators import dynamic_interface
 from egse.env import get_data_storage_location
 from egse.env import get_site_id
 from egse.exceptions import Error
-from egse.listener import Event
-from egse.listener import EventInterface
 from egse.log import logger
 from egse.obsid import ObservationIdentifier
 from egse.obsid import TEST_LAB
@@ -715,7 +713,7 @@ def determine_counter_from_dir_list(location, pattern, index: int = -1):
         return 1
 
 
-class StorageController(StorageInterface, EventInterface):
+class StorageController(StorageInterface):
     """
     The Storage Controller handles the registration of components, the start and end of an
     observation/test and the dispatching of the persistence functions in save.
@@ -1051,27 +1049,12 @@ class StorageController(StorageInterface, EventInterface):
             self._setup = setup
             logger.info(f"Setup {setup.get_id()} loaded in the Storage manager.")
 
-    def handle_event(self, event: Event) -> str:
-        logger.info(f"An event is received, {event=}")
-
-        logger.warning(
-            f"----------> This functionality has been replaced with the notification events and will be removed soon."
-        )
-
-        # try:
-        #     if event.type == "new_setup":
-        #         self._cs.schedule_task(partial(self.load_setup, setup_id=event.context["setup_id"]))
-        # except KeyError as exc:
-        #     return f"Expected event context to contain the following key: {exc}"
-
-        return "ACK"
-
 
 class StorageCommand(ClientServerCommand):
     pass
 
 
-class StorageProxy(Proxy, StorageInterface, EventInterface):
+class StorageProxy(Proxy, StorageInterface):
     """
     The StorageProxy class is used to connect to the Storage Manager (control server) and
     send commands remotely.