Merge lp:~therve/landscape-client/restore-hardware-monitor into lp:~landscape/landscape-client/trunk

[Thomas Herve]

The branch basically reverts r414 from trunk, except keeping the new hardwareinfo manager plugin.

[Fernando Correa Neto (fcorrea)]

Everything went fine on my system (Oneiric)

PASSED (successes=2298)

+1!

review: Approve

[Geoff Teale (tealeg)]

+1 Good for me.

One small thing.

+ logging.error("Couldn't to connect to Hal via DBus")

The "to" there is unecessary.

review: Approve

[lp:~therve/landscape-client/restore-hardware-monitor]

472. By Thomas Herve on 2012-03-06

CLeanups

=== modified file 'README'
--- README	2011-12-01 14:01:29 +0000
+++ README	2012-03-06 09:20:24 +0000
@@ -23,6 +23,14 @@
 
 == Developing ==
 
+To run the full test suite, you must have a dbus session bus
+running. If you don't have one (for example, if you're running the
+tests in an ssh session), run the following command:
+
+export DBUS_SESSION_BUS_ADDRESS=`dbus-daemon --print-address=1 --session --fork`
+
+Then your tests should pass.
+
 When you want to test the landscape client manually without management
 features, you can simply run:
 
@@ -31,7 +39,8 @@
 This defaults to the 'landscape-client.conf' configuration file.
 
 When you want to test management features manually, you'll need to run as root.
-There's a configuration file 'root-client.conf'.
+There's a configuration file 'root-client.conf' which specifies use of the
+system bus.
 
 $ sudo ./scripts/landscape-client -c root-client.conf
 

=== added directory 'dbus'
=== added file 'dbus/landscape.conf'
--- dbus/landscape.conf	1970-01-01 00:00:00 +0000
+++ dbus/landscape.conf	2012-03-06 09:20:24 +0000
@@ -0,0 +1,62 @@
+<!DOCTYPE busconfig PUBLIC
+ "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+
+  <policy user="landscape">
+    <allow own="com.canonical.landscape.Broker" />
+    <allow own="com.canonical.landscape.Monitor" />
+
+    <allow send_destination="com.canonical.landscape.Broker" />
+    <allow receive_sender="com.canonical.landscape.Broker" />
+
+    <allow send_destination="com.canonical.landscape.Monitor" />
+    <allow receive_sender="com.canonical.landscape.Monitor" />
+
+    <allow send_destination="com.canonical.landscape.Manager" />
+    <allow receive_sender="com.canonical.landscape.Manager" />
+
+    <allow send_interface="org.freedesktop.Hal.Manager" />
+    <allow send_interface="org.freedesktop.Hal.Device" />
+
+  </policy>
+
+  <!-- this is a horrible hack -->
+  <policy user="haldaemon">
+
+    <allow receive_sender="com.canonical.landscape.Manager" />
+    <allow receive_sender="com.canonical.landscape.Monitor" />
+    <allow receive_sender="com.canonical.landscape.Broker" />
+
+  </policy>
+
+  <policy user="root">
+    <allow own="com.canonical.landscape.Manager" />
+
+    <allow send_destination="com.canonical.landscape.Broker" />
+    <allow receive_sender="com.canonical.landscape.Broker" />
+
+    <allow send_destination="com.canonical.landscape.Monitor" />
+    <allow receive_sender="com.canonical.landscape.Monitor" />
+
+    <allow send_destination="com.canonical.landscape.Manager" />
+    <allow receive_sender="com.canonical.landscape.Manager" />
+  </policy>
+
+  <policy context="default">
+    <deny own="com.canonical.landscape.Broker" />
+    <deny own="com.canonical.landscape.Monitor" />
+    <deny own="com.canonical.landscape.Manager" />
+
+    <deny send_destination="com.canonical.landscape.Broker" />
+    <deny receive_sender="com.canonical.landscape.Broker" />
+
+    <deny send_destination="com.canonical.landscape.Monitor" />
+    <deny receive_sender="com.canonical.landscape.Monitor" />
+
+    <deny send_destination="com.canonical.landscape.Manager" />
+    <deny receive_sender="com.canonical.landscape.Manager" />
+
+  </policy>
+
+</busconfig>

=== modified file 'debian/landscape-client.install'
--- debian/landscape-client.install	2011-12-01 14:01:29 +0000
+++ debian/landscape-client.install	2012-03-06 09:20:24 +0000
@@ -8,5 +8,7 @@
 usr/bin/landscape-package-reporter
 usr/bin/landscape-release-upgrader
 usr/bin/landscape-is-cloud-managed
+usr/bin/landscape-dbus-proxy
 usr/share/landscape/cloud-default.conf
+etc/dbus-1/system.d/landscape.conf
 usr/lib/landscape

=== modified file 'debian/landscape-client.postinst'
--- debian/landscape-client.postinst	2012-02-28 17:47:57 +0000
+++ debian/landscape-client.postinst	2012-03-06 09:20:24 +0000
@@ -129,6 +129,17 @@
         if [ -e $very_old_cron_job ]; then
             rm $very_old_cron_job
         fi
+
+        # Check if we're upgrading from a D-Bus version
+        if ! [ -z $2 ]; then
+            if dpkg --compare-versions $2 lt 1.5.1; then
+                # Launch a proxy service that will forward requests over DBus
+                # from the old package-changer to the new AMP-based broker. This
+                # is a one-off only needed for the DBus->AMP upgrade
+                start-stop-daemon -x /usr/bin/landscape-dbus-proxy -b -c landscape -u landscape -S
+            fi
+         fi
+
     ;;
 
     abort-upgrade|abort-remove|abort-deconfigure)

=== modified file 'debian/rules'
--- debian/rules	2012-02-10 17:59:13 +0000
+++ debian/rules	2012-03-06 09:20:24 +0000
@@ -60,6 +60,7 @@
 	install -D -o root -g root -m 644 debian/cloud-default.conf $(root_dir)/usr/share/landscape/cloud-default.conf
 	install -D -o root -g root -m 755 smart-update/smart-update $(root_dir)/usr/lib/landscape/smart-update
 	install -D -o root -g root -m 755 apt-update/apt-update $(root_dir)/usr/lib/landscape/apt-update
+	install -D -o root -g root -m 644 dbus/landscape.conf $(root_dir)/etc/dbus-1/system.d/landscape.conf
 
 binary-indep:
 # do nothing
@@ -83,22 +84,24 @@
 
 ifneq (,$(findstring $(dist_release),"dapper"))
 	# We need python2.4-pysqlite2 and a non-buggy libcurl3-gnutls on dapper
-	echo "extra:Depends=python2.4-pysqlite2, libcurl3-gnutls (>= 7.15.1-1ubuntu3), python-smartpm (>= 1.1.1~bzr20081010-0ubuntu1.6.06.0)" >> $(landscape_common_substvars)
-	echo "extra:Depends=python2.4-pycurl" >> $(landscape_client_substvars)
+	echo "extra:Depends=python2.4-pysqlite2, libcurl3-gnutls (>= 7.15.1-1ubuntu3), python-smartpm (>= 1.1.1~bzr20081010-0ubuntu1.6.06.0), python2.4-dbus" >> $(landscape_common_substvars)
+	echo "extra:Depends=python2.4-pycurl, hal" >> $(landscape_client_substvars)
 endif
 ifneq (,$(findstring $(dist_release),"hardy"))
 	# We want the smart 1.1.1 from the Landscape repository on hardy
