subscriber

src/OpcUaSubscriber.py

@@ -0,0 +1,114 @@
+import asyncio
+from sqlite3 import NotSupportedError
+from asyncua import Client, ua
+import threading
+from loguru import logger
+from FlatDataObject import FlatDataObject
+from StructuredDataObject import StructuredDataObject
+
+
+
+class FlatSubscriptionHandler:
+    def __init__(self, serverName, nodes, queue):
+        self.serverName = serverName
+        self.nodes = nodes
+        self.queue = queue
+        self.count = 0
+
+    def getAndResetCount(self):
+        tmp = self.count
+        self.count = 0
+        return tmp
+
+    def datachange_notification(self, node, val, data):
+        logger.info(f"received: {node=}, {val=}, {data=}")
+        self.count += 1
+        match node.nodeid.NodeIdType:
+            case ua.NodeIdType.Numeric:
+                prefix = 'i'
+            case ua.NodeIdType.String:
+                prefix = 's'
+            case _: 
+                prefix = 'x'
+        nodeName = f"{prefix}={node.nodeid.Identifier}"
+        namespaceIndex = node.nodeid.NamespaceIndex
+        displayNames = [ x['d'] for x in self.nodes if x['ns'] == namespaceIndex and x['n'] == nodeName ]
+        name = displayNames[0] if displayNames else nodeName
+        self.queue.put(FlatDataObject(self.serverName, str(namespaceIndex), name, data.monitored_item.Value))
+
+
+class _RenewTriggerException(Exception): pass
+
+class OpcUaSubscriber(threading.Thread):
+    def __init__(self, config, stats, queue):
+        super().__init__()
+
+        self.config = config
+        self.queue = queue
+        self.stats = stats
+
+        self.name = self.config['name']
+        self.url = self.config['url']
+        self.nodes = self.config['nodes']
+        self.period = self.config['period']
+        self.timeout = self.config['timeout']
+        self.dataObjectType = self.config['type']
+        self.flat = self.dataObjectType == 'flat'
+
+        if not self.flat:
+            raise NotImplementedError("Only flat approach supported in OpcUaSubscriber")
+
+        # consider this flag in the localLoop
+        self.killBill = False
+        self.killEvent = asyncio.Event()
+
+    async def opcUaSubscriberInnerLoop(self):
+        while not self.killBill:
+            try:
+                async with Client(url=self.url, timeout=self.timeout) as client:
+                    subscriptionHandler = FlatSubscriptionHandler(self.name, self.nodes, self.queue) 
+                    subscription = await client.create_subscription(self.period * 1000, subscriptionHandler)
+                    nodes = [ client.get_node(f"ns={n['ns']};{n['n']}") for n in self.nodes ]
+                    await subscription.subscribe_data_change(nodes)
+                    logger.info("Subscriptions created, nodes subscribed")                    
+
+                    while True:
+                        try:
+                            await asyncio.wait_for(self.killEvent.wait(), self.period * 10)
+                            logger.info("About to terminate opcUaSubscriber")
+                            break
+                        except asyncio.TimeoutError:
+                            cnt = subscriptionHandler.getAndResetCount()
+                            logger.info(f"receive count: {cnt}")
+                            if cnt == 0:
+                                raise _RenewTriggerException()
+
+                    await subscription.delete()
+                    logger.info("Subscriptions deleted, wait a moment")
+                    await asyncio.sleep(1)
+                    logger.info("opcUaSubscriber terminated")
+            except _RenewTriggerException:
+                logger.error(f"too few data received, renew connection")
+                # continues in the loop
+            except asyncio.exceptions.TimeoutError as e:
+                self.stats.incOpcUaTimeouts()
+                logger.error(f"Timeout in inner OPC-UA loop")
+            except asyncio.exceptions.CancelledError as e:
+                self.stats.incOpcUaErrors()
+                logger.error(f"Cancelled in inner OPC-UA loop")
+            except Exception as e:
+                self.stats.incOpcUaErrors()
+                logger.error(f"Exception in inner OPC-UA loop: {type(e)} {e}")
+
+    def run(self):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(self.opcUaSubscriberInnerLoop())
+        loop.close()
+
+    def stop(self):
+        self.killBill = True
+        logger.info("kill flag set")
+
+        self.killEvent.set()
+        logger.info("kill events triggered")