OpenSMI-Core 0.3.1__tar.gz → 0.4__tar.gz

{opensmi_core-0.3.1 → opensmi_core-0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenSMI-Core
-Version: 0.3.1
+Version: 0.4
 Summary: Smart Machine Interface core functionality for server and client applications.
 Author-email: Carsten Harms <Carsten.Harms@dfki.de>, Simon Jungbluth <Simon.Jungbluth@smartfactory.de>
 License-Expression: MIT

{opensmi_core-0.3.1 → opensmi_core-0.4}/src/OpenSMI_Core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenSMI-Core
-Version: 0.3.1
+Version: 0.4
 Summary: Smart Machine Interface core functionality for server and client applications.
 Author-email: Carsten Harms <Carsten.Harms@dfki.de>, Simon Jungbluth <Simon.Jungbluth@smartfactory.de>
 License-Expression: MIT

{opensmi_core-0.3.1 → opensmi_core-0.4}/src/OpenSMI_Core.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.3.1",
+  "tag": "0.4",
   "distance": 0,
-  "node": "g672f1787bfda4d814e6bfae7730db36dc7cd0999",
+  "node": "gf395f24046a13a5a9c4b6536f16e250aada34582",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-12"

{opensmi_core-0.3.1 → opensmi_core-0.4}/src/opensmi/core/subscription_manager.py

@@ -10,7 +10,8 @@ import time
 from abc import ABC, abstractmethod
 from asyncio import Task
 from collections.abc import Iterable
-from typing import Any, Never
+from dataclasses import dataclass, field
+from typing import Any, Generic, Never, TypeVar
 
 import structlog
 from asyncua import ua
@@ -39,11 +40,21 @@ class UaEventSubscriber(ABC):
         """Handle OPC UA event notification."""
 
 
+_HandlerType = TypeVar("_HandlerType")
+
+
+@dataclass
+class _MonitoredItem(Generic[_HandlerType]):
+    handle: int | None
+    """Handle as returned by ``asyncua``. Is ``None`` when renew failed."""
+    handlers: list[_HandlerType] = field(default_factory=list)
+
+
 class SubscriptionManager:
     """Centrally manages all OPC UA subscription needs.
 
     It bundles subscriptions using only one subscription to an OPC UA server
-    to not stay within max. subscription limits of certain OPC UA servers.
+    to stay within max. subscription limits of certain OPC UA servers.
     """
 
     _ua_client: Client
@@ -65,10 +76,10 @@ class SubscriptionManager:
         self._publishing_interval_ms = publishing_interval_ms
         self._ua_client = ua_client
 
-        self._data_subscription_map: dict[NodeId, list[UaDataChangeSubscriber]] = {}
-        """ Maps a OPC UA node to a list of handlers for data change notifications. """
-        self._event_subscription_map: dict[NodeId, list[UaEventSubscriber]] = {}
-        """ Maps a OPC UA node to a list of handlers for event notifications. """
+        self._data_subscription_map: dict[NodeId, _MonitoredItem[UaDataChangeSubscriber]] = {}
+        """ Maps a OPC UA node to a handle and a list of handlers for data change notifications. """
+        self._event_subscription_map: dict[NodeId, _MonitoredItem[UaEventSubscriber]] = {}
+        """ Maps a OPC UA node to a handle and a list of handlers for event notifications. """
 
         self._heartbeat_task: Task[Never] | None = None
         self._last_heartbeat = time.monotonic()
@@ -83,6 +94,13 @@ class SubscriptionManager:
         self.logger.info("Created subscription!", parameters=self._ua_subscription.parameters)
 
     async def init(self) -> None:
+        """Create the subscription and start heartbeat monitoring.
+
+        Must be called once before any ``subscribe_*`` method.
+        """
+        if self._heartbeat_task is not None:
+            return
+
         await self._create_subscription()
 
         # subscribe to a node that always changes reliably, for example the current time of the server
@@ -92,47 +110,80 @@ class SubscriptionManager:
 
         self._last_heartbeat = time.monotonic()
         self._heartbeat_task = asyncio.create_task(self._heartbeat_loop(), name="heartbeat_task")
+        self.logger.info("Subscription manager initialized")
 
-    async def _renew_subscriptions(self) -> None:
-        self.logger.info(f"Trying to renew {self.no_of_monitored_items} subscriptions...")
-        old_data_subscription_map = self._data_subscription_map.copy()
-        old_event_subscription_map = self._event_subscription_map.copy()
+    async def shutdown(self) -> None:
+        """Stop heartbeat monitoring and delete the OPC UA subscription."""
+        # Stop the heartbeat first, so it can't start renewing subscriptions while shutting down
+        if self._heartbeat_task is not None:
+            self._heartbeat_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._heartbeat_task
+            self._heartbeat_task = None
 
         await self.clear_subscriptions()
-        while True:
+        self.logger.info("Subscription manager shut down")
+
+    # TODO(CaHa): What about the subscriptions that could not be renewed?
+
+    async def _renew_data_change_subscriptions(self) -> None:
+        for node_id, monitored_item in list(self._data_subscription_map.items()):
             try:
-                await self._create_subscription()
-                # add all old data change subscriptions back
-                for node_id, handlers in old_data_subscription_map.items():
-                    for handler in handlers:
-                        await self.subscribe_data_change(handler=handler, nodes=[self._ua_client.get_node(node_id)])
+                handle = await self._ua_subscription.subscribe_data_change(self._ua_client.get_node(node_id))
+                monitored_item.handle = handle
+            except UaStatusCodeError as err:
+                monitored_item.handle = None
+                self.logger.warning("Could not renew data change subscription", node=node_id.to_string(), reason=err)
+
+    async def _renew_event_subscriptions(self) -> None:
+        for node_id, monitored_item in list(self._event_subscription_map.items()):
+            try:
+                handle = await self._ua_subscription.subscribe_events(node_id)
+                monitored_item.handle = handle
+            except UaStatusCodeError as err:
+                monitored_item.handle = None
+                self.logger.warning("Could not renew event subscription", node=node_id.to_string(), reason=err)
 
-                # add all old event subscriptions back
-                for node_id, handlers in old_event_subscription_map.items():
-                    for handler in handlers:
-                        await self.subscribe_event(handler=handler, source_node=node_id)
+    async def _renew_subscriptions(self) -> None:
+        self.logger.info("Trying to renew subscriptions...", count=self.no_of_monitored_items)
+        await self._delete_subscription()
 
+        while True:
+            try:
+                await self._create_subscription()
+                await self._renew_data_change_subscriptions()
+                await self._renew_event_subscriptions()
+                self._last_heartbeat = time.monotonic()
                 self.logger.info("Successfully renewed subscriptions")
                 break
             except Exception as err:
                 self.logger.warning("Could not renew subscriptions!", reason=err)
+                await self._delete_subscription()
                 await asyncio.sleep(1)
 
-    async def clear_subscriptions(self) -> None:
-        self.logger.info(f"Clearing {self.no_of_monitored_items} subscriptions...")
+    def _invalidate_subscription_handles(self) -> None:
+        for item in self._data_subscription_map.values():
+            item.handle = None
+        for item in self._event_subscription_map.values():
+            item.handle = None
+
+    async def _delete_subscription(self) -> None:
+        """Best-effort deletion of the server-side subscription; the maps are left untouched."""
+        self._invalidate_subscription_handles()
         try:
             await self._ua_subscription.delete()
             self.logger.info("Deleted main OPC UA subscription!")
-        except ConnectionError:
-            pass  # we can safely ignore it since is no longer relevant
-        except AttributeError:
-            pass  # we can safely ignore it since there is no subscription to delete
+        except (ConnectionError, AttributeError):
+            pass  # connection is gone or there is no subscription to delete
         except Exception as err:
             self.logger.exception("Could not delete main OPC UA subscription!", reason=err)
-
         with contextlib.suppress(NameError, AttributeError):
             del self._ua_subscription
 
+    async def clear_subscriptions(self) -> None:
+        """Delete the OPC UA subscription and forget all registered handlers."""
+        self.logger.info("Clearing subscriptions...", count=self.no_of_monitored_items)
+        await self._delete_subscription()
         self._data_subscription_map.clear()
         self._event_subscription_map.clear()
 
@@ -153,11 +204,12 @@ class SubscriptionManager:
                 node = self._ua_client.get_node(node)
 
             if node.nodeid not in self._data_subscription_map:
-                self._data_subscription_map[node.nodeid] = []
                 try:
-                    await self._ua_subscription.subscribe_data_change(node)
-                    self._data_subscription_map[node.nodeid].append(handler)
-                    self.logger.debug("Added data change handler", handler=handler, node=node.nodeid.to_string())
+                    handle = await self._ua_subscription.subscribe_data_change(node)
+                    self._data_subscription_map[node.nodeid] = _MonitoredItem(handle=handle, handlers=[handler])
+                    self.logger.debug(
+                        "Added data change handler", handler=handler, node=node.nodeid.to_string(), handle=handle
+                    )
                 except BadAttributeIdInvalid:
                     self.logger.warning("Node does not support subscription!", node=node.nodeid.to_string())
                 except UaStatusCodeError as err:
@@ -169,7 +221,7 @@ class SubscriptionManager:
                     handler=handler,
                     node=node.nodeid.to_string(),
                 )