-	echo "extra:Depends=python-smartpm (>= 1.1.1~bzr20081010-0ubuntu1.8.04.1)" >> $(landscape_common_substvars)
-	echo "extra:Depends=python-pycurl" >> $(landscape_client_substvars)
+	echo "extra:Depends=python-smartpm (>= 1.1.1~bzr20081010-0ubuntu1.8.04.1), python-dbus" >> $(landscape_common_substvars)
+	echo "extra:Depends=python-pycurl, hal" >> $(landscape_client_substvars)
 endif
 ifneq (,$(filter $(dist_release),karmic lucid maverick))
 	# We want libpam-modules in karmic, and smart 1.2
-	echo "extra:Depends=libpam-modules (>= 1.0.1-9ubuntu3), python-smartpm (>= 1.2-4)" >> $(landscape_common_substvars)
-	echo "extra:Depends=python-pycurl" >> $(landscape_client_substvars)
+	echo "extra:Depends=libpam-modules (>= 1.0.1-9ubuntu3), python-smartpm (>= 1.2-4), python-dbus" >> $(landscape_common_substvars)
+	echo "extra:Depends=python-pycurl, hal" >> $(landscape_client_substvars)
 endif
 ifeq (,$(filter $(dist_release),dapper hardy karmic lucid maverick))
+	# Starting natty, no more hal or dbus
 	echo "extra:Depends=libpam-modules (>= 1.0.1-9ubuntu3), python-smartpm (>= 1.2-4)" >> $(landscape_common_substvars)
 	echo "extra:Depends=python-pycurl, gir1.2-gudev-1.0 (>= 165-0ubuntu2)" >> $(landscape_client_substvars)
+	echo "extra:Suggests=python-dbus, hal" >> $(landscape_client_substvars)
 endif
 ifeq (,$(filter $(dist_release),dapper hardy karmic))
 	# The python-image-store-proxy package is needed for the eucalyptus plugin

=== modified file 'landscape/broker/exchange.py'
--- landscape/broker/exchange.py	2011-12-01 14:01:29 +0000
+++ landscape/broker/exchange.py	2012-03-06 09:20:24 +0000
@@ -422,7 +422,9 @@
                 handler(message)
 
     def register_client_accepted_message_type(self, type):
-        self._client_accepted_types.add(type)
+        # stringify the type because it's a dbus.String.  It should work
+        # anyway, but this is just for sanity and less confusing logs.
+        self._client_accepted_types.add(str(type))
 
     def get_client_accepted_message_types(self):
         return sorted(self._client_accepted_types)

=== added file 'landscape/hal.py'
--- landscape/hal.py	1970-01-01 00:00:00 +0000
+++ landscape/hal.py	2012-03-06 09:20:24 +0000
@@ -0,0 +1,52 @@
+import logging
+
+from dbus import Interface, SystemBus
+from dbus.exceptions import DBusException
+
+
+class HALManager(object):
+
+    def __init__(self, bus=None):
+        try:
+            self._bus = bus or SystemBus()
+            manager = self._bus.get_object("org.freedesktop.Hal",
+                                           "/org/freedesktop/Hal/Manager")
+        except DBusException:
+            logging.error("Couldn't connect to Hal via DBus")
+            self._manager = None
+        else:
+            self._manager = Interface(manager, "org.freedesktop.Hal.Manager")
+
+    def get_devices(self):
+        """Returns a list of HAL devices.
+
+        @note: If it wasn't possible to connect to HAL over DBus, then an
+            empty list will be returned. This can happen if the HAL or DBus
+            services are not running.
+        """
+        if not self._manager:
+            return []
+        devices = []
+        for udi in self._manager.GetAllDevices():
+            device = self._bus.get_object("org.freedesktop.Hal", udi)
+            device = Interface(device, "org.freedesktop.Hal.Device")
+            device = HALDevice(device)
+            devices.append(device)
+        return devices
+
+
+class HALDevice(object):
+
+    def __init__(self, device):
+        self._children = []
+        self._device = device
+        self.properties = device.GetAllProperties()
+        self.udi = self.properties["info.udi"]
+        self.parent = None
+
+    def add_child(self, device):
+        self._children.append(device)
+        device.parent = self
+
+    def get_children(self):
+        return self._children

=== added file 'landscape/lib/bpickle_dbus.py'
--- landscape/lib/bpickle_dbus.py	1970-01-01 00:00:00 +0000
+++ landscape/lib/bpickle_dbus.py	2012-03-06 09:20:24 +0000
@@ -0,0 +1,65 @@
+"""
+Different versions of the Python DBus bindings return different types
+to represent integers, strings, lists, etc.  Older versions return
+builtin Python types: C{int}, C{str}, C{list}, etc.  Newer versions
+return DBus-specific wrappers: C{Int16}, C{String}, C{Array}, etc.
+Failures occur when DBus types are used because bpickle doesn't know
+that an C{Int16} is really an C{int} and that an C{Array} is really a
+C{list}.
+
+L{install} and L{uninstall} can install and remove extensions that
+make bpickle work with DBus types.
+"""
+
+import dbus
+
+from landscape.lib import bpickle
+
+
+def install():
+    """Install bpickle extensions for DBus types."""
+    for type, function in get_dbus_types():
+        bpickle.dumps_table[type] = function
+
+
+def uninstall():
+    """Uninstall bpickle extensions for DBus types."""
+    for type, function in get_dbus_types():
+        del bpickle.dumps_table[type]
+
+
+def dumps_utf8string(obj):
+    """
+    Convert the specified L{dbus.types.UTF8String} to bpickle's
+    representation for C{unicode} data.
+    """
+    return "u%s:%s" % (len(obj), obj)
+
+
+def dumps_double(obj):
+    """
+    Convert a dbus.types.Double into a floating point representation.
+    """
+    return "f%r;" % float(obj)
+
+
+def get_dbus_types():
+    """
+    Generator yields C{(type, bpickle_function)} for available DBus
+    types.
+    """
+    for (type_name, function) in [("Boolean", bpickle.dumps_bool),
+                                  ("Int16", bpickle.dumps_int),
+                                  ("UInt16", bpickle.dumps_int),
+                                  ("Int32", bpickle.dumps_int),
+                                  ("UInt32", bpickle.dumps_int),
+                                  ("Int64", bpickle.dumps_int),
+                                  ("UInt64", bpickle.dumps_int),
+                                  ("Double", dumps_double),
+                                  ("Array", bpickle.dumps_list),
+                                  ("Dictionary", bpickle.dumps_dict),
+                                  ("String", bpickle.dumps_unicode),
+                                  ("UTF8String", dumps_utf8string)]:
+        type = getattr(dbus.types, type_name, None)
+        if type is not None:
+            yield type, function

=== modified file 'landscape/monitor/config.py'
--- landscape/monitor/config.py	2011-11-30 09:28:10 +0000
+++ landscape/monitor/config.py	2012-03-06 09:20:24 +0000
@@ -1,10 +1,11 @@
 from landscape.deployment import Configuration
 
 
