Lazily add high level client match rules

Makes the low level client and high level service a bit more predictable
to not have to deal with a default match rule and should lower
connection overhead by eliminating a call in those cases.

Also fix several bugs.

Author: Tony Crisci

.travis.yml

@@ -4,6 +4,6 @@ dist: xenial
 services:
   - docker
 before_install:
-  - docker build -t dbus-next .
+  - docker build -t dbus-next-test .
 script:
-  - docker run -it dbus-next
+  - docker run -it dbus-next-test

Makefile

@@ -1,4 +1,4 @@
-.PHONY: lint check format test docker-test coverage clean publish docs livedocs all
+.PHONY: lint check format test docker-test clean publish docs livedocs all
 .DEFAULT_GOAL := all
 
 source_dirs = dbus_next test examples
@@ -13,14 +13,11 @@ format:
 	yapf -rip $(source_dirs)
 
 test:
-	dbus-run-session python3 -m pytest -s
+	dbus-run-session python3 -m pytest -svv --cov=dbus_next
 
 docker-test:
-	docker build -t dbus-next38 .
-	docker run -it dbus-next38
-
-coverage:
-	dbus-run-session pytest --cov=dbus_next
+	docker build -t dbus-next-test .
+	docker run -it dbus-next-test
 
 clean:
 	rm -rf dist dbus_next.egg-info build docs/_build

dbus_next/aio/message_bus.py

@@ -3,7 +3,7 @@
 from ..message import Message
 from ..constants import BusType, NameFlag, RequestNameReply, ReleaseNameReply, MessageType, MessageFlag
 from ..service import ServiceInterface
-from ..errors import AuthError, DBusError
+from ..errors import AuthError
 from .proxy_object import ProxyObject
 from .. import introspection as intr
 from ..auth import Authenticator, AuthExternal
@@ -81,34 +81,14 @@ def on_hello(reply, err):
             self._buffered_messages.clear()
             future.set_result(self)
 
-        def on_match_added(reply, err):
-            if err:
-                logging.error('adding match to "NameOwnerChanged" failed')
-                self.disconnect()
-                self._finalize(err)
-            elif reply.message_type == MessageType.ERROR:
-                logging.error('adding match to "NameOwnerChanged" failed')
-                self.disconnect()
-                self._finalize(DBusError._from_message(reply))
-
         hello_msg = Message(destination='org.freedesktop.DBus',
                             path='/org/freedesktop/DBus',
                             interface='org.freedesktop.DBus',
                             member='Hello',
                             serial=self.next_serial())
 
-        add_match_msg = Message(destination='org.freedesktop.DBus',
-                                path='/org/freedesktop/DBus',
-                                interface='org.freedesktop.DBus',
-                                member='AddMatch',
-                                signature='s',
-                                body=[self._name_owner_match_rule],
-                                serial=self.next_serial())
-
         self._method_return_handlers[hello_msg.serial] = on_hello
-        self._method_return_handlers[add_match_msg.serial] = on_match_added
         self._stream.write(hello_msg._marshall())
-        self._stream.write(add_match_msg._marshall())
         self._stream.flush()
 
         return await future

dbus_next/glib/message_bus.py

@@ -8,7 +8,6 @@
 from .. import introspection as intr
 from ..auth import Authenticator, AuthExternal
 
-import logging
 import io
 from typing import Callable, Optional
 
@@ -197,30 +196,14 @@ def on_hello(reply, err):
                 if connect_notify:
                     connect_notify(self, err)
 
-            def on_match_added(reply, err):
-                if err:
-                    logging.error(f'adding match to "NameOwnerChanged" failed: {err}')
-                    self.disconnect()
-                    return
-
             hello_msg = Message(destination='org.freedesktop.DBus',
                                 path='/org/freedesktop/DBus',
                                 interface='org.freedesktop.DBus',
                                 member='Hello',
                                 serial=self.next_serial())
 
