Merge lp:~thomir-deactivatedaccount/autopilot/dbus-address-changes into lp:autopilot

[Thomi Richards]

Changes to Dbus address backend code to make it easier to get a proxy object from a dbus address.

Several changes to support backing autopilot on to different dbus backend locations. It is now easier to get an autopilot proxy object from a dbus backend - this could even be on a separate machine.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:180
http://jenkins.qa.ubuntu.com/job/autopilot-ci/46/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/46
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/45

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/46/rebuild

review: Approve (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/dbus-address-changes]

181. By Thomi Richards on 2013-04-30

Use the DBus address instance in place of service name and object path. Support for dbus introspection interface.

182. By Thomi Richards on 2013-04-30

Convert Qt interface.

183. By Thomi Richards on 2013-04-30

Fix missing import.

184. By Thomi Richards on 2013-04-30

Remove un-used optional parameter.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:181
http://jenkins.qa.ubuntu.com/job/autopilot-ci/48/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/48
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/47

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/48/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:184
http://jenkins.qa.ubuntu.com/job/autopilot-ci/50/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/50
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/49

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/50/rebuild

review: Approve (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/dbus-address-changes]

185. By Thomi Richards on 2013-04-30

whitespace fix.

[Christopher Lee (veebers)]

Awesome, looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:185
http://jenkins.qa.ubuntu.com/job/autopilot-ci/54/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/54
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/53

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/54/rebuild

review: Approve (continuous-integration)

=== modified file 'autopilot/introspection/__init__.py'
--- autopilot/introspection/__init__.py	2013-04-26 22:41:19 +0000
+++ autopilot/introspection/__init__.py	2013-04-30 20:33:25 +0000
@@ -24,6 +24,7 @@
 mechanism, and probably isn't useful to most test authors.
 
 """
+from __future__ import absolute_import
 
 import dbus
 import logging
@@ -32,20 +33,19 @@
 import os
 
 
+from autopilot.introspection.backends import DBusAddress
 from autopilot.introspection.constants import (
     AUTOPILOT_PATH,
     QT_AUTOPILOT_IFACE,
     AP_INTROSPECTION_IFACE,
-    DBUS_INTROSPECTION_IFACE,
     )
 from autopilot.introspection.dbus import (
     clear_object_registry,
     DBusIntrospectionObject,
-    object_passes_filters,
-    get_session_bus,
     get_classname_from_path,
     )
-from autopilot.utilities import get_debug_logger, addCleanup
+from autopilot.dbus_handler import get_session_bus
+from autopilot.utilities import get_debug_logger
 
 
 logger = logging.getLogger(__name__)
@@ -166,11 +166,6 @@
     bus_object = session_bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
     bus_iface = dbus.Interface(bus_object, 'org.freedesktop.DBus')
 
-    # clear the object registry, since it's specific to the dbus service, and we
-    # have just started a new service. We don't want the old types hanging around
-    # in the registry. We need a better method for this however.
-    clear_object_registry()
-
     logger.info("Looking for autopilot interface for PID %d (and children)", pid)
     # We give the process 10 seconds grace time to get the dbus interface up...
     for i in range(10):
@@ -214,27 +209,37 @@
     return result
 
 
-def make_proxy_object_from_service_name(service_name, obj_path):
+def make_proxy_object_from_service_name(service_name, obj_path, dbus_addr=None):
     """Returns a root proxy object given a DBus service name."""
     # parameters can sometimes be dbus.String instances, sometimes QString instances.
     # it's easier to convert them here than at the calling sites.
     service_name = str(service_name)
     obj_path = str(obj_path)
 
-    proxy_bases = get_proxy_object_base_clases(service_name, obj_path)
-    cls_name, cls_state = get_proxy_object_class_name_and_state(service_name, obj_path)
+    if dbus_addr is not None:
+        be = DBusAddress.CustomBus(dbus_addr, service_name, obj_path)
+    else:
+        be = DBusAddress.SessionBus(service_name, obj_path)
+
+
+    proxy_bases = get_proxy_object_base_clases(be)
+    cls_name, cls_state = get_proxy_object_class_name_and_state(be)
 
     clsobj = type(str(cls_name),
         proxy_bases,
-        dict(DBUS_SERVICE=service_name,
-            DBUS_OBJECT=obj_path
+        dict(_Backend = be
             )
         )
+
+    # clear the object registry, since it's specific to the dbus service, and we
+    # have just started a new service. We don't want the old types hanging around
+    # in the registry. We need a better method for this however.
+    clear_object_registry(clsobj._Backend)
     proxy = clsobj.get_root_instance()
     return proxy
 
 
-def get_proxy_object_base_clases(service_name, obj_path):
+def get_proxy_object_base_clases(backend):
     """Return  tuple of the base classes to use when creating a proxy object
     for the given service name & path.
 