-ALL_PLUGINS = ["ActiveProcessInfo", "ComputerInfo", "LoadAverage",
-               "MemoryInfo", "MountInfo", "ProcessorInfo", "Temperature",
-               "PackageMonitor", "UserMonitor", "RebootRequired",
-               "AptPreferences", "NetworkActivity", "NetworkDevice"]
+ALL_PLUGINS = ["ActiveProcessInfo", "ComputerInfo", "HardwareInventory",
+               "LoadAverage", "MemoryInfo", "MountInfo", "ProcessorInfo",
+               "Temperature", "PackageMonitor", "UserMonitor",
+               "RebootRequired", "AptPreferences", "NetworkActivity",
+               "NetworkDevice"]
 
 
 class MonitorConfiguration(Configuration):

=== added file 'landscape/monitor/hardwareinventory.py'
--- landscape/monitor/hardwareinventory.py	1970-01-01 00:00:00 +0000
+++ landscape/monitor/hardwareinventory.py	2012-03-06 09:20:24 +0000
@@ -0,0 +1,114 @@
+import logging
+
+from twisted.internet.defer import succeed
+
+from landscape.lib.log import log_failure
+
+from landscape.diff import diff
+from landscape.monitor.plugin import MonitorPlugin
+
+
+class HardwareInventory(MonitorPlugin):
+
+    persist_name = "hardware-inventory"
+
+    def __init__(self, hal_manager=None):
+        super(HardwareInventory, self).__init__()
+        self._persist_sets = []
+        self._persist_removes = []
+        self.enabled = True
+        try:
+            from landscape.hal import HALManager
+        except ImportError:
+            self.enabled = False
+        else:
+            self._hal_manager = hal_manager or HALManager()
+
+    def register(self, manager):
+        if not self.enabled:
+            return
+        super(HardwareInventory, self).register(manager)
+        self.call_on_accepted("hardware-inventory", self.exchange, True)
+
+    def send_message(self, urgent):
+        devices = self.create_message()
+        if devices:
+            message = {"type": "hardware-inventory", "devices": devices}
+            result = self.registry.broker.send_message(message, urgent=urgent)
+            result.addCallback(self.persist_data)
+            result.addErrback(log_failure)
+            logging.info("Queueing a message with hardware-inventory "
+                         "information.")
+        else:
+            result = succeed(None)
+        return result
+
+    def exchange(self, urgent=False):
+        if not self.enabled:
+            return
+        return self.registry.broker.call_if_accepted("hardware-inventory",
+                                                     self.send_message, urgent)
+
+    def persist_data(self, message_id):
+        for key, udi, value in self._persist_sets:
+            self._persist.set((key, udi), value)
+        for key in self._persist_removes:
+            self._persist.remove(key)
+        del self._persist_sets[:]
+        del self._persist_removes[:]
+        # This forces the registry to write the persistent store to disk
+        # This means that the persistent data reflects the state of the
+        # messages sent.
+        self.registry.flush()
+
+    def create_message(self):
+        # FIXME Using persist to keep track of changes here uses a
+        # fair amount of memory.  On my machine a rough test seemed to
+        # indicate that memory usage grew by 1.3mb, about 12% of the
+        # overall process size.  Look here to save memory.
+        del self._persist_sets[:]
+        del self._persist_removes[:]
+        devices = []
+        previous_devices = self._persist.get("devices", {})
+        current_devices = set()
+
+        for device in self._hal_manager.get_devices():
+            previous_properties = previous_devices.get(device.udi)
+            if not previous_properties:
+                devices.append(("create", device.properties))
+            elif previous_properties != device.properties:
+                creates, updates, deletes = diff(previous_properties,
+                                                 device.properties)
+                devices.append(("update", device.udi,
+                                creates, updates, deletes))
+            current_devices.add(device.udi)
+            self._persist_sets.append(
+                ("devices", device.udi, device.properties))
+
+        items_with_parents = {}
+        deleted_devices = set()
+        for udi, value in previous_devices.iteritems():
+            if udi not in current_devices:
+                if "info.parent" in value:
+                    items_with_parents[udi] = value["info.parent"]
+                deleted_devices.add(udi)
+
+        # We remove the deleted devices from our persistent store it's
+        # only the information we're sending to the server that we're
+        # compressing.
+        for udi in deleted_devices:
+            self._persist_removes.append(("devices", udi))
+
+        # We can now flatten the list of devices we send to the server
+        # For each of the items_with_parents, if both the item and it's parent
+        # are in the deleted_devices set, then we can remove this item from the
+        # set.
+        minimal_deleted_devices = deleted_devices.copy()
+        for child, parent in items_with_parents.iteritems():
+            if child in deleted_devices and parent in deleted_devices:
+                minimal_deleted_devices.remove(child)
+        # We now build the deleted devices message
+        for udi in minimal_deleted_devices:
+            devices.append(("delete", udi))
+
+        return devices

=== modified file 'landscape/monitor/mountinfo.py'
--- landscape/monitor/mountinfo.py	2011-12-01 13:38:58 +0000
+++ landscape/monitor/mountinfo.py	2012-03-06 09:20:24 +0000
@@ -15,7 +15,7 @@
 
     def __init__(self, interval=300, monitor_interval=60 * 60,
                  mounts_file="/proc/mounts", create_time=time.time,
-                 statvfs=None, mtab_file="/etc/mtab"):
+                 statvfs=None, hal_manager=None, mtab_file="/etc/mtab"):
         self.run_interval = interval
         self._monitor_interval = monitor_interval
         self._create_time = create_time
@@ -29,6 +29,12 @@
         self._mount_info = []
         self._mount_info_to_persist = None
         try:
+            from landscape.hal import HALManager
+        except ImportError:
+            self._hal_manager = hal_manager
+        else:
+            self._hal_manager = hal_manager or HALManager()
+        try:
             from gi.repository import GUdev
         except ImportError:
             self._gudev_client = None
@@ -116,7 +122,9 @@
             current_mount_points.add(mount_point)
 
     def _get_removable_devices(self):
-        if self._gudev_client is not None:
+        if self._hal_manager is not None:
+            return self._get_hal_removable_devices()
+        elif self._gudev_client is not None:
             return self._get_udev_removable_devices()
         else:
             return set()
@@ -130,6 +138,61 @@
                 return False
         return is_removable()
 
+    def _get_hal_removable_devices(self):
+        block_devices = {}  # {udi: [device, ...]}
+        children = {}  # {parent_udi: [child_udi, ...]}
+        removable = set()
+
+        # We walk the list of devices building up a dictionary of all removable
+        # devices, and a mapping of {UDI => [block devices]}
+        # We differentiate between devices that we definitely know are
+        # removable and devices that _may_ be removable, depending on their
+        # parent device, e.g. /dev/sdb1 isn't flagged as removable, but
+        # /dev/sdb may well be removable.
+
+        # Unfortunately, HAL doesn't guarantee the order of the devices
+        # returned from get_devices(), so we may not know that a parent device
+        # is removable when we find it's first child.
+        devices = self._hal_manager.get_devices()
+        for device in devices:
+            block_device = device.properties.get("block.device")
+            if block_device:
+                if device.properties.get("storage.removable"):
+                    removable.add(device.udi)
+
+                try:
+                    block_devices[device.udi].append(block_device)
+                except KeyError:
+                    block_devices[device.udi] = [block_device]
+
+                parent_udi = device.properties.get("info.parent")
+                if parent_udi is not None:
+                    try:
+                        children[parent_udi].append(device.udi)
+                    except KeyError:
+                        children[parent_udi] = [device.udi]
+
+        # Propagate the removable flag from each node all the way to
+        # its leaf children.
+        updated = True
+        while updated:
+            updated = False
+            for parent_udi in children:
+                if parent_udi in removable:
+                    for child_udi in children[parent_udi]:
+                        if child_udi not in removable:
+                            removable.add(child_udi)
+                            updated = True
+
+        # We've now seen _all_ devices, and have the definitive list of
+        # removable UDIs, so we can now find all the removable devices in the
+        # system.
+        removable_devices = set()
+        for udi in removable:
+            removable_devices.update(block_devices[udi])
+
+        return removable_devices
+
     def _get_mount_info(self):
         """Generator yields local mount points worth recording data for."""
         removable_devices = self._get_removable_devices()