-            add_match_msg = Message(destination='org.freedesktop.DBus',
-                                    path='/org/freedesktop/DBus',
-                                    interface='org.freedesktop.DBus',
-                                    member='AddMatch',
-                                    signature='s',
-                                    body=[self._name_owner_match_rule],
-                                    serial=self.next_serial())
-
             self._method_return_handlers[hello_msg.serial] = on_hello
-            self._method_return_handlers[add_match_msg.serial] = on_match_added
             self._stream.write(hello_msg._marshall())
-            self._stream.write(add_match_msg._marshall())
             self._stream.flush()
 
         self._authenticate(authenticate_notify)

dbus_next/message_bus.py

@@ -59,14 +59,22 @@ def __init__(self,
         self._stream = self._sock.makefile('rwb')
         self._fd = self._sock.fileno()
         self._user_message_handlers = []
+        # the key is the name and the value is the unique name of the owner.
+        # This cache is kept up to date by the NameOwnerChanged signal and is
+        # used to route messages to the correct proxy object. (used for the
+        # high level client only)
         self._name_owners = {}
+        # used for the high level service
         self._path_exports = {}
         self._bus_address = parse_address(bus_address) if bus_address else parse_address(
             get_bus_address(bus_type))
-        # the bus implementations need this rule to work correctly
+        # the bus implementations need this rule for the high level client to
+        # work correctly.
         self._name_owner_match_rule = "sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',path='/org/freedesktop/DBus',member='NameOwnerChanged'"
         # _match_rules: the keys are match rules and the values are ref counts
+        # (used for the high level client only)
         self._match_rules = {}
+        self._high_level_client_initialized = False
         self._ProxyObject = ProxyObject
 
         # machine id is lazy loaded
@@ -351,6 +359,8 @@ def get_proxy_object(self, bus_name: str, path: str,
         if self._ProxyObject is None:
             raise Exception('the message bus implementation did not provide a proxy object class')
 
+        self._init_high_level_client()
+
         return self._ProxyObject(bus_name, path, introspection, self)
 
     def disconnect(self):
@@ -631,8 +641,8 @@ def _process_message(self, msg):
                 [name, old_owner, new_owner] = msg.body
                 if new_owner:
                     self._name_owners[name] = new_owner
-                elif old_owner in self._name_owners:
-                    del self._name_owners[old_owner]
+                elif name in self._name_owners:
+                    del self._name_owners[name]
 
         elif msg.message_type == MessageType.METHOD_CALL:
             if not handled:
@@ -832,7 +842,35 @@ def _get_all_properties(self, interface):
 
         return result
 
+    def _init_high_level_client(self):
+        '''The high level client is initialized when the first proxy object is
+        gotten. Currently just sets up the match rules for the name owner cache
+        so signals can be routed to the right objects.'''
+        if self._high_level_client_initialized:
+            return
+        self._high_level_client_initialized = True
+
+        def add_match_notify(msg, err):
+            if err:
+                logging.error(
+                    f'add match request failed. match="{self._name_owner_match_rule}", {err}')
+            if msg.message_type == MessageType.ERROR:
+                logging.error(
+                    f'add match request failed. match="{self._name_owner_match_rule}", {msg.body[0]}'
+                )
+
+        self._call(
+            Message(destination='org.freedesktop.DBus',
+                    interface='org.freedesktop.DBus',
+                    path='/org/freedesktop/DBus',
+                    member='AddMatch',
+                    signature='s',
+                    body=[self._name_owner_match_rule]), add_match_notify)
+
     def _add_match_rule(self, match_rule):
+        '''Add a match rule. Match rules added by this function are refcounted
+        and must be removed by _remove_match_rule(). This is for use in the
+        high level client only.'''
         if match_rule == self._name_owner_match_rule:
             return
 
@@ -857,6 +895,8 @@ def add_match_notify(msg, err):
                     body=[match_rule]), add_match_notify)
 
     def _remove_match_rule(self, match_rule):
