WIP: Make/asyncio just to easily see diff DO NOT MERGE

Dockerfile

@@ -0,0 +1,5 @@
+FROM python:3.6
+
+RUN pip install opcua
+
+CMD uaserver

dev_requirements.txt

@@ -0,0 +1,3 @@
+pytest
+pytest-asyncio
+coverage

examples/client-events.py

@@ -1,57 +1,53 @@
-import sys
-sys.path.insert(0, "..")
-
-try:
-    from IPython import embed
-except ImportError:
-    import code
-
-    def embed():
-        vars = globals()
-        vars.update(locals())
-        shell = code.InteractiveConsole(vars)
-        shell.interact()
-
 
+import asyncio
+import logging
 from opcua import Client
 
+logging.basicConfig(level=logging.INFO)
+_logger = logging.getLogger('opcua')
 
-class SubHandler(object):
 
+class SubHandler:
     """
     Subscription Handler. To receive events from server for a subscription
     data_change and event methods are called directly from receiving thread.
     Do not do expensive, slow or network operation there. Create another
     thread if you need to do such a thing
     """
     def event_notification(self, event):
-        print("New event recived: ", event)
+        _logger.info("New event received: %r", event)
 
 
-if __name__ == "__main__":
-
-    client = Client("opc.tcp://localhost:4840/freeopcua/server/")
-    # client = Client("opc.tcp://admin@localhost:4840/freeopcua/server/") #connect using a user
-    try:
-        client.connect()
+async def task():
+    url = "opc.tcp://localhost:4840/freeopcua/server/"
+    # url = "opc.tcp://admin@localhost:4840/freeopcua/server/"  #connect using a user
 
+    async with Client(url=url) as client:
         # Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects
         root = client.get_root_node()
-        print("Objects node is: ", root)
+        _logger.info("Objects node is: %r", root)
 
         # Now getting a variable node using its browse path
-        obj = root.get_child(["0:Objects", "2:MyObject"])
-        print("MyObject is: ", obj)
+        obj = await root.get_child(["0:Objects", "2:MyObject"])
+        _logger.info("MyObject is: %r", obj)
 
-        myevent = root.get_child(["0:Types", "0:EventTypes", "0:BaseEventType", "2:MyFirstEvent"])
-        print("MyFirstEventType is: ", myevent)
+        myevent = await root.get_child(["0:Types", "0:EventTypes", "0:BaseEventType", "2:MyFirstEvent"])
+        _logger.info("MyFirstEventType is: %r", myevent)
 
         msclt = SubHandler()
-        sub = client.create_subscription(100, msclt)
-        handle = sub.subscribe_events(obj, myevent)
-
-        embed()
-        sub.unsubscribe(handle)
-        sub.delete()
-    finally:
-        client.disconnect()
+        sub = await client.create_subscription(100, msclt)
+        handle = await sub.subscribe_events(obj, myevent)
+        await asyncio.sleep(10)
+        await sub.unsubscribe(handle)
+        await sub.delete()
+
+
+def main():
+    loop = asyncio.get_event_loop()
+    loop.set_debug(True)
+    loop.run_until_complete(task())
+    loop.close()
+
+
+if __name__ == "__main__":
+    main()

examples/client-example.py

@@ -1,26 +1,15 @@
-import sys
-sys.path.insert(0, "..")
-import logging
-import time
-
-try:
-    from IPython import embed
-except ImportError:
-    import code
-
-    def embed():
-        vars = globals()
-        vars.update(locals())
-        shell = code.InteractiveConsole(vars)
-        shell.interact()
 
+import time
+import asyncio
+import logging
 
 from opcua import Client
-from opcua import ua
 
+logging.basicConfig(level=logging.INFO)
+_logger = logging.getLogger('opcua')
 
-class SubHandler(object):
 
+class SubHandler(object):
     """
     Subscription Handler. To receive events from server for a subscription
     data_change and event methods are called directly from receiving thread.
@@ -29,60 +18,63 @@ class SubHandler(object):
     """
 
     def datachange_notification(self, node, val, data):
-        print("Python: New data change event", node, val)
+        print("New data change event", node, val)
 
     def event_notification(self, event):
-        print("Python: New event", event)
-
+        print("New event", event)
 
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.WARN)
-    #logger = logging.getLogger("KeepAlive")
-    #logger.setLevel(logging.DEBUG)
 
-    client = Client("opc.tcp://localhost:4840/freeopcua/server/")
-    # client = Client("opc.tcp://admin@localhost:4840/freeopcua/server/") #connect using a user
+async def task(loop):
+    url = "opc.tcp://commsvr.com:51234/UA/CAS_UA_Server"
+    # url = "opc.tcp://localhost:4840/freeopcua/server/"
     try:
-        client.connect()
-
-        # Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects
-        root = client.get_root_node()
-        print("Root node is: ", root)
-        objects = client.get_objects_node()
-        print("Objects node is: ", objects)
-
-        # Node objects have methods to read and write node attributes as well as browse or populate address space
-        print("Children of root are: ", root.get_children())
-
-        # get a specific node knowing its node id
-        #var = client.get_node(ua.NodeId(1002, 2))
-        #var = client.get_node("ns=3;i=2002")
-        #print(var)
-        #var.get_data_value() # get value of node as a DataValue object
-        #var.get_value() # get value of node as a python builtin
-        #var.set_value(ua.Variant([23], ua.VariantType.Int64)) #set node value using explicit data type
-        #var.set_value(3.9) # set node value using implicit data type
-
-        # Now getting a variable node using its browse path
-        myvar = root.get_child(["0:Objects", "2:MyObject", "2:MyVariable"])
-        obj = root.get_child(["0:Objects", "2:MyObject"])
-        print("myvar is: ", myvar)
-
-        # subscribing to a variable node
-        handler = SubHandler()
-        sub = client.create_subscription(500, handler)
-        handle = sub.subscribe_data_change(myvar)
-        time.sleep(0.1)
-
-        # we can also subscribe to events from server
-        sub.subscribe_events()
-        # sub.unsubscribe(handle)
-        # sub.delete()
-
-        # calling a method on server
-        res = obj.call_method("2:multiply", 3, "klk")
-        print("method result is: ", res)
-
-        embed()
-    finally:
-        client.disconnect()
+        async with Client(url=url) as client:
+            root = client.get_root_node()
+            _logger.info("Root node is: %r", root)
+            objects = client.get_objects_node()
+            _logger.info("Objects node is: %r", objects)
+
+            # Node objects have methods to read and write node attributes as well as browse or populate address space
+            _logger.info("Children of root are: %r", await root.get_children())
+
+            # get a specific node knowing its node id
+            #var = client.get_node(ua.NodeId(1002, 2))
+            #var = client.get_node("ns=3;i=2002")
+            #print(var)
+            #var.get_data_value() # get value of node as a DataValue object
+            #var.get_value() # get value of node as a python builtin
+            #var.set_value(ua.Variant([23], ua.VariantType.Int64)) #set node value using explicit data type
+            #var.set_value(3.9) # set node value using implicit data type
+
+            # Now getting a variable node using its browse path
+            myvar = await root.get_child(["0:Objects", "2:MyObject", "2:MyVariable"])
+            obj = await root.get_child(["0:Objects", "2:MyObject"])
+            _logger.info("myvar is: %r", myvar)
+
+            # subscribing to a variable node
+            handler = SubHandler()
+            sub = await client.create_subscription(500, handler)
+            handle = await sub.subscribe_data_change(myvar)
+            await asyncio.sleep(0.1)
+
+            # we can also subscribe to events from server
+            await sub.subscribe_events()
+            # await sub.unsubscribe(handle)
+            # await sub.delete()
+
+            # calling a method on server
+            res = obj.call_method("2:multiply", 3, "klk")
+            _logger.info("method result is: %r", res)
+    except Exception:
+        _logger.exception('error')
+
+
+def main():
+    loop = asyncio.get_event_loop()
+    loop.set_debug(True)
+    loop.run_until_complete(task(loop))
+    loop.close()
+
+
+if __name__ == "__main__":
+    main()

examples/client-minimal-auth.py

@@ -0,0 +1,69 @@
+import asyncio
+import logging
+from opcua import Client, Node, ua
+
+logging.basicConfig(level=logging.INFO)
+_logger = logging.getLogger('opcua')
+
+
+async def browse_nodes(node: Node):
+    """
+    Build a nested node tree dict by recursion (filtered by OPC UA objects and variables).
+    """
+    node_class = await node.get_node_class()
+    children = []
+    for child in await node.get_children():
+        if await child.get_node_class() in [ua.NodeClass.Object, ua.NodeClass.Variable]:
+            children.append(
+                await browse_nodes(child)
+            )
+    if node_class != ua.NodeClass.Variable:
+        var_type = None
+    else:
+        try:
+            var_type = (await node.get_data_type_as_variant_type()).value
+        except ua.UaError:
+            _logger.warning('Node Variable Type could not be determined for %r', node)
+            var_type = None
+    return {
+        'id': node.nodeid.to_string(),
+        'name': (await node.get_display_name()).Text,
+        'cls': node_class.value,
+        'children': children,
+        'type': var_type,
+    }
+
+
+async def task(loop):
+    url = "opc.tcp://192.168.2.64:4840"
+    # url = "opc.tcp://localhost:4840/freeopcua/server/"
+    try:
+        client = Client(url=url)
+        client.set_user('test')
+        client.set_password('test')
+        # client.set_security_string()
+        await client.connect()
+        # Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects
+        root = client.get_root_node()
+        _logger.info("Objects node is: %r", root)
+
+        # Node objects have methods to read and write node attributes as well as browse or populate address space
+        _logger.info("Children of root are: %r", await root.get_children())
+
+        tree = await browse_nodes(client.get_objects_node())
+        _logger.info('Node tree: %r', tree)
+    except Exception:
+        _logger.exception('error')
+    finally:
+        await client.disconnect()
+
+
+def main():
+    loop = asyncio.get_event_loop()
+    loop.set_debug(True)
+    loop.run_until_complete(task(loop))
+    loop.close()
+
+
+if __name__ == "__main__":
+    main()