=== added file 'landscape/monitor/tests/test_hardwareinventory.py'
--- landscape/monitor/tests/test_hardwareinventory.py	1970-01-01 00:00:00 +0000
+++ landscape/monitor/tests/test_hardwareinventory.py	2012-03-06 09:20:24 +0000
@@ -0,0 +1,273 @@
+from twisted.internet.defer import fail, succeed
+
+from landscape.monitor.hardwareinventory import HardwareInventory
+from landscape.tests.test_hal import MockHALManager, MockRealHALDevice
+from landscape.tests.helpers import LandscapeTest, MonitorHelper
+from landscape.tests.mocker import ANY
+from landscape.message_schemas import HARDWARE_INVENTORY
+
+
+class HardwareInventoryTest(LandscapeTest):
+
+    helpers = [MonitorHelper]
+
+    def setUp(self):
+        super(HardwareInventoryTest, self).setUp()
+        self.mstore.set_accepted_types(["hardware-inventory"])
+        devices = [MockRealHALDevice({u"info.udi": u"wubble",
+                                      u"info.product": u"Wubble"}),
+                   MockRealHALDevice({u"info.udi": u"ooga",
+                                      u"info.product": u"Ooga"})]
+        self.hal_manager = MockHALManager(devices)
+        self.plugin = HardwareInventory(hal_manager=self.hal_manager)
+        self.monitor.add(self.plugin)
+
+    def assertSchema(self, devices):
+        full_message = {"type": "hardware-inventory", "devices": devices}
+        self.assertEqual(HARDWARE_INVENTORY.coerce(full_message),
+                         full_message)
+
+    def test_hal_devices(self):
+        """
+        The first time the plugin runs it should report information
+        about all HAL devices found on the system.  Every UDI provided
+        by HAL should be present in the devices list as is from HAL.
+        """
+        message = self.plugin.create_message()
+        actual_udis = [part[1][u"info.udi"] for part in message]
+        expected_udis = [device.udi for device
+                         in self.hal_manager.get_devices()]
+        self.assertEqual(set(actual_udis), set(expected_udis))
+
+    def test_first_message(self):
+        """
+        The first time the plugin runs it should report information
+        about all HAL devices found on the system.  All new devices
+        will be reported with 'create' actions.
+        """
+        message = self.plugin.create_message()
+        actions = [part[0] for part in message]
+        self.assertEqual(set(actions), set(["create"]))
+        self.assertSchema(message)
+
+    def test_no_changes(self):
+        """
+        Messages should not be created if hardware information is
+        unchanged since the last server exchange.
+        """
+        self.plugin.exchange()
+        self.assertNotEquals(len(self.mstore.get_pending_messages()), 0)
+
+        messages = self.mstore.get_pending_messages()
+        self.plugin.exchange()
+        self.assertEqual(self.mstore.get_pending_messages(), messages)
+
+    def test_update(self):
+        """
+        If a change is detected for a device that was previously
+        reported to the server, the changed device should be reported
+        with an 'update' action.  Property changes are reported at a
+        key/value pair level.
+        """
+        self.hal_manager.devices = [
+            MockRealHALDevice({u"info.udi": u"wubble",
+                               u"info.product": u"Wubble"})]
+        registry_mocker = self.mocker.replace(self.plugin.registry)
+        registry_mocker.flush()
+        self.mocker.count(2)
+        self.mocker.result(None)
+        self.mocker.replay()
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+        self.assertEqual(message, [("create", {u"info.udi": u"wubble",
+                                               u"info.product": u"Wubble"})])
+
+        self.hal_manager.devices[0] = MockRealHALDevice(
+            {u"info.udi": u"wubble", u"info.product": u"Ooga"})
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+        self.assertEqual(message, [("update", u"wubble",
+                                    {}, {u"info.product": u"Ooga"}, {})])
+        self.assertSchema(message)
+        self.assertEqual(self.plugin.create_message(), [])
+
+    def test_update_list(self):
+        """
+        An update should be sent to the server when a strlist device
+        property changes.  No updates should be sent if a device is
+        unchanged.
+        """
+        self.hal_manager.devices = [
+            MockRealHALDevice({u"info.udi": u"wubble",
+                               u"info.product": u"Wubble",
+                               u"info.capabilities": [u"foo", u"bar"]})]
+
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+        self.assertEqual(message, [("create",
+                                    {u"info.udi": u"wubble",
+                                     u"info.product": u"Wubble",
+                                     u"info.capabilities": [u"foo", u"bar"]}),
+                                   ])
+
+        self.assertSchema(message)
+
+        self.hal_manager.devices[0] = MockRealHALDevice(
+            {u"info.udi": u"wubble", u"info.product": u"Wubble",
+             u"info.capabilities": [u"foo"]})
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+        self.assertEqual(message, [("update", u"wubble",
+                                    {}, {u"info.capabilities": [u"foo"]}, {}),
+                                   ])
+        self.assertSchema(message)
+
+        self.assertEqual(self.plugin.create_message(), [])
+
+    def test_update_complex(self):
+        """
+        The 'update' action reports property create, update and
+        delete changes.
+        """
+        self.hal_manager.devices = [
+            MockRealHALDevice({u"info.udi": u"wubble",
+                               u"info.product": u"Wubble",
+                               u"linux.acpi_type": 11})]
+
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+        self.assertEqual(message, [("create", {u"info.udi": u"wubble",
+                                               u"info.product": u"Wubble",
+                                               u"linux.acpi_type": 11})])
+
+        self.hal_manager.devices[0] = MockRealHALDevice(
+            {u"info.udi": u"wubble", u"info.product": u"Ooga",
+             u"info.category": u"unittest"})
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+        self.assertEqual(message, [("update", u"wubble",
+                                    {u"info.category": u"unittest"},
+                                    {u"info.product": u"Ooga"},
+                                    {u"linux.acpi_type": 11})])
+        self.assertSchema(message)
+
+        self.assertEqual(self.plugin.create_message(), [])
+
+    def test_delete(self):
+        """
+        If a device that was previously reported is no longer present
+        in a system a device entry should be created with a 'delete'
+        action.
+        """
+        self.hal_manager.devices = [
+            MockRealHALDevice({u"info.udi": u"wubble",
+                               u"info.product": u"Wubble"}),
+            MockRealHALDevice({u"info.udi": u"ooga",
+                               u"info.product": u"Ooga"})]
+
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+        self.assertEqual(message, [("create", {u"info.udi": u"wubble",
+                                               u"info.product": u"Wubble"}),
+                                   ("create", {u"info.udi": u"ooga",
+                                               u"info.product": u"Ooga"})])
+        self.assertSchema(message)
+
+        self.hal_manager.devices.pop(1)
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+        self.assertEqual(message, [("delete", u"ooga")])
+        self.assertSchema(message)
+        self.assertEqual(self.plugin.create_message(), [])
+
+    def test_minimal_delete(self):
+        self.hal_manager.devices = [
+            MockRealHALDevice({u"info.udi": u"wubble",
+                               u"block.device": u"/dev/scd",
+                               u"storage.removable": True}),
+            MockRealHALDevice({u"info.udi": u"wubble0",
+                               u"block.device": u"/dev/scd0",
+                               u"info.parent": u"wubble"}),
+            MockRealHALDevice({u"info.udi": u"wubble1",
+                               u"block.device": u"/dev/scd1",
+                               u"info.parent": u"wubble"}),
+            MockRealHALDevice({u"info.udi": u"wubble2",
+                               u"block.device": u"/dev/scd1",
+                               u"info.parent": u"wubble0"}),
+            MockRealHALDevice({u"info.udi": u"wubble3",
+                               u"block.device": u"/dev/scd1",
+                               u"info.parent": u"wubble2"})]
+
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+
+        del self.hal_manager.devices[:]
+
+        message = self.plugin.create_message()
+        self.plugin.persist_data(None)
+
+        self.assertEqual(message, [("delete", u"wubble")])
+        self.assertEqual(self.plugin.create_message(), [])
+
+    def test_resynchronize(self):
+        """
+        If a 'resynchronize' reactor event is fired, the plugin should
+        send a message that contains all data as if the server has
+        none.
+        """
+        self.plugin.exchange()
+        self.reactor.fire("resynchronize")
+        self.plugin.exchange()
+
+        messages = self.mstore.get_pending_messages()
+        self.assertEqual(len(messages), 2)
+        self.assertEqual(messages[0]["devices"], messages[1]["devices"])
+
+    def test_call_on_accepted(self):
+        remote_broker_mock = self.mocker.replace(self.remote)
+        remote_broker_mock.send_message(ANY, urgent=True)
+        self.mocker.result(succeed(None))
+        self.mocker.replay()
+
+        self.reactor.fire(("message-type-acceptance-changed",
+                           "hardware-inventory"),
+                          True)
+
+    def test_no_message_if_not_accepted(self):
+        """
+        Don't add any messages at all if the broker isn't currently
+        accepting their type.
+        """
+        self.mstore.set_accepted_types([])
+        self.reactor.advance(self.monitor.step_size * 2)
+        self.monitor.exchange()
+
+        self.mstore.set_accepted_types(["hardware-inventory"])
+        self.assertMessages(list(self.mstore.get_pending_messages()), [])
+
+    def test_do_not_persist_changes_when_send_message_fails(self):
+        """
+        When the plugin is run it persists data that it uses on
+        subsequent checks to calculate the delta to send.  It should
+        only persist data when the broker confirms that the message
+        sent by the plugin has been sent.
+        """
+
+        class MyException(Exception):
+            pass
+
+        self.log_helper.ignore_errors(MyException)
+
+        broker_mock = self.mocker.replace(self.monitor.broker)
+        broker_mock.send_message(ANY, urgent=ANY)
+        self.mocker.result(fail(MyException()))
+        self.mocker.replay()
+
+        message = self.plugin.create_message()
+
+        def assert_message(message_id):
+            self.assertEqual(message, self.plugin.create_message())
+
+        result = self.plugin.exchange()
+        result.addCallback(assert_message)
+        return result