@@ -244,11 +249,9 @@
 
     bases = [ApplicationProxyObject]
 
-    dbus_object = get_session_bus().get_object(service_name, obj_path)
-    introspection_iface = dbus.Interface(dbus_object, DBUS_INTROSPECTION_IFACE)
-    intro_xml = introspection_iface.Introspect()
+    intro_xml = backend.dbus_introspection_iface.Introspect()
     if AP_INTROSPECTION_IFACE not in intro_xml:
-        raise RuntimeError("Could not find Autopilot interface on service name '%s'" % service_name)
+        raise RuntimeError("Could not find Autopilot interface on DBus backend '%s'" % backend)
 
     if QT_AUTOPILOT_IFACE in intro_xml:
         from autopilot.introspection.qt import QtObjectProxyMixin
@@ -257,11 +260,9 @@
     return tuple(bases)
 
 
-def get_proxy_object_class_name_and_state(service_name, obj_path):
+def get_proxy_object_class_name_and_state(backend):
     """Return the class name and root state dictionary."""
-    dbus_object = get_session_bus().get_object(service_name, obj_path)
-    dbus_iface = dbus.Interface(dbus_object, AP_INTROSPECTION_IFACE)
-    object_path, object_state = dbus_iface.GetState("/")[0]
+    object_path, object_state = backend.introspection_iface.GetState("/")[0]
     return get_classname_from_path(object_path), object_state
 
 

=== added file 'autopilot/introspection/backends.py'
--- autopilot/introspection/backends.py	1970-01-01 00:00:00 +0000
+++ autopilot/introspection/backends.py	2013-04-30 20:33:25 +0000
@@ -0,0 +1,118 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Autopilot Functional Test Tool
+# Copyright (C) 2012-2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"Backend interface for autopilot."
+from __future__ import absolute_import
+
+from dbus._dbus import BusConnection
+import dbus
+
+from autopilot.introspection.constants import (
+    AP_INTROSPECTION_IFACE,
+    DBUS_INTROSPECTION_IFACE,
+    QT_AUTOPILOT_IFACE,
+    )
+
+
+class DBusAddress(object):
+
+    "Store information about an Autopilot dbus backend, from keyword arguments."
+
+    @staticmethod
+    def SessionBus(connection, object_path):
+        """Construct a DBusAddress that backs on to the session bus."""
+        return DBusAddress(dbus.SessionBus(), connection, object_path)
+
+    @staticmethod
+    def SystemBus(connection, object_path):
+        """Construct a DBusAddress that backs on to the system bus."""
+        return DBusAddress(dbus.SystemBus(), connection, object_path)
+
+    @staticmethod
+    def CustomBus(bus_address, connection, object_path):
+        """Construct a DBusAddress that backs on to a custom bus.
+
+        :param bus_address: A string representing the address of the dbus bus to
+            connect to.
+
+        """
+        return DBusAddress(BusConnection(bus_address), connection, object_path)
+
+    def __init__(self, bus, connection, object_path):
+        """Construct a DBusAddress instance.
+
+        :param bus: A valid DBus bus object.
+        :param connection: A string connection name to look at, or None to search
+            all dbus connections for objects that resemble an autopilot conection.
+        :param object_path: The path to the object that provides the autopilot
+            interface, or None to search for the object.
+
+        """
+        # We cannot evaluate kwargs for accuracy now, since this class will be
+        # created at module import time, at which point the bus backend probably
+        # does not exist yet.
+        self._bus = bus
+        self._connection = connection
+        self._object_path = object_path
+
+    @property
+    def introspection_iface(self):
+        if not isinstance(self._connection, basestring):
+            raise TypeError("Service name must be a string.")
+        if not isinstance(self._object_path, basestring):
+            raise TypeError("Object name must be a string")
+
+        _debug_proxy_obj = self._bus.get_object(self._connection, self._object_path)
+        return dbus.Interface(_debug_proxy_obj, AP_INTROSPECTION_IFACE)
+
+    @property
+    def dbus_introspection_iface(self):
+        dbus_object = self._bus.get_object(self._connection, self._object_path)
+        return dbus.Interface(dbus_object, DBUS_INTROSPECTION_IFACE)
+
+    @property
+    def qt_introspection_iface(self):
+        _debug_proxy_obj = self._bus.get_object(self._connection, self._object_path)
+        return dbus.Interface(_debug_proxy_obj, QT_AUTOPILOT_IFACE)
+
+    def __hash__(self):
+        return hash((self._bus, self._connection, self._object_path))
+
+    def __eq__(self, other):
+        return self._bus == other._bus and \
+            self._connection == other._connection and \
+            self._object_path == other._object_path
+
+    def __ne__(self, other):
+        return self._object_path != other._object_path or \
+            self._connection != other._connection or \
+            self._bus != other._bus
+
+    def __str__(self):
+        return repr(self)
+
+    def __repr__(self):
+        if self._bus_type == dbus.Bus.TYPE_SESSION:
+            name = "session"
+        elif self._bus_type == dbus.Bus.TYPE_SYSTEM:
+            name = "system"
+        else:
+            name = "custom"
+        return "<%s bus %s %s>" % (name, self._connection, self._object_path)
+