-                self._data_subscription_map[node.nodeid].append(handler)
+                self._data_subscription_map[node.nodeid].handlers.append(handler)
 
     async def subscribe_event(self, handler: UaEventSubscriber, source_node: Node | NodeId) -> None:
         """Add given handler to receive event notifications for given node."""
@@ -182,11 +234,57 @@ class SubscriptionManager:
             msg = f"Given source_node {source_node} is not supported!"
             raise TypeError(msg)
 
-        if source_node not in self._event_subscription_map:
-            self._event_subscription_map[node_id] = []
+        if node_id not in self._event_subscription_map:
+            handle = await self._ua_subscription.subscribe_events(sourcenode=source_node)
+            self._event_subscription_map[node_id] = _MonitoredItem(handle=handle, handlers=[handler])
+            self.logger.debug("Added event handler", handler=handler, node=node_id.to_string(), handle=handle)
+        else:
+            # We only need 1 subscription for n handlers.
+            self.logger.debug(
+                "Added event handler, reusing existing subscription.", handler=handler, node=node_id.to_string()
+            )
+            self._event_subscription_map[node_id].handlers.append(handler)
+
+    async def unsubscribe_data_change(
+        self, handler: UaDataChangeSubscriber, nodes: Node | NodeId | Iterable[Node | NodeId]
+    ) -> None:
+        """Remove handler for given nodes; removes server subscription once it has no handlers left."""
+        if not isinstance(nodes, Iterable):
+            nodes = [nodes]
+
+        for node in nodes:
+            node_id = node.nodeid if isinstance(node, Node) else node
+            await self._unsubscribe(handler=handler, node_id=node_id, subscription_map=self._data_subscription_map)
 