=== modified file 'landscape/monitor/tests/test_mountinfo.py'
--- landscape/monitor/tests/test_mountinfo.py	2011-12-01 13:38:58 +0000
+++ landscape/monitor/tests/test_mountinfo.py	2012-03-06 09:20:24 +0000
@@ -3,6 +3,7 @@
 from twisted.internet.defer import succeed
 
 from landscape.monitor.mountinfo import MountInfo
+from landscape.tests.test_hal import MockHALManager, MockRealHALDevice
 from landscape.tests.helpers import LandscapeTest, mock_counter, MonitorHelper
 from landscape.tests.mocker import ANY
 
@@ -21,6 +22,8 @@
         self.log_helper.ignore_errors("Typelib file for namespace")
 
     def get_mount_info(self, *args, **kwargs):
+        hal_devices = kwargs.pop("hal_devices", [])
+        kwargs["hal_manager"] = MockHALManager(hal_devices)
         if "statvfs" not in kwargs:
             kwargs["statvfs"] = lambda path: (0,) * 10
         return MountInfo(*args, **kwargs)
@@ -320,8 +323,51 @@
         message = plugin.create_mount_info_message()
         self.assertEqual(message, None)
 
+    def test_ignore_removable_partitions(self):
+        """
+        Partitions on removable devices don't directly report
+        storage.removable : True, but they do point to their parent and the
+        parent will be marked removable if appropriate.
+        """
+        devices = [MockRealHALDevice({"info.udi": "wubble",
+                                      "block.device": "/dev/scd",
+                                      "storage.removable": True}),
+                   MockRealHALDevice({"info.udi": "wubble0",
+                                      "block.device": "/dev/scd0",
+                                      "info.parent": "wubble"})]
+
+        filename = self.makeFile("""\
+/dev/scd0 /media/Xerox_M750 iso9660 ro,nosuid,nodev,uid=1000,utf8 0 0
+""")
+        plugin = self.get_mount_info(mounts_file=filename, hal_devices=devices,
+                                     mtab_file=filename)
+        self.monitor.add(plugin)
+        plugin.run()
+
+        message = plugin.create_mount_info_message()
+        self.assertEqual(message, None)
+
     def test_ignore_removable_devices(self):
         """
+        The mount info plugin should only report data about
+        non-removable devices.
+        """
+        devices = [MockRealHALDevice({"info.udi": "wubble",
+                                      "block.device": "/dev/scd0",
+                                      "storage.removable": True})]
+        filename = self.makeFile("""\
+/dev/scd0 /media/Xerox_M750 iso9660 ro,nosuid,nodev,uid=1000,utf8 0 0
+""")
+        plugin = self.get_mount_info(mounts_file=filename, hal_devices=devices,
+                                     mtab_file=filename)
+        self.monitor.add(plugin)
+        plugin.run()
+
+        message = plugin.create_mount_info_message()
+        self.assertEqual(message, None)
+
+    def test_ignore_removable_devices_gudev(self):
+        """
         The mount info plugin uses gudev to retrieve removable information
         about devices.
         """
@@ -330,6 +376,7 @@
 """)
         plugin = self.get_mount_info(mounts_file=filename,
                                      mtab_file=filename)
+        plugin._hal_manager = None
 
         class MockDevice(object):
             def get_sysfs_attr_as_boolean(self, attr):
@@ -348,6 +395,35 @@
         message = plugin.create_mount_info_message()
         self.assertEqual(message, None)
 
+    def test_ignore_multiparented_removable_devices(self):
+        """
+        Some removable devices might be the grand-children of a device that is
+        marked as "storage.removable".
+        """
+        devices = [MockRealHALDevice({"info.udi": "wubble",
+                                      "block.device": "/dev/scd",
+                                      "storage.removable": True}),
+                   MockRealHALDevice({"info.udi": "wubble0",
+                                      "block.device": "/dev/scd0",
+                                      "info.parent": "wubble"}),
+                   MockRealHALDevice({"info.udi": "wubble0a",
+                                      "block.device": "/dev/scd0a",
+                                      "info.parent": "wubble0"}),
+                   MockRealHALDevice({"info.udi": "wubble0b",
+                                      "block.device": "/dev/scd0b",
+                                      "info.parent": "wubble0"})]
+
+        filename = self.makeFile("""\
+/dev/scd0a /media/Xerox_M750 iso9660 ro,nosuid,nodev,uid=1000,utf8 0 0
+""")
+        plugin = self.get_mount_info(mounts_file=filename, hal_devices=devices,
+                                     mtab_file=filename)
+        self.monitor.add(plugin)
+        plugin.run()
+
+        message = plugin.create_mount_info_message()
+        self.assertEqual(message, None)
+
     def test_sample_free_space(self):
         """Test collecting information about free space."""
         def statvfs(path, multiplier=mock_counter(1).next):

=== modified file 'landscape/monitor/tests/test_service.py'
--- landscape/monitor/tests/test_service.py	2011-12-02 08:35:25 +0000
+++ landscape/monitor/tests/test_service.py	2012-03-06 09:20:24 +0000
@@ -1,3 +1,4 @@
+from landscape.tests.mocker import ANY
 from landscape.tests.helpers import LandscapeTest, FakeBrokerServiceHelper
 from landscape.reactor import FakeReactor
 from landscape.monitor.config import MonitorConfiguration, ALL_PLUGINS
@@ -45,10 +46,15 @@
         starts the plugins and register the monitor as broker client.  It also
         start listening on its own socket for incoming connections.
         """
