service: async properties

fixes #86

Author: Tony Crisci

dbus_next/_private/util.py

@@ -1,5 +1,7 @@
 from typing import List, Any, Union
+import inspect
 from ..signature import SignatureTree, Variant
+import ast
 
 
 def signature_contains_type(signature: Union[str, SignatureTree], body: List[Any],
@@ -91,6 +93,33 @@ def _replace(idx):
     return body
 
 
+def parse_annotation(annotation: str) -> str:
+    '''
+    Because of PEP 563, if `from __future__ import annotations` is used in code
+    or on Python version >=3.10 where this is the default, return annotations
+    from the `inspect` module will return annotations as "forward definitions".
+    In this case, we must eval the result which we do only when given a string
+    constant.
+    '''
+    def raise_value_error():
+        raise ValueError(f'service annotations must be a string constant (got {annotation})')
+
+    if not annotation or annotation is inspect.Signature.empty:
+        return ''
+    if type(annotation) is not str:
+        raise_value_error()
+    try:
+        body = ast.parse(annotation).body
+        if len(body) == 1 and type(body[0].value) is ast.Constant:
+            if type(body[0].value.value) is not str:
+                raise_value_error()
+            return body[0].value.value
+    except SyntaxError:
+        pass
+
+    return annotation
+
+
 def _replace_fds(body_obj: List[Any], children, replace_fn):
     '''Replace any type 'h' with the value returned by replace_fn() given the
     value of the fd field. This is used by the high level interfaces which

dbus_next/aio/message_bus.py

@@ -341,8 +341,7 @@ async def wait_for_disconnect(self):
         """
         return await self._disconnect_future
 
-    @classmethod
-    def _make_method_handler(cls, interface, method):
+    def _make_method_handler(self, interface, method):
         if not asyncio.iscoroutinefunction(method.fn):
             return super()._make_method_handler(interface, method)
 

dbus_next/message_bus.py

@@ -8,7 +8,6 @@
 from .signature import Variant
 from .proxy_object import BaseProxyObject
 from . import introspection as intr
-from contextlib import suppress
 
 import inspect
 import socket
@@ -222,20 +221,27 @@ def _emit_interface_added(self, path, interface):
         if self._disconnected:
             return
 
-        body = {interface.name: {}}
-        properties = interface._get_properties(interface)
+        def get_properties_callback(interface, result, user_data, e):
+            if e is not None:
+                try:
+                    raise e
+                except Exception:
+                    logging.error(
+                        'An exception ocurred when emitting ObjectManager.InterfacesAdded for %s. '
+                        'Some properties will not be included in the signal.',
+                        interface.name,
+                        exc_info=True)
 
-        for prop in properties:
-            with suppress(Exception):
-                body[interface.name][prop.name] = Variant(prop.signature,
-                                                          prop.prop_getter(interface))
+            body = {interface.name: result}
 
-        self.send(
-            Message.new_signal(path=path,
-                               interface='org.freedesktop.DBus.ObjectManager',
-                               member='InterfacesAdded',
-                               signature='oa{sa{sv}}',
-                               body=[path, body]))
+            self.send(
+                Message.new_signal(path=path,
+                                   interface='org.freedesktop.DBus.ObjectManager',
+                                   member='InterfacesAdded',
+                                   signature='oa{sa{sv}}',
+                                   body=[path, body]))
+
+        ServiceInterface._get_all_property_values(interface, get_properties_callback)
 
     def _emit_interface_removed(self, path, removed_interfaces):
         """Emit the ``org.freedesktop.DBus.ObjectManager.InterfacesRemoved` signal.
@@ -630,7 +636,7 @@ def __call__(self, reply):
 
                 bus.send(reply)
 
-            def __exit__(self, exc_type, exc_value, tb):
+            def _exit(self, exc_type, exc_value, tb):
                 if exc_type is None:
                     return
 
@@ -646,6 +652,12 @@ def __exit__(self, exc_type, exc_value, tb):
                         ))
                     return True
 
+            def __exit__(self, exc_type, exc_value, tb):
+                self._exit(exc_type, exc_value, tb)
+
+            def send_error(self, exc):
+                self._exit(exc.__class__, exc, exc.__traceback__)
+
         return SendReply()
 
     def _process_message(self, msg):
@@ -713,8 +725,7 @@ def _process_message(self, msg):
                     handler(msg, None)
                 del self._method_return_handlers[msg.reply_serial]
 
-    @classmethod
-    def _make_method_handler(cls, interface, method):
+    def _make_method_handler(self, interface, method):
         def handler(msg, send_reply):
             args = ServiceInterface._msg_body_to_args(msg)
             result = method.fn(interface, *args)
@@ -792,16 +803,51 @@ def reply_handler(reply, err):
 
     def _default_get_managed_objects_handler(self, msg, send_reply):
         result = {}
-
-        for node in self._path_exports:
-            if not node.startswith(msg.path + '/') and msg.path != '/':
-                continue
-
+        result_signature = 'a{oa{sa{sv}}}'
+        error_handled = False
+
+        def is_result_complete():
+            if not result:
+                return True
+            for n, interfaces in result.items():
+                for value in interfaces.values():
+                    if value is None:
+                        return False
+
+            return True
+
+        nodes = [
+            node for node in self._path_exports
+            if msg.path == '/' or node.startswith(msg.path + '/')
+        ]
+
+        # first build up the result object to know when it's complete
+        for node in nodes:
             result[node] = {}
             for interface in self._path_exports[node]:
-                result[node][interface.name] = self._get_all_properties(interface)
+                result[node][interface.name] = None
+
+        if is_result_complete():
+            send_reply(Message.new_method_return(msg, result_signature, [result]))
+            return
+
+        def get_all_properties_callback(interface, values, node, err):
+            nonlocal error_handled
+            if err is not None:
+                if not error_handled:
+                    error_handled = True
+                    send_reply.send_error(err)
+                return
 
-        send_reply(Message.new_method_return(msg, 'a{oa{sa{sv}}}', [result]))
+            result[node][interface.name] = values
+
+            if is_result_complete():
+                send_reply(Message.new_method_return(msg, result_signature, [result]))
+
+        for node in nodes:
+            for interface in self._path_exports[node]:
+                ServiceInterface._get_all_property_values(interface, get_all_properties_callback,
+                                                          node)
 
     def _default_properties_handler(self, msg, send_reply):
         methods = {'Get': 'ss', 'Set': 'ssv', 'GetAll': 's'}
@@ -858,14 +904,24 @@ def _default_properties_handler(self, msg, send_reply):
                 if not prop.access.readable():
                     raise DBusError(ErrorType.UNKNOWN_PROPERTY,
                                     'the property does not have read access')
-                prop_value = getattr(interface, prop.prop_getter.__name__)
 
-                body, unix_fds = replace_fds_with_idx(prop.signature, [prop_value])
+                def get_property_callback(interface, prop, prop_value, err):
+                    try:
+                        if err is not None:
+                            send_reply.send_error(err)
+                            return
+
+                        body, unix_fds = replace_fds_with_idx(prop.signature, [prop_value])
+
+                        send_reply(
+                            Message.new_method_return(msg,
+                                                      'v', [Variant(prop.signature, body[0])],
+                                                      unix_fds=unix_fds))
+                    except Exception as e:
+                        send_reply.send_error(e)
+
+                ServiceInterface._get_property_value(interface, prop, get_property_callback)
 
-                send_reply(
-                    Message.new_method_return(msg,
-                                              'v', [Variant(prop.signature, body[0])],
-                                              unix_fds=unix_fds))
             elif msg.member == 'Set':
                 if not prop.access.writable():
                     raise DBusError(ErrorType.PROPERTY_READ_ONLY, 'the property is readonly')
@@ -874,27 +930,30 @@ def _default_properties_handler(self, msg, send_reply):
                     raise DBusError(ErrorType.INVALID_SIGNATURE,
                                     f'wrong signature for property. expected "{prop.signature}"')
                 assert prop.prop_setter
+
+                def set_property_callback(interface, prop, err):
+                    if err is not None:
+                        send_reply.send_error(err)
+                        return
+                    send_reply(Message.new_method_return(msg))
+
                 body = replace_idx_with_fds(value.signature, [value.value], msg.unix_fds)
-                setattr(interface, prop.prop_setter.__name__, body[0])
-                send_reply(Message.new_method_return(msg))
+                ServiceInterface._set_property_value(interface, prop, body[0],
+                                                     set_property_callback)
 
         elif msg.member == 'GetAll':
-            body, unix_fds = replace_fds_with_idx('a{sv}', [self._get_all_properties(interface)])
-            send_reply(Message.new_method_return(msg, 'a{sv}', body, unix_fds=unix_fds))
 
-        else:
-            assert False
-
-    def _get_all_properties(self, interface):
-        result = {}
+            def get_all_properties_callback(interface, values, user_data, err):
+                if err is not None:
+                    send_reply.send_error(err)
+                    return
+                body, unix_fds = replace_fds_with_idx('a{sv}', [values])
+                send_reply(Message.new_method_return(msg, 'a{sv}', body, unix_fds=unix_fds))
 
-        for prop in ServiceInterface._get_properties(interface):
-            if prop.disabled or not prop.access.readable():
-                continue
-            result[prop.name] = Variant(prop.signature, getattr(interface,
-                                                                prop.prop_getter.__name__))
+            ServiceInterface._get_all_property_values(interface, get_all_properties_callback)
 
-        return result
+        else:
+            assert False
 
     def _init_high_level_client(self):
         '''The high level client is initialized when the first proxy object is