-        await self._ua_subscription.subscribe_events(sourcenode=source_node)
-        self._event_subscription_map[node_id].append(handler)
+    async def unsubscribe_event(self, handler: UaEventSubscriber, source_node: Node | NodeId) -> None:
+        """Remove handler for events of given node; removes server subscription once it has no handlers left."""
+        node_id = source_node.nodeid if isinstance(source_node, Node) else source_node
+        await self._unsubscribe(handler=handler, node_id=node_id, subscription_map=self._event_subscription_map)
+
+    async def _unsubscribe(
+        self,
+        *,
+        handler: _HandlerType,
+        node_id: NodeId,
+        subscription_map: dict[NodeId, _MonitoredItem[_HandlerType]],
+    ) -> None:
+        item = subscription_map.get(node_id)
+        if item is None or handler not in item.handlers:
+            return  # nothing to do
+
+        item.handlers.remove(handler)
+
+        if len(item.handlers) > 0:
+            return  # other handlers still need the monitored item
+
+        del subscription_map[node_id]
+        if item.handle is None:
+            return  # nothing to unsubscribe
+
+        try:
+            await self._ua_subscription.unsubscribe(item.handle)
+        except (UaStatusCodeError, ConnectionError) as err:
+            self.logger.warning("Could not delete monitored item", node=node_id.to_string(), reason=err)
 
     async def _heartbeat_loop(self) -> Never:
         while True:
@@ -206,15 +304,20 @@ class SubscriptionManager:
         """Handle OPC UA data change notifications callback."""
         self._last_heartbeat = time.monotonic()
 
-        try:
-            for handler in self._data_subscription_map[node.nodeid]:  # list of handlers
-                if handler == self:
-                    continue  # current time, not required for anything specific
-                await handler.ua_on_data_change(node, val, data)
-        except KeyError:
+        item = self._data_subscription_map.get(node.nodeid)
+        if item is None:
             self.logger.warning(
                 "Received DataChange Notification with no handlers", key=node.nodeid.to_string(), value=val
             )
+            return
+
+        for handler in list(item.handlers):  # copy, to guard against unsubscription during iteration
+            if handler is self:
+                continue  # current time, not required for anything specific
+            try:
+                await handler.ua_on_data_change(node, val, data)
+            except Exception as err:
+                self.logger.warning("Data change handler failed", handler=handler, reason=err)
 
     async def status_change_notification(self, status: ua.StatusChangeNotification) -> None:
         """Handle OPC UA status notifications callback."""
@@ -226,8 +329,13 @@ class SubscriptionManager:
 
         # TODO(CaHa): ua_event.emitting_node is always i=2253 (=Server)
         # might be an asyncua problem
-        try:
-            for handler in self._event_subscription_map[ua_event.SourceNode]:
-                await handler.ua_on_event(ua_event)
-        except KeyError:
+        item = self._event_subscription_map.get(ua_event.SourceNode)
+        if item is None:
             self.logger.warning("Received Event Notification with no handlers", ua_event=ua_event)
+            return
+
+        for handler in list(item.handlers):  # copy, to guard against unsubscription during iteration
+            try:
+                await handler.ua_on_event(ua_event)
+            except Exception as err:
+                self.logger.warning("Event handler failed", handler=handler, reason=err)