+        # FIXME: don't actually run the real register method, because at the
+        # moment the UserMonitor plugin still depends on DBus. We can probably
+        # drop this mocking once the AMP migration is completed.
+        for plugin in self.service.plugins:
+            plugin.register = self.mocker.mock()
+            plugin.register(ANY)
+        self.mocker.replay()
+
         def stop_service(ignored):
-            for plugin in self.service.plugins:
-                if getattr(plugin, "stop", None) is not None:
-                    plugin.stop()
             [connector] = self.broker_service.broker.get_connectors()
             connector.disconnect()
             self.service.stopService()

=== modified file 'landscape/package/releaseupgrader.py'
--- landscape/package/releaseupgrader.py	2011-12-01 14:01:29 +0000
+++ landscape/package/releaseupgrader.py	2012-03-06 09:20:24 +0000
@@ -188,11 +188,32 @@
                 config.add_section("NonInteractive")
                 config.set("NonInteractive", "ForceOverwrite", "no")
 
+            # Workaround for Bug #174148, which prevents dbus from restarting
+            # after a dapper->hardy upgrade
+            if not config.has_section("Distro"):
+                config.add_section("Distro")
+            if not config.has_option("Distro", "PostInstallScripts"):
+                config.set("Distro", "PostInstallScripts", "./dbus.sh")
+            else:
+                scripts = config.get("Distro", "PostInstallScripts")
+                scripts += ", ./dbus.sh"
+                config.set("Distro", "PostInstallScripts", scripts)
+
             # Write config changes to disk
             fd = open(config_filename, "w")
             config.write(fd)
             fd.close()
 
+            # Generate the post-install script that starts DBus
+            dbus_sh_filename = os.path.join(upgrade_tool_directory,
+                                            "dbus.sh")
+            fd = open(dbus_sh_filename, "w")
+            fd.write("#!/bin/sh\n"
+                     "/etc/init.d/dbus start\n"
+                     "sleep 10\n")
+            fd.close()
+            os.chmod(dbus_sh_filename, 0755)
+
         # On some releases the upgrade-tool doesn't support the allow third
         # party environment variable, so this trick is needed to make it
         # possible to upgrade against testing client packages from the

=== modified file 'landscape/package/tests/test_releaseupgrader.py'
--- landscape/package/tests/test_releaseupgrader.py	2011-12-01 14:01:29 +0000
+++ landscape/package/tests/test_releaseupgrader.py	2012-03-06 09:20:24 +0000
@@ -245,6 +245,60 @@
         result.addCallback(check_result)
         return result
 
+    def test_tweak_sets_dbus_start_script(self):
+        """
+        The L{ReleaseUpgrader.tweak} method adds to the upgrade-tool
+        configuration a little script that starts dbus after the upgrade.
+        """
+        config_filename = os.path.join(self.config.upgrade_tool_directory,
+                                       "DistUpgrade.cfg.dapper")
+        self.makeFile(path=config_filename,
+                      content="[Distro]\n"
+                              "PostInstallScripts=/foo.sh\n")
+
+        def check_result(ignored):
+            config = ConfigParser.ConfigParser()
+            config.read(config_filename)
+            self.assertEqual(config.get("Distro", "PostInstallScripts"),
+                             "/foo.sh, ./dbus.sh")
+            dbus_sh = os.path.join(self.config.upgrade_tool_directory,
+                                   "dbus.sh")
+            self.assertFileContent(dbus_sh,
+                                   "#!/bin/sh\n"
+                                   "/etc/init.d/dbus start\n"
+                                   "sleep 10\n")
+
+        result = self.upgrader.tweak("dapper")
+        result.addCallback(check_result)
+        return result
+
+    def test_tweak_sets_dbus_start_script_with_no_post_install_scripts(self):
+        """
+        The L{ReleaseUpgrader.tweak} method adds to the upgrade-tool
+        configuration a little script that starts dbus after the upgrade. This
+        works even when the config file doesn't have a PostInstallScripts entry
+        yet.
+        """
+        config_filename = os.path.join(self.config.upgrade_tool_directory,
+                                       "DistUpgrade.cfg.dapper")
+        self.makeFile(path=config_filename, content="")
+
+        def check_result(ignored):
+            config = ConfigParser.ConfigParser()
+            config.read(config_filename)
+            self.assertEqual(config.get("Distro", "PostInstallScripts"),
+                             "./dbus.sh")
+            dbus_sh = os.path.join(self.config.upgrade_tool_directory,
+                                   "dbus.sh")
+            self.assertFileContent(dbus_sh,
+                                   "#!/bin/sh\n"
+                                   "/etc/init.d/dbus start\n"
+                                   "sleep 10\n")
+
+        result = self.upgrader.tweak("dapper")
+        result.addCallback(check_result)
+        return result
+
     def test_default_logs_directory(self):
         """
         The default directory for the upgrade-tool logs is the system one.

=== modified file 'landscape/reactor.py'
--- landscape/reactor.py	2012-02-03 18:10:57 +0000
+++ landscape/reactor.py	2012-03-06 09:20:24 +0000
@@ -16,6 +16,10 @@
     """Raised when an invalid ID is used with reactor.cancel_call()."""
 
 
+class CallHookError(Exception):
+    """Raised when hooking on a reactor incorrectly."""
+
+
 class EventID(object):
     """Unique identifier for an event handler.
 
@@ -155,6 +159,13 @@
             except Exception, e:
                 logging.exception(e)
 
+    def _hook_threaded_callbacks(self):
+        id = self.call_every(0.5, self._run_threaded_callbacks)
+        self._run_threaded_callbacks_id = id
+
+    def _unhook_threaded_callbacks(self):
+        self.cancel_call(self._run_threaded_callbacks_id)
+
 
 class UnixReactorMixin(object):
 

=== modified file 'landscape/service.py'
--- landscape/service.py	2012-02-03 10:06:28 +0000
+++ landscape/service.py	2012-03-06 09:20:24 +0000
@@ -29,6 +29,12 @@
 
     def __init__(self, config):
         self.config = config
+        try:
+            from landscape.lib import bpickle_dbus
+        except ImportError:
+            pass
+        else:
+            bpickle_dbus.install()
         self.reactor = self.reactor_factory()
         if self.persist_filename:
             self.persist = get_versioned_persist(self)