=== modified file 'autopilot/introspection/dbus.py'
--- autopilot/introspection/dbus.py	2013-04-30 00:04:23 +0000
+++ autopilot/introspection/dbus.py	2013-04-30 20:33:25 +0000
@@ -34,7 +34,6 @@
 from time import sleep
 from textwrap import dedent
 
-from autopilot.dbus_handler import get_session_bus
 from autopilot.introspection.constants import AP_INTROSPECTION_IFACE
 from autopilot.utilities import Timer
 
@@ -58,16 +57,15 @@
     def __new__(cls, classname, bases, classdict):
         """Add class name to type registry."""
         class_object = type.__new__(cls, classname, bases, classdict)
-        _object_registry[classname] = class_object
+        # The DBusIntrospectionObject class always has Backend == None, since it's
+        # not introspectable itself. We need to compensate for this...
+        if class_object._Backend is not None:
+            _object_registry[class_object._Backend] = {classname:class_object}
         return class_object
 
 
-def clear_object_registry():
-    """Clear the object registry.
-
-    .. important:: DO NOT CALL THIS UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!
-     ... and even then, are you *sure*?
-    """
+def clear_object_registry(target_backend):
+    """Delete all class objects from the object registry for a single backend."""
     global _object_registry
 
     # NOTE: We used to do '_object_registry.clear()' here, but that causes issues
@@ -80,31 +78,13 @@
     # - Thomi Richards
     to_delete = []
     for k,v in _object_registry.iteritems():
-        if v.DBUS_SERVICE != "com.canonical.Unity":
+        if k == target_backend:
             to_delete.append(k)
 
     for k in to_delete:
         del _object_registry[k]
 
 
-def get_introspection_iface(service_name, object_path):
-    """Get the autopilot introspection interface for the specified service name
-    and object path.
-
-    :param string service_name:
-    :param string object_name:
-    :raises: **TypeError** on invalid parameter type
-
-    """
-    if not isinstance(service_name, basestring):
-        raise TypeError("Service name must be a string.")
-    if not isinstance(object_path, basestring):
-        raise TypeError("Object name must be a string")
-
-    _debug_proxy_obj = get_session_bus().get_object(service_name, object_path)
-    return Interface(_debug_proxy_obj, AP_INTROSPECTION_IFACE)
-
-
 def translate_state_keys(state_dict):
     """Translates the *state_dict* passed in so the keys are usable as python attributes."""
     return {k.replace('-','_'):v for k,v in state_dict.iteritems() }