+        '''Remove a match rule added with _add_match_rule(). This is for use in
+        the high level client only.'''
         if match_rule == self._name_owner_match_rule:
             return
 

dbus_next/proxy_object.py

@@ -71,24 +71,31 @@ def _add_property(self, intr_property):
         raise NotImplementedError('this must be implemented in the inheriting class')
 
     def _message_handler(self, msg):
-        if msg._matches(message_type=MessageType.SIGNAL,
-                        interface=self.introspection.name,
-                        path=self.path) and msg.member in self._signal_handlers:
-            if msg.sender != self.bus_name and self.bus._name_owners.get(self.bus_name,
-                                                                         '') != msg.sender:
-                return
-            match = [s for s in self.introspection.signals if s.name == msg.member]
-            if not len(match):
-                return
-            intr_signal = match[0]
-            if intr_signal.signature != msg.signature:
-                logging.warning(
-                    f'got signal "{self.introspection.name}.{msg.member}" with unexpected signature "{msg.signature}"'
-                )
-                return
-
-            for handler in self._signal_handlers[msg.member]:
-                handler(*msg.body)
+        if not msg._matches(message_type=MessageType.SIGNAL,
+                            interface=self.introspection.name,
+                            path=self.path) or msg.member not in self._signal_handlers:
+            return
+
+        if msg.sender != self.bus_name and self.bus._name_owners.get(self.bus_name,
+                                                                     '') != msg.sender:
+            # The sender is always a unique name, but the bus name given might
+            # be a well known name. If the sender isn't an exact match, check
+            # to see if it owns the bus_name we were given from the cache kept
+            # on the bus for this purpose.
+            return
+
+        match = [s for s in self.introspection.signals if s.name == msg.member]
+        if not len(match):
+            return
+        intr_signal = match[0]
+        if intr_signal.signature != msg.signature:
+            logging.warning(
+                f'got signal "{self.introspection.name}.{msg.member}" with unexpected signature "{msg.signature}"'
+            )
+            return
+
+        for handler in self._signal_handlers[msg.member]:
+            handler(*msg.body)
 
     def _add_signal(self, intr_signal, interface):
         def on_signal_fn(fn):
@@ -218,12 +225,15 @@ def get_interface(self, name: str) -> BaseProxyInterface:
         def get_owner_notify(msg, err):
             if err:
                 logging.error(f'getting name owner for "{name}" failed, {err}')
+                return
             if msg.message_type == MessageType.ERROR:
-                logging.error(f'getting name owner for "{name}" failed, {msg.body[0]}')
+                if msg.error_name != ErrorType.NAME_HAS_NO_OWNER.value:
+                    logging.error(f'getting name owner for "{name}" failed, {msg.body[0]}')
+                return
 
             self.bus._name_owners[self.bus_name] = msg.body[0]
 
-        if self.bus_name[0] != ':':
+        if self.bus_name[0] != ':' and not self.bus._name_owners.get(self.bus_name, ''):
             self.bus._call(
                 Message(destination='org.freedesktop.DBus',
                         interface='org.freedesktop.DBus',

docs/low-level-interface/index.rst

@@ -23,6 +23,8 @@ The primary methods and classes of the low-level interface are:
 - :func:`glib.MessageBus.call() <dbus_next.glib.MessageBus.call>`
 - :func:`glib.MessageBus.call_sync() <dbus_next.glib.MessageBus.call_sync>`
 
+Mixed use of the low and high level interfaces on the same bus connection is not recommended.
+
 :example: Call a standard interface
 
 .. code-block:: python3
@@ -41,7 +43,7 @@ The primary methods and classes of the low-level interface are:
 
     print(reply.body[0])
 
-:example: A custom method handler
+:example: A custom method handler. Note that to receive these messages, you must `add a match rule <https://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-routing-match-rules>`_ for the types of messages you want to receive.
 
 .. code-block:: python3