=== modified file 'landscape/tests/test_configuration.py'
--- landscape/tests/test_configuration.py	2012-02-29 22:13:01 +0000
+++ landscape/tests/test_configuration.py	2012-03-06 09:20:24 +0000
@@ -1883,7 +1883,7 @@
 
     def test_register_bus_connection_failure_ok_no_register(self):
         """
-        Exit code 0 will be returned if we can't contact Landscape and
+        Exit code 0 will be returned if we can't contact Landscape via DBus and
         --ok-no-register was passed.
         """
         print_text_mock = self.mocker.replace(print_text)

=== added file 'landscape/tests/test_hal.py'
--- landscape/tests/test_hal.py	1970-01-01 00:00:00 +0000
+++ landscape/tests/test_hal.py	2012-03-06 09:20:24 +0000
@@ -0,0 +1,87 @@
+from dbus import SystemBus, Interface
+from dbus.exceptions import DBusException
+
+from landscape.hal import HALDevice, HALManager
+from landscape.tests.helpers import LandscapeTest
+
+
+class HALManagerTest(LandscapeTest):
+
+    def setUp(self):
+        super(HALManagerTest, self).setUp()
+        self.bus = SystemBus()
+
+    def test_get_devices(self):
+        """
+        A HALManager can return a flat list of devices.  All available
+        devices should be included in the returned list.
+        """
+        devices = HALManager().get_devices()
+        manager = self.bus.get_object("org.freedesktop.Hal",
+                                      "/org/freedesktop/Hal/Manager")
+        manager = Interface(manager, "org.freedesktop.Hal.Manager")
+        expected_devices = manager.GetAllDevices()
+        actual_devices = [device.udi for device in devices]
+        self.assertEqual(set(expected_devices), set(actual_devices))
+
+    def test_get_devices_with_dbus_error(self):
+        """
+        If the L{HALManager} fails connecting to HAL over D-Bus, then the
+        L{HALManager.get_devices} method returns an empty list.
+        """
+        self.log_helper.ignore_errors("Couldn't connect to Hal via DBus")
+        bus = self.mocker.mock()
+        bus.get_object("org.freedesktop.Hal", "/org/freedesktop/Hal/Manager")
+        self.mocker.throw(DBusException())
+        self.mocker.replay()
+        devices = HALManager(bus=bus).get_devices()
+        self.assertEqual(devices, [])
+
+    def test_get_devices_with_no_server(self):
+        """
+        If the L{HALManager} fails connecting to HAL over D-Bus, for example
+        because the DBus server is not running at all, then the
+        L{HALManager.get_devices} method returns an empty list.
+        """
+        self.log_helper.ignore_errors("Couldn't connect to Hal via DBus")
+        bus_mock = self.mocker.replace("dbus.SystemBus")
+        bus_mock()
+        self.mocker.throw(DBusException())
+        self.mocker.replay()
+        devices = HALManager().get_devices()
+        self.assertEqual(devices, [])
+
+
+class MockHALManager(object):
+
+    def __init__(self, devices):
+        self.devices = devices
+
+    def get_devices(self):
+        return [HALDevice(device) for device in self.devices]
+
+
+class MockRealHALDevice(object):
+
+    def __init__(self, properties):
+        self._properties = properties
+        self.udi = properties.get("info.udi", "fake_udi")
+
+    def GetAllProperties(self):
+        return self._properties
+
+
+class HALDeviceTest(LandscapeTest):
+
+    def test_init(self):
+        device = HALDevice(MockRealHALDevice({"info.udi": "wubble"}))
+        self.assertEqual(device.properties, {"info.udi": "wubble"})
+        self.assertEqual(device.udi, "wubble")
+        self.assertEqual(device.parent, None)
+
+    def test_add_child(self):
+        parent = HALDevice(MockRealHALDevice({"info.udi": "wubble"}))
+        child = HALDevice(MockRealHALDevice({"info.udi": "ooga"}))
+        parent.add_child(child)
+        self.assertEqual(parent.get_children(), [child])
+        self.assertEqual(child.parent, parent)

=== modified file 'landscape/tests/test_service.py'
--- landscape/tests/test_service.py	2011-12-01 13:38:58 +0000
+++ landscape/tests/test_service.py	2012-03-06 09:20:24 +0000
@@ -56,6 +56,15 @@
         service = TestService(self.config)
         self.assertFalse(hasattr(service, "persist"))
 
+    def test_install_bpickle_dbus(self):
+        """
+        A L{LandscapeService} installs the DBus extensions of bpickle.
+        """
+        dbus_mock = self.mocker.replace("landscape.lib.bpickle_dbus.install")
+        dbus_mock()
+        self.mocker.replay()
+        TestService(self.config)
+
     def test_usr1_rotates_logs(self):
         """
         SIGUSR1 should cause logs to be reopened.

=== modified file 'landscape/tests/test_textmessage.py'
--- landscape/tests/test_textmessage.py	2011-12-01 14:01:29 +0000
+++ landscape/tests/test_textmessage.py	2012-03-06 09:20:24 +0000
@@ -13,8 +13,8 @@
 
     def test_send_message(self):
         """
-        L{send_message} should send a message of type C{text-message} to the
-        landscape messaging service.
+        L{send_message} should send a message of type
+        C{text-message} to the landscape dbus messaging service.
         """
         service = self.broker_service
         service.message_store.set_accepted_types(["text-message"])

=== modified file 'landscape/textmessage.py'
--- landscape/textmessage.py	2011-12-01 14:01:29 +0000
+++ landscape/textmessage.py	2012-03-06 09:20:24 +0000
@@ -1,6 +1,7 @@
 """
 Support code for the C{landscape-message} utility, which sends a text
-message to the Landscape web UI via the landscape-client's messaging service.
+message to the Landscape web UI via the landscape-client's dbus
+messaging service (see L{landscape.plugins.dbus_message}).
 """
 
 import sys

=== modified file 'landscape/watchdog.py'
--- landscape/watchdog.py	2012-02-27 20:49:50 +0000
+++ landscape/watchdog.py	2012-03-06 09:20:24 +0000
@@ -62,6 +62,8 @@
     @cvar program: The name of the executable program that will start this
         daemon.
     @cvar username: The name of the user to switch to, by default.
+    @cvar service: The DBus service name that the program will be expected to
+        listen on.
     @cvar max_retries: The maximum number of retries before giving up when
         trying to connect to the watched daemon.
     @cvar factor: The factor by which the delay between subsequent connection
@@ -176,7 +178,8 @@
 
     def is_running(self):
         # FIXME Error cases may not be handled in the best possible way
-        # here. We're basically return False if any error happens.
+        # here. We're basically return False if any error happens from the
+        # dbus ping.
         return self._connect_and_call("ping")
 
     def wait(self):
@@ -364,7 +367,7 @@
     def start(self):
         """
         Start all daemons. The broker will be started first, and no other
-        daemons will be started before it is running and responding to
+        daemons will be started before it is running and responding to DBUS
         messages.
 
         @return: A deferred which fires when all services have successfully

=== modified file 'man/landscape-client.1'
--- man/landscape-client.1	2011-12-02 09:52:48 +0000
+++ man/landscape-client.1	2012-03-06 09:20:24 +0000
@@ -1,5 +1,5 @@
 .\"Text automatically generated by txt2man
