[ADD] wip

examples/async_client.py

+
+import asyncio
+import logging
+
+from opcua.client.async_client import AsyncClient
+
+logging.basicConfig(level=logging.INFO)
+_logger = logging.getLogger('opcua')
+
+
+async def browse_nodes(node, level=0):
+    node_class = node.get_node_class()
+    return {
+        'id': node.nodeid.to_string(),
+        'name': node.get_display_name().Text.decode('utf8'),
+        'cls': node_class.value,
+        'children': [
+            browse_nodes(child, level=level + 1) for child in node.get_children(nodeclassmask=objects_and_variables)
+        ],
+        'type': node.get_data_type_as_variant_type().value if node_class == ua.NodeClass.Variable else None,
+    }
+
+
+async def task(loop):
+    try:
+        client = AsyncClient(url='opc.tcp://commsvr.com:51234/UA/CAS_UA_Server')
+        await client.connect()
+        obj_node = client.get_objects_node()
+        _logger.info('Objects Node: %r', obj_node)
+        tree = await browse_nodes(obj_node)
+        _logger.info('Tree: %r', tree)
+    except Exception:
+        _logger.exception('Task error')
+    loop.stop()
+
+
+def main():
+    loop = asyncio.get_event_loop()
+    loop.set_debug(True)
+    loop.create_task(task(loop))
+    try:
+        loop.run_forever()
+    except Exception:
+        _logger.exception('Event loop error')
+        loop.run_until_complete(loop.shutdown_asyncgens())
+        loop.close()
+
+
+if __name__ == '__main__':
+    main()

opcua/client/async_ua_client.py

@@ -47,22 +47,25 @@ class UASocketProtocol(asyncio.Protocol):
     async def read(self, size):
         """Receive up to size bytes from socket."""
         data = b''
+        self.logger.debug('read %s bytes from socket', size)
         while size > 0:
+            self.logger.debug('data is now %s, waiting for %s bytes', len(data), size)
             # ToDo: abort on timeout, socket close
             # raise SocketClosedException("Server socket has closed")
             if self._leftover_chunk:
+                self.logger.debug('leftover bytes %s', len(self._leftover_chunk))
                 # use leftover chunk first
                 chunk = self._leftover_chunk
                 self._leftover_chunk = None
             else:
                 chunk = await self.receive_buffer.get()
-            needed_length = size - len(data)
-            if len(chunk) <= needed_length:
+            self.logger.debug('got chunk %s needed_length is %s', len(chunk), size)
+            if len(chunk) <= size:
                 _chunk = chunk
             else:
                 # chunk is too big
-                _chunk = chunk[:needed_length]
-                self._leftover_chunk = chunk[needed_length:]
+                _chunk = chunk[:size]
+                self._leftover_chunk = chunk[size:]
             data += _chunk
             size -= len(_chunk)
         return data
@@ -99,7 +102,8 @@ class UASocketProtocol(asyncio.Protocol):
         """
         future = self._send_request(request, callback, timeout, message_type)
         if not callback:
-            data = await asyncio.wait_for(future.result(), self.timeout)
+            await asyncio.wait_for(future, self.timeout)
+            data = future.result()
             self.check_answer(data, " in response to " + request.__class__.__name__)
             return data
 
@@ -246,7 +250,7 @@ class UaClient:
         self.logger.info("create_session")
         request = ua.CreateSessionRequest()
         request.Parameters = parameters
-        data = self.protocol.send_request(request)
+        data = await self.protocol.send_request(request)
         response = struct_from_binary(ua.CreateSessionResponse, data)
         self.logger.debug(response)
         response.ResponseHeader.ServiceResult.check()