@@ -137,8 +117,7 @@
 
     __metaclass__ = IntrospectableObjectMetaclass
 
-    DBUS_SERVICE = None
-    DBUS_OBJECT = None
+    _Backend = None
 
     def __init__(self, state_dict, path):
         self.__state = {}
@@ -443,10 +422,7 @@
             raise TypeError("XPath query must be a string, not %r", type(piece))
 
         with Timer("GetState %s" % piece):
-            return get_introspection_iface(
-                cls.DBUS_SERVICE,
-                cls.DBUS_OBJECT
-                ).GetState(piece)
+            return cls._Backend.introspection_iface.GetState(piece)
 
     def get_new_state(self):
         """Retrieve a new state dictionary for this class instance.
@@ -474,7 +450,7 @@
         path, state = dbus_tuple
         name = get_classname_from_path(path)
         try:
-            class_type = _object_registry[name]
+            class_type = _object_registry[cls._Backend][name]
         except KeyError:
             logger.warning("Generating introspection instance for type '%s' based on generic class.", name)
             class_type = type(str(name), (cls,), {})

=== modified file 'autopilot/introspection/qt.py'
--- autopilot/introspection/qt.py	2013-04-23 04:15:54 +0000
+++ autopilot/introspection/qt.py	2013-04-30 20:33:25 +0000
@@ -23,14 +23,11 @@
 
 __all__ = ['QtApplicationLauncher']
 
-import dbus
 import functools
 
 import logging
 
 from autopilot.introspection import ApplicationLauncher
-from autopilot.introspection.constants import QT_AUTOPILOT_IFACE
-from autopilot.introspection.dbus import get_session_bus
 
 
 logger = logging.getLogger(__name__)
@@ -102,8 +99,7 @@
 
         """
 
-        _debug_proxy_obj = get_session_bus().get_object(self.DBUS_SERVICE, self.DBUS_OBJECT)
-        return dbus.Interface(_debug_proxy_obj, QT_AUTOPILOT_IFACE)
+        return self._Backend.qt_introspection_iface
 
     @property
     def slots(self):

=== added file 'autopilot/tests/test_backend.py'
--- autopilot/tests/test_backend.py	1970-01-01 00:00:00 +0000
+++ autopilot/tests/test_backend.py	2013-04-30 20:33:25 +0000
@@ -0,0 +1,52 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Autopilot Functional Test Tool
+# Copyright (C) 2012-2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+from testtools import TestCase
+from testtools.matchers import Equals, Not, NotEquals
+from autopilot.introspection.backends import DBusAddress
+
+class DBusAddressTests(TestCase):
+
+    def test_can_construct(self):
+        fake_bus = object()
+        addr = DBusAddress(fake_bus, "conn", "path")
+
+    def test_can_store_address_in_dictionary(self):
+        fake_bus = object()
+        addr = DBusAddress(fake_bus, "conn", "path")
+        dict(addr=object())
+
+    def test_equality_operator(self):
+        fake_bus = object()
+        addr1 = DBusAddress(fake_bus, "conn", "path")
+
+        self.assertThat(addr1, Equals(DBusAddress(fake_bus, "conn", "path")))
+        self.assertThat(addr1, Not(Equals(DBusAddress(fake_bus, "conn", "new_path"))))
+        self.assertThat(addr1, Not(Equals(DBusAddress(fake_bus, "conn2", "path"))))
+        self.assertThat(addr1, Not(Equals(DBusAddress(object(), "conn", "path"))))
+
+    def test_inequality_operator(self):
+        fake_bus = object()
+        addr1 = DBusAddress(fake_bus, "conn", "path")
+
+        self.assertThat(addr1, Not(NotEquals(DBusAddress(fake_bus, "conn", "path"))))
+        self.assertThat(addr1, NotEquals(DBusAddress(fake_bus, "conn", "new_path")))
+        self.assertThat(addr1, NotEquals(DBusAddress(fake_bus, "conn2", "path")))
+        self.assertThat(addr1, NotEquals(DBusAddress(object(), "conn", "path")))