-.TH landscape-client 1 "02 December 2011" "" ""
+.TH landscape-client  "18 January 2010" "" ""
 .SH NAME
 \fBlandscape-client \fP- Landscape system client
 \fB
@@ -35,6 +35,11 @@
 \fIoptions\fP override settings from the file).
 .TP
 .B
+\fB--bus\fP=BUS
+Which DBUS bus to use. One of 'session' or 
+'system'.
+.TP
+.B
 \fB-d\fP PATH, \fB--data-path\fP=PATH
 The directory to store data files in.
 .TP

=== modified file 'man/landscape-client.txt'
--- man/landscape-client.txt	2011-12-01 14:01:29 +0000
+++ man/landscape-client.txt	2012-03-06 09:20:24 +0000
@@ -17,6 +17,8 @@
   -h, --help                 Show this help message and exit.
   -c FILE, --config=FILE     Use config from this file (any command line 
                              options override settings from the file).
+  --bus=BUS                  Which DBUS bus to use. One of 'session' or 
+                             'system'.
   -d PATH, --data-path=PATH  The directory to store data files in.
   -q, --quiet                Do not log to the standard output.
   -l FILE, --log-dir=FILE    The directory to write log files to.

=== modified file 'man/landscape-config.1'
--- man/landscape-config.1	2011-12-02 09:52:48 +0000
+++ man/landscape-config.1	2012-03-06 09:20:24 +0000
@@ -1,5 +1,5 @@
 .\"Text automatically generated by txt2man
-.TH landscape-config 1 "02 December 2011" "" ""
+.TH landscape-config  "18 January 2010" "" ""
 .SH NAME
 \fBlandscape-config \fP- configure the Landscape management client
 \fB
@@ -46,6 +46,11 @@
 '/etc/landscape/client.conf').
 .TP
 .B
+\fB--bus\fP=BUS
+Which DBUS bus to use. One of 'session' or 'system'
+(default: 'system').
+.TP
+.B
 \fB-d\fP PATH, \fB--data-path\fP=PATH
 The directory to store data files in (default:
 '/var/lib/landscape/client').

=== modified file 'man/landscape-config.txt'
--- man/landscape-config.txt	2011-12-01 14:01:29 +0000
+++ man/landscape-config.txt	2012-03-06 09:20:24 +0000
@@ -28,6 +28,8 @@
   -c FILE, --config=FILE   Use config from this file (any command line options
                            override settings from the file) (default:
                            '/etc/landscape/client.conf').
+  --bus=BUS                Which DBUS bus to use. One of 'session' or 'system'
+                           (default: 'system').
   -d PATH, --data-path=PATH   The directory to store data files in (default:
                            '/var/lib/landscape/client').
   -q, --quiet              Do not log to the standard output.

=== modified file 'man/landscape-message.1'
--- man/landscape-message.1	2011-12-02 09:52:48 +0000
+++ man/landscape-message.1	2012-03-06 09:20:24 +0000
@@ -1,5 +1,5 @@
 .\"Text automatically generated by txt2man
-.TH landscape-message 1 "02 December 2011" "" ""
+.TH landscape-message  "18 January 2010" "" ""
 .SH NAME
 \fBlandscape-message \fP- Send a message to the landscape web interface
 \fB
@@ -31,6 +31,10 @@
 .B
 \fB-h\fP, \fB--help\fP
 Show this help message and exit.
+.TP
+.B
+\fB-b\fP BUS, \fB--bus\fP=BUS
+The DBUS bus to use to send the message.
 .SH EXAMPLES
 
 \fBlandscape-message\fP Hello administrator

=== modified file 'man/landscape-message.txt'
--- man/landscape-message.txt	2011-12-01 14:01:29 +0000
+++ man/landscape-message.txt	2012-03-06 09:20:24 +0000
@@ -16,6 +16,7 @@
 OPTIONS
   --version           Show program's version number and exit.
   -h, --help          Show this help message and exit.
+  -b BUS, --bus=BUS   The DBUS bus to use to send the message.
 
 EXAMPLES
 

=== added file 'scripts/landscape-dbus-proxy'
--- scripts/landscape-dbus-proxy	1970-01-01 00:00:00 +0000
+++ scripts/landscape-dbus-proxy	2012-03-06 09:20:24 +0000
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+import os
+import dbus
+import dbus.service
+import dbus.glib # This as side effects, don't remove it!
+
+from dbus.service import Object, BusName, method
+
+from twisted.internet import glib2reactor
+glib2reactor.install()
+from twisted.internet import reactor
+
+from landscape.lib.bpickle import loads
+from landscape.lib.lock import lock_path, LockError
+from landscape.reactor import TwistedReactor
+from landscape.deployment import Configuration
+from landscape.broker.amp import RemoteBrokerConnector
+
+
+BUS_NAME = "com.canonical.landscape.Broker"
+OBJECT_PATH = "/com/canonical/landscape/Broker"
+
+
+def array_to_string(array):
+    """Convert an L{Array} of L{Byte}s (or integers) to a Python str."""
+    result = []
+    for item in array:
+        if item < 0:
+            item = item + 256
+        result.append(chr(item))
+    return "".join(result)
+
+
+class BrokerDBusObject(Object):
+    """A DBus-published object proxying L{RemoteBroker.send_message}.
+
+    It is used when upgrading from a DBus-based version of the Landscape client
+    to the newer AMP-based one, for letting the old package-changer process
+    performing the upgrade communicate with the new version of the client.
+    """
+
+    bus_name = BUS_NAME
+    object_path = OBJECT_PATH
+
+    def __init__(self, config):
+        super(BrokerDBusObject, self).__init__(BusName(
+            self.bus_name, dbus.SystemBus()), object_path=self.object_path)
+        self.config = config
+
+    @method(BUS_NAME)
+    def send_message(self, message, urgent=True):
+        """Queue the given message in the message exchange."""
+        message = loads(array_to_string(message))
+
+        def cb_connected(broker):
+            result = broker.send_message(message, urgent=True)
+            return result.addCallback(cb_done)
+
+        def cb_done(ignored):
+            return reactor.stop()
+
+        twisted_reactor = TwistedReactor()
+        connector = RemoteBrokerConnector(twisted_reactor, self.config)
+        connected = connector.connect()
+        connected.addCallback(cb_connected)
+
+
+if __name__ == "__main__":
+    config = Configuration()
+    lock_dir = os.path.join(config.data_path, "package")
+    if os.path.isdir(lock_dir):
+        lock_filename = os.path.join(lock_dir, "changer.lock")
+        try:
+            lock_path(lock_filename)
+        except LockError:
+            # The package-changer is running, this means that we're upgrading from
+            # a non-AMP version and that the upgrade is Landscape driven, so let's
+            # expose the DBus broker proxy to give a chance to the package-changer
+            # to send its result message.
+            remote = BrokerDBusObject(config)
+            reactor.run()

=== modified file 'setup.py'
--- setup.py	2012-03-05 15:22:36 +0000
+++ setup.py	2012-03-06 09:20:24 +0000
@@ -30,7 +30,8 @@
                "scripts/landscape-package-reporter",
                "scripts/landscape-release-upgrader",
                "scripts/landscape-sysinfo",
-               "scripts/landscape-is-cloud-managed"],
+               "scripts/landscape-is-cloud-managed",
+               "scripts/landscape-dbus-proxy"],
       ext_modules=[Extension("landscape.lib.initgroups",
                              ["landscape/lib/initgroups.c"])]
           )