Merge lp:~roadmr/ubuntu/quantal/checkbox/0.14.9 into lp:ubuntu/quantal/checkbox

[Daniel Manrique]

This adds udisks2 support to removable storage tests in checkbox. This encompasses media cards (all variants), USB storage devices, ESATA and FireWire.

The code required to implement this is somewhat extensive, but is necessary because udisks1 is not shipping in Quantal and without this, none of the checkbox removable storage tests will work.

I was told we shouldn't need to request an explicit FFe for this as it needs release team review anyway, but the spirit of this is a "new feature", please take this into account when reviewing it.

I'll add the required build and install logs to the linked bug anyway, in case they're needed for the review.

Thanks and apologies for the late-landing request.

[Mathieu Trudel-Lapierre (cyphermox)]

Seems fine to me, I'll merge once the bug https://bugs.launchpad.net/checkbox/+bug/1016035 gets approved by the release team.

review: Approve

[Ara Pulido (ara)]

The release team is asking to upload this, so they can review it in the queue

=== added directory 'checkbox/dbus'
=== added file 'checkbox/dbus/__init__.py'
--- checkbox/dbus/__init__.py	1970-01-01 00:00:00 +0000
+++ checkbox/dbus/__init__.py	2012-10-09 17:53:24 +0000
@@ -0,0 +1,89 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox 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.
+#
+# Checkbox 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 Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+checkbox.dbus
+=============
+
+Utility modules for working with various things accessible over dbus
+"""
+
+import logging
+
+from dbus import SystemBus
+from dbus.mainloop.glib import DBusGMainLoop
+from dbus import (Array, Boolean, Byte, Dictionary, Double, Int16, Int32,
+                  Int64, ObjectPath, String, Struct, UInt16, UInt32, UInt64)
+from gi.repository import GObject
+
+
+def connect_to_system_bus():
+    """
+    Connect to the system bus properly.
+
+    Returns a tuple (system_bus, loop) where loop is a GObject.MainLoop
+    instance. The loop is there so that you can listen to signals.
+    """
+    # We'll need an event loop to observe signals. We will need the instance
+    # later below so let's keep it. Note that we're not passing it directly
+    # below as DBus needs specific API. The DBusGMainLoop class that we
+    # instantiate and pass is going to work with this instance transparently.
+    #
+    # NOTE: DBus tutorial suggests that we should create the loop _before_
+    # connecting to the bus.
+    logging.debug("Setting up glib-based event loop")
+    loop = GObject.MainLoop()
+    # Let's get the system bus object. We need that to access UDisks2 object
+    logging.debug("Connecting to DBus system bus")
+    system_bus = SystemBus(mainloop=DBusGMainLoop())
+    return system_bus, loop
+
+
+def drop_dbus_type(value):
+    """
+    Convert types from the DBus bindings to their python counterparts.
+
+    This function is mostly lossless, except for arrays of bytes (DBus
+    signature "y") that are transparently converted to strings, assuming
+    an UTF-8 encoded string.
+
+    The point of this function is to simplify printing of nested DBus data that
+    gets displayed in a rather illegible way.
+    """
+    if isinstance(value, Array) and value.signature == "y":
+        # Some other things are reported as array of bytes that are just
+        # strings but due to Unix heritage the encoding is not known.
+        # In practice it is better to treat them as UTF-8 strings
+        return bytes(value).decode("UTF-8", "replace").strip("\0")
+    elif isinstance(value, (Struct, Array)):
+        return [drop_dbus_type(item) for item in value]
+    elif isinstance(value, (Dictionary)):
+        return {drop_dbus_type(dict_key): drop_dbus_type(dict_value)
+                for dict_key, dict_value in value.items()}
+    elif isinstance(value, (String, ObjectPath)):
+        return str(value)
+    elif isinstance(value, (Byte, UInt16, UInt32, UInt64,
+                            Int16, Int32, Int64)):
+        return int(value)
+    elif isinstance(value, Boolean):
+        return bool(value)
+    elif isinstance(value, Double):
+        return float(value)
+    else:
+        return value

=== added file 'checkbox/dbus/udisks2.py'
--- checkbox/dbus/udisks2.py	1970-01-01 00:00:00 +0000
+++ checkbox/dbus/udisks2.py	2012-10-09 17:53:24 +0000
@@ -0,0 +1,479 @@
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# 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/>.
+
+"""
+checkbox.dbus.udisks2
+=====================
+
+Module for working with UDisks2 from python.
+
+There are two main classes that are interesting here.
+
+The first class is UDisksObserver, which is easy to setup and has pythonic API
+to all of the stuff that happens in UDisks2. It offers simple signal handlers
+for any changes that occur in UDisks2 that were advertised by DBus.
+
+The second class is UDisksModel, that builds on the observer class to offer
+persistent collection of objects managed by UDisks2.
+
+To work with this model you will likely want to look at:
+    http://udisks.freedesktop.org/docs/latest/ref-dbus.html
+"""
+
+import logging
+
+from dbus import Interface, PROPERTIES_IFACE
+from dbus.exceptions import DBusException
+
+from checkbox.dbus import drop_dbus_type
+
+__all__ = ['UDisks2Observer', 'UDisks2Model', 'Signal', 'is_udisks2_supported',
+           'lookup_udev_device']
+
+
+def is_udisks2_supported(system_bus):
+    """
+    Check if udisks2 is available on the system bus.
+
+    ..note::
+        Calling this _may_ trigger activation of the UDisks2 daemon but it
+        should only happen on systems where it is already expected to run all
+        the time.
+    """
+    observer = UDisks2Observer()
+    try:
+        logging.debug("Trying to connect to UDisks2...")
+        observer.connect_to_bus(system_bus)
+    except DBusException as exc:
+        if exc.get_dbus_name() == "org.freedesktop.DBus.Error.ServiceUnknown":
+            logging.debug("No UDisks2 on the system bus")
+            return False
+        else:
+            raise
+    else:
+        logging.debug("Got UDisks2 connection")
+        return True
+
+
+def map_udisks1_connection_bus(udisks1_connection_bus):
+    """
+    Map the value of udisks1 ConnectionBus property to the corresponding values
+    in udisks2. This a lossy function as some values are no longer supported.
+
+    Incorrect values raise LookupError
+    """
+    return {
+        'ata_serial_esata': '',  # gone from udisks2
+        'firewire': 'ieee1934',  # renamed
+        'scsi': '',              # gone from udisks2
+        'sdio': 'sdio',          # as-is
+        'usb': 'usb',            # as-is
+    }[udisks1_connection_bus]
+
+
+def lookup_udev_device(udisks2_object, udev_devices):
+    """
+    Find the udev_device that corresponds to the udisks2 object
+
+    Devices are matched by unix filesystem path of the special file (device).
+    The udisks2_object must implement the block device interface (so that the
+    block device path can be determined) or a ValueError is raised.
+
+    The udisks2_object must be the dictionary that maps from interface names to
+    dictionaries of properties. For compatible data see
+    UDisks2Model.managed_objects The udev_devices must be a list of udev
+    device, as returned from GUdev.
+
+    If there is no match, LookupError is raised with the unix block device
+    path.
+    """
+    try:
+        block_props = udisks2_object[UDISKS2_BLOCK_INTERFACE]
+    except KeyError:
+        raise ValueError("udisks2_object must be a block device")
+    else:
+        block_dev = block_props['Device']
+    for udev_device in udev_devices:
+        if udev_device.get_device_file() == block_dev:
+            return udev_device
+    raise LookupError(block_dev)
+
+
+# The well-known name for the ObjectManager interface, sadly it is not a part
+# of the python binding along with the rest of well-known names.
+OBJECT_MANAGER_INTERFACE = "org.freedesktop.DBus.ObjectManager"
+
+# The well-known name of the filesystem interface implemented by certain
+# objects exposed by UDisks2
+UDISKS2_FILESYSTEM_INTERFACE = "org.freedesktop.UDisks2.Filesystem"
+
+# The well-known name of the block (device) interface implemented by certain
+# objects exposed by UDisks2
+UDISKS2_BLOCK_INTERFACE = "org.freedesktop.UDisks2.Block"
+
+# The well-known name of the drive interface implemented by certain objects
+# exposed by UDisks2
+UDISKS2_DRIVE_INTERFACE = "org.freedesktop.UDisks2.Drive"
+
+
+class Signal:
+    """
+    Basic signal that supports arbitrary listeners.
+
+    While this class can be used directly it is best used with the helper
+    decorator Signal.define on a member function. The function body is ignored,
+    apart from the documentation.
+
+    The function name then becomes a unique (per encapsulating class instance)
+    object (an instance of this Signal class) that is created on demand.
+
+    In practice you just have a documentation and use
+    object.signal_name.connect() and object.signal_name(*args, **kwargs) to
+    fire it.
+    """
+
+    def __init__(self, signal_name):
+        """
+        Construct a signal with the given name
+        """
+        self._listeners = []
+        self._signal_name = signal_name
+
+    def connect(self, listener):
+        """
+        Connect a new listener to this signal
+
+        That listener will be called whenever fire() is invoked on the signal
+        """
+        self._listeners.append(listener)
+
+    def disconnect(self, listener):
+        """
+        Disconnect an existing listener from this signal
+        """
+        self._listeners.remove(listener)
+
+    def fire(self, args, kwargs):
+        """
+        Fire this signal with the specified arguments and keyword arguments.
+
+        Typically this is used by using __call__() on this object which is more
+        natural as it does all the argument packing/unpacking transparently.
+        """
+        for listener in self._listeners:
+            listener(*args, **kwargs)
+
+    def __call__(self, *args, **kwargs):
+        """
+        Call fire() with all arguments forwarded transparently
+        """
+        self.fire(args, kwargs)
+
+    @classmethod
+    def define(cls, dummy_func):
+        """
+        Helper decorator to define a signal descriptor in a class
+
+        The decorated function is never called but is used to get
+        documentation.
+        """
+        return _SignalDescriptor(dummy_func)
+
+
+class _SignalDescriptor:
+    """
+    Descriptor for convenient signal access.
+
+    Typically this class is used indirectly, when accessed from Signal.define
+    method decorator. It is used to do all the magic required when accessing
+    signal name on a class or instance.
+    """
+
+    def __init__(self, dummy_func):
+        self.signal_name = dummy_func.__name__
+        self.__doc__ = dummy_func.__doc__
+
+    def __repr__(self):
+        return "<SignalDecorator for signal: %r>" % self.signal_name
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+        # Ensure that the instance has __signals__ property
+        if not hasattr(instance, "__signals__"):
+            instance.__signals__ = {}
+        if self.signal_name not in instance.__signals__:
+            instance.__signals__[self.signal_name] = Signal(self.signal_name)
+        return instance.__signals__[self.signal_name]
+
+    def __set__(self, instance, value):
+        raise AttributeError("You cannot overwrite signals")
+
+    def __delete__(self, instance):
+        raise AttributeError("You cannot delete signals")
+
+
+class UDisks2Observer:
+    """
+    Class for observing ongoing changes in UDisks2
+    """
+
+    def __init__(self):
+        """
+        Create a UDisks2 model.
+
+        The model must be connected to a bus before it is first used, see
+        connect()
+        """
+        # Proxy to the UDisks2 object
+        self._udisks2_obj = None
+        # Proxy to the ObjectManager interface exposed by UDisks2 object
+        self._udisks2_obj_manager = None
+
+    @Signal.define
+    def on_initial_objects(self, managed_objects):
+        """
+        Signal fired when the initial list of objects becomes available
+        """
+
+    @Signal.define
+    def on_interfaces_added(self, object_path, interfaces_and_properties):
+        """
+        Signal fired when one or more interfaces gets added to a specific
+        object.
+        """
+
+    @Signal.define
+    def on_interfaces_removed(self, object_path, interfaces):
+        """
+        Signal fired when one or more interface gets removed from a specific
+        object
+        """
+
+    @Signal.define
+    def on_properties_changed(self, interface_name, changed_properties,
+                              invalidated_properties, sender=None):
+        """
+        Signal fired when one or more property changes value or becomes
+        invalidated.
+        """
+
+    def connect_to_bus(self, bus):
+        """
+        Establish initial connection to UDisks2 on the specified DBus bus.
+
+        This will also load the initial set of objects from UDisks2 and thus
+        fire the on_initial_objects() signal from the model. Please call this
+        method only after connecting that signal if you want to observe that
+        event.
+        """
+        # Once everything is ready connect to udisks2
+        self._connect_to_udisks2(bus)
+        # And read all the initial objects and setup
+        # change event handlers
+        self._get_initial_objects()
+
+    def _connect_to_udisks2(self, bus):
+        """
+        Setup the initial connection to UDisks2
+
+        This step can fail if UDisks2 is not available and cannot be
+        service-activated.
+        """
+        # Access the /org/freedesktop/UDisks2 object sitting on the
+        # org.freedesktop.UDisks2 bus name. This will trigger the necessary
+        # activation if udisksd is not running for any reason
+        logging.debug("Accessing main UDisks2 object")
+        self._udisks2_obj = bus.get_object(
+            "org.freedesktop.UDisks2", "/org/freedesktop/UDisks2")
+        # Now extract the standard ObjectManager interface so that we can
+        # observe and iterate the collection of objects that UDisks2 provides.
+        logging.debug("Accessing ObjectManager interface on UDisks2 object")
+        self._udisks2_obj_manager = Interface(
+            self._udisks2_obj, OBJECT_MANAGER_INTERFACE)
+        # Connect to the PropertiesChanged signal. Here unlike before we want
+        # to listen to all signals, regardless of who was sending them in the
+        # first place.
+        logging.debug("Setting up DBus signal handler for PropertiesChanged")
+        bus.add_signal_receiver(
+            self._on_properties_changed,
+            signal_name="PropertiesChanged",
+            dbus_interface=PROPERTIES_IFACE,
+            # Use the sender_keyword keyword argument to indicate that we wish
+            # to know the sender of each signal. For consistency with other
+            # signals we choose to use the 'object_path' keyword argument.
+            sender_keyword='sender')
+
+    def _get_initial_objects(self):
+        """
+        Get the initial collection of objects.
+
+        Needs to be called before the first signals from DBus are observed.
+        Requires a working connection to UDisks2.
+        """
+        # Having this interface we can now peek at the existing objects.
+        # We can use the standard method GetManagedObjects() to do that
+        logging.debug("Accessing GetManagedObjects() on UDisks2 object")
+        managed_objects = self._udisks2_obj_manager.GetManagedObjects()
+        managed_objects = drop_dbus_type(managed_objects)
+        # Fire the public signal for getting initial objects
+        self.on_initial_objects(managed_objects)
+        # Connect our internal handles to the DBus signal handlers
+        logging.debug("Setting up DBus signal handler for InterfacesAdded")
+        self._udisks2_obj_manager.connect_to_signal(
+            "InterfacesAdded", self._on_interfaces_added)
+        logging.debug("Setting up DBus signal handler for InterfacesRemoved")
+        self._udisks2_obj_manager.connect_to_signal(
+            "InterfacesRemoved", self._on_interfaces_removed)
+
+    def _on_interfaces_added(self, object_path, interfaces_and_properties):
+        """
+        Internal callback that is called by DBus
+
+        This function is responsible for firing the public signal
+        """
+        # Convert from dbus types
+        object_path = drop_dbus_type(object_path)
+        interfaces_and_properties = drop_dbus_type(interfaces_and_properties)
+        # Log what's going on
+        logging.debug("The object %r has gained the following interfaces and "
+                      "properties: %r", object_path, interfaces_and_properties)
+        # Call the signal handler
+        self.on_interfaces_added(object_path, interfaces_and_properties)
+
+    def _on_interfaces_removed(self, object_path, interfaces):
+        """
+        Internal callback that is called by DBus
+
+        This function is responsible for firing the public signal
+        """
+        # Convert from dbus types
+        object_path = drop_dbus_type(object_path)
+        interfaces = drop_dbus_type(interfaces)
+        # Log what's going on
+        logging.debug("The object %r has lost the following interfaces: %r",
+                      object_path, interfaces)
+        # Call the signal handler
+        self.on_interfaces_removed(object_path, interfaces)
+
+    def _on_properties_changed(self, interface_name, changed_properties,
+                               invalidated_properties, sender=None):
+        """
+        Internal callback that is called by DBus
+
+        This function is responsible for firing the public signal
+        """
+        # Convert from dbus types
+        interface_name = drop_dbus_type(interface_name)
+        changed_properties = drop_dbus_type(changed_properties)
+        invalidated_properties = drop_dbus_type(invalidated_properties)
+        sender = drop_dbus_type(sender)
+        # Log what's going on
+        logging.debug("Some object with the interface %r has changed "
+                      "properties: %r and invalidated properties %r "
+                      "(sender: %s)",
+                      interface_name, changed_properties,
+                      invalidated_properties, sender)
+        # Call the signal handler
+        self.on_properties_changed(interface_name, changed_properties,
+                                   invalidated_properties, sender)
+
+
+class UDisks2Model:
+    """
+    Model for working with UDisks2
+
+    This class maintains a persistent model of what UDisks2 knows about, based
+    on the UDisks2Observer class and the signals it offers.
+    """
+
+    def __init__(self, observer):
+        """
+        Create a UDisks2 model.
+
+        The model will track changes using the specified observer (which is
+        expected to be a UDisks2Observer instance)
+
+        You should only connect the observer to the bus after creating the
+        model otherwise the initial objects will not be detected.
+        """
+        # Local state, everything that UDisks2 tells us
+        self._managed_objects = {}
+        self._observer = observer
+        # Connect all the signals to the observer
+        self._observer.on_initial_objects.connect(self._on_initial_objects)
+        self._observer.on_interfaces_added.connect(self._on_interfaces_added)
+        self._observer.on_interfaces_removed.connect(
+            self._on_interfaces_removed)
+        self._observer.on_properties_changed.connect(
+            self._on_properties_changed)
+
+    @Signal.define
+    def on_change(self):
+        """
+        Signal sent whenever the collection of managed object changes
+
+        Note that this signal is fired _after_ the change has occurred
+        """
+
+    @property
+    def managed_objects(self):
+        """
+        A collection of objects that is managed by this model. All changes as
+        well as the initial state, are reflected here.
+        """
+        return self._managed_objects
+
+    def _on_initial_objects(self, managed_objects):
+        """
+        Internal callback called when we get the initial collection of objects
+        """
+        self._managed_objects = drop_dbus_type(managed_objects)
+
+    def _on_interfaces_added(self, object_path, interfaces_and_properties):
+        """
+        Internal callback called when an interface is added to certain object
+        """
+        # Update internal state
+        if object_path not in self._managed_objects:
+            self._managed_objects[object_path] = {}
+        obj = self._managed_objects[object_path]
+        obj.update(interfaces_and_properties)
+        # Fire the change signal
+        self.on_change()
+
+    def _on_interfaces_removed(self, object_path, interfaces):
+        """
+        Internal callback called when an interface is removed from a certain
+        object
+        """
+        # Update internal state
+        if object_path in self._managed_objects:
+            obj = self._managed_objects[object_path]
+            for interface in interfaces:
+                if interface in obj:
+                    del obj[interface]
+        # Fire the change signal
+        self.on_change()
+
+    def _on_properties_changed(self, interface_name, changed_properties,
+                               invalidated_properties, sender=None):
+        # XXX: This is a workaround the fact that we cannot
+        # properly track changes to all properties :-(
+        self._managed_objects = drop_dbus_type(
+            self._observer._udisks2_obj_manager.GetManagedObjects())
+        # Fire the change signal()
+        self.on_change()

=== added directory 'checkbox/heuristics'
=== added file 'checkbox/heuristics/__init__.py'
--- checkbox/heuristics/__init__.py	1970-01-01 00:00:00 +0000
+++ checkbox/heuristics/__init__.py	2012-10-09 17:53:24 +0000
@@ -0,0 +1,56 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox 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.
+#
+# Checkbox 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 Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+checkbox.heuristics
+===================
+
+This module contains implementations behind various heuristics used throughout
+the code. The intent of this module is twofold:
+
+    1) To encourage code reuse so that developers can use one implementation of
+       "guesswork" that is sometimes needed in our test. This reduces duplicate
+       bugs where many scripts do similar things in a different way.
+
+    2) To identify missing features in plumbing layer APIs such as
+       udev/udisks/dbus etc. Ideally no program should have to guess this, the
+       plumbing layer should be able to provide this meta data to allow
+       application developers deliver consistent behavior across userspace.
+
+Heuristics should be reusable from both python and shell. To make that possible
+each heuristics needs to be constrained to serializable input and output. This
+levels the playing field and allows both shell developers and python developers
+to reuse the same function.
+
+Additionally heuristics should try to avoid accessing thick APIs (such as
+objects returned by various libraries. This is meant to decrease the likelihood
+that updates to those libraries break this code. As an added side effect this
+also should make the implementation more explicit and easier to understand.
+
+In the long term each heuristic should be discussed with upstream developers of
+the particular problem area (udev, udisks, etc) to see if that subsystem can
+provide the required information directly, without us having to guess and fill
+the gaps.
+
+Things to consider when adding entries to this package:
+
+    1) File a bug on the upstream package about missing feature.
+
+    2) File a bug on checkbox to de-duplicate similar heuristics
+"""

=== added file 'checkbox/heuristics/udev.py'
--- checkbox/heuristics/udev.py	1970-01-01 00:00:00 +0000
+++ checkbox/heuristics/udev.py	2012-10-09 17:53:24 +0000
@@ -0,0 +1,44 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox 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.
+#
+# Checkbox 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 Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+checkbox.heuristics.dev
+=======================
+
+Heuristics for udev.
+
+    Documentation: http://udisks.freedesktop.org/docs/latest/
+    Source code: http://cgit.freedesktop.org/systemd/systemd/ (src/udev)
+    Bug tracker: http://bugs.freedesktop.org/ (using systemd product)
+"""
+
+
+def is_virtual_device(device_file):
+    """
+    Given a device name like /dev/ramX, /dev/sdX or /dev/loopX determine if
+    this is a virtual device. Virtual devices are typically uninteresting to
+    users. The only exception may be nonempty loopback device.
+
+    Possible prior art: gnome-disks, palimpset (precursor, suffering from this
+    flaw and showing all the /dev/ram devices by default)
+    """
+    for part in device_file.split("/"):
+        if part.startswith("ram") or part.startswith("loop"):
+            return True
+    return False

=== added file 'checkbox/heuristics/udisks2.py'
--- checkbox/heuristics/udisks2.py	1970-01-01 00:00:00 +0000
+++ checkbox/heuristics/udisks2.py	2012-10-09 17:53:24 +0000
@@ -0,0 +1,62 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox 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.
+#
+# Checkbox 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 Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+checkbox.heuristics.udisks2
+===========================
+
+Heuristics for udisks2.
+
+    Documentation: http://udisks.freedesktop.org/docs/latest/
+    Source code: http://cgit.freedesktop.org/systemd/systemd/ (src/udev)
+    Bug tracker: http://bugs.freedesktop.org/ (using systemd product)
+"""
+
+from checkbox.parsers.udevadm import CARD_READER_RE, GENERIC_RE, FLASH_RE
+
+
+def is_memory_card(vendor, model, udisks2_media):
+    """
+    Check if the device seems to be a memory card
+
+    The vendor and model arguments are _strings_, not integers.
+    The udisks2_media argument is the value of org.freedesktop.UDisks2.Drive/
+
+
+    This is rather fuzzy, sadly udev and udisks2 don't do a very good job and
+    mostly don't specify the "media" property (it has a few useful values, such
+    as flash_cf, flash_ms, flash_sm, flash_sd, flash_sdhc, flash_sdxc and
+    flash_mmc but I have yet to see a device that reports such values)
+    """
+    # Treat any udisks2_media that contains 'flash' as a memory card
+    if udisks2_media is not None and FLASH_RE.search(udisks2_media):
+        return True
+    # Treat any device that match model name to the following regular
+    # expression as a memory card reader.
+    if CARD_READER_RE.search(model):
+        return True
+    # Treat any device that contains the word 'Generic' in the vendor string as
+    # a memory card reader.
+    #
+    # XXX: This seems odd but strangely enough seems to gets the job done. I
+    # guess if I should start filing tons of bugs/patches on udev/udisks2 to
+    # just have a few more rules and make this rule obsolete.
+    if GENERIC_RE.search(vendor):
+        return True
+    return False

=== modified file 'checkbox/parsers/udevadm.py'
--- checkbox/parsers/udevadm.py	2012-10-04 02:54:55 +0000
+++ checkbox/parsers/udevadm.py	2012-10-09 17:53:24 +0000
@@ -59,6 +59,9 @@
     r"^scsi:"
     r"t-0x(?P<type>[%(hex)s]{2})"
     % {"hex": string.hexdigits})
+CARD_READER_RE = re.compile(r"SD|MMC|CF|MS|SM|xD|Card", re.I)
+GENERIC_RE = re.compile(r"Generic", re.I)
+FLASH_RE = re.compile(r"Flash", re.I)
 
 
 class UdevadmDevice:
@@ -208,6 +211,22 @@
             if test_bit(Input.BTN_MOUSE, bitmask, self._bits):
                 return "MOUSE"
 
+        if self.driver:
+            if self.driver.startswith("sdhci"):
+                return "CARDREADER"
+
+            if self.driver.startswith("mmc"):
+                return "CARDREADER"
+
+            if self.driver == "sd" and self.product:
+                if any(FLASH_RE.search(k) for k in self._environment.keys()):
+                    return "CARDREADER"
+                if any(d.bus == 'usb' for d in self._stack):
+                    if CARD_READER_RE.search(self.product):
+                        return "CARDREADER"
+                    if GENERIC_RE.search(self.vendor):
+                        return "CARDREADER"
+
         if "ID_TYPE" in self._environment:
             id_type = self._environment["ID_TYPE"]
 

=== added file 'checkbox/tests/heuristics.py'
--- checkbox/tests/heuristics.py	1970-01-01 00:00:00 +0000
+++ checkbox/tests/heuristics.py	2012-10-09 17:53:24 +0000
@@ -0,0 +1,40 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox 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.
+#
+# Checkbox 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 Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+checkbox.tests.heuristics
+=========================
+
+Unit tests for checkbox.heuristics package
+"""
+
+from unittest import TestCase
+
+from checkbox.heuristics.udisks2 import is_memory_card
+
+
+class TestIsMemoryCard(TestCase):
+
+    def test_generic(self):
+        """
+        Device with vendor string "GENERIC" is a memory card
+        """
+        self.assertTrue(
+            is_memory_card(vendor="Generic", model="", udisks2_media=None))

=== added file 'checkbox/udev.py'
--- checkbox/udev.py	1970-01-01 00:00:00 +0000
+++ checkbox/udev.py	2012-10-09 17:53:24 +0000
@@ -0,0 +1,93 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#
+# Checkbox 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.
+#
+# Checkbox 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 Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+checkbox.udev
+=============
+
+A collection of utility function sfor interacting with GUdev
+"""
+
+from gi.repository import GUdev
+
+from checkbox.heuristics.udev import is_virtual_device
+
+
+def get_interconnect_speed(device):
+    """
+    Compute the speed of the USB interconnect of single device
+
+    This function traverses up the tree of devices all the way to the root
+    object and returns the minimum value of the 'speed' sysfs attribute, or
+    None if there was no speed in any of the devices.
+    """
+    # We'll track the actual speed of the interconnect here. The value None
+    # means that we just don't know
+    interconnect_speed = None
+    while device:
+        # For each udev device that we traverse we attempt to lookup the
+        # 'speed' attribute. If present it is converted to an ASCII string and
+        # then to an integer. That integer represents the speed of the
+        # interconnect in megabits.
+        #
+        # Here we use get_sysfs_attr_as_int that does it all for us, returning
+        # 0 if anything is wrong.
+        device_speed = device.get_sysfs_attr_as_int('speed')
+        if device_speed != 0:  # Empty values get truncated to 0
+            # As USB devices can be connected via any number of hubs we
+            # carefully use the smallest number that is encountered but it
+            # seems that the Kernel already does the right thing and shows a
+            # SuperSpeed USB 3.0 device (that normally has speed of 5000Mbit/s)
+            # which is connected to a HighSpeed USB 2.0 device (that is limited
+            # to 480Mbit/s) to also have the smaller, 480Mbit/s speed.
+            if interconnect_speed is not None:
+                interconnect_speed = min(interconnect_speed, device_speed)
+            else:
+                interconnect_speed = device_speed
+        # We walk up the tree of udev devices looking for any parent that
+        # belongs to the 'usb' subsystem having device_type of 'usb_device'. I
+        # have not managed to find any documentation about this (I've yet to
+        # check Kernel documentation) but casual observation and testing seems
+        # to indicate that this is what we want.
+        # TODO: get_parent_with_subsystem('usb', 'usb_device')
+        device = device.get_parent()
+    return interconnect_speed
+
+
+def get_udev_block_devices(udev_client):
+    """
+    Get a list of all block devices
+
+    Returns a list of GUdev.Device objects representing all block devices in
+    the system. Virtual devices are filtered away using
+    checkbox.heuristics.udev.is_virtual_device.
+    """
+    # setup an enumerator so that we can list devices
+    enumerator = GUdev.Enumerator(client=udev_client)
+    # Iterate over block devices only
+    enumerator.add_match_subsystem('block')
+    # Convert the enumerator into a plain list and filter-away all
+    # devices deemed virtual by the heuristic.
+    devices = [
+        device for device in enumerator.execute()
+        if not is_virtual_device(device.get_device_file())]
+    # Sort the list, this is not needed but makes various debugging dumps
+    # look better.
+    devices.sort(key=lambda device: device.get_device_file())
+    return devices

=== modified file 'debian/changelog'
--- debian/changelog	2012-10-05 14:04:55 +0000
+++ debian/changelog	2012-10-09 17:53:24 +0000
@@ -1,3 +1,18 @@
+checkbox (0.14.9) quantal; urgency=low
+
+  * New upstream release (LP: #1064504)
+
+  [Zygmunt Krynicki]
+  * checkbox/dbus/__init__.py, checkbox/dbus/udisks2.py, checkbox/heuristics/,
+    checkbox/heuristics/__init__.py, checkbox/heuristics/udev.py,
+    checkbox/heuristics/udisks2.py, checkbox/tests/heuristics.py,
+    checkbox/udev.py, checkbox/parsers/udevadm.py, debian/control,
+    jobs/mediacard.txt.in, scripts/removable_storage_test,
+    scripts/removable_storage_watcher, setup.py: Added udisks2 support 
+    (LP: #1016035)
+
+ -- Daniel Manrique <[e-mail]>  Tue, 09 Oct 2012 12:23:41 -0400
+
 checkbox (0.14.8) quantal; urgency=low
 
   * New upstream release (LP: #1061359)

=== modified file 'debian/control'
--- debian/control	2012-10-04 02:54:55 +0000
+++ debian/control	2012-10-09 17:53:24 +0000
@@ -22,6 +22,7 @@
 Depends: debconf,
          python3-lxml,
          udev,
+         gir1.2-gudev-1.0,
          udisks2 | udisks,
          ${misc:Depends},
          ${python3:Depends},

=== modified file 'jobs/mediacard.txt.in'
--- jobs/mediacard.txt.in	2012-10-04 02:54:55 +0000
+++ jobs/mediacard.txt.in	2012-10-09 17:53:24 +0000
@@ -1,6 +1,6 @@
 plugin: manual
 name: mediacard/mmc-insert
-command: removable_storage_watcher insert sdio usb scsi
+command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the systems media card reader can
@@ -16,7 +16,7 @@
 plugin: shell
 name: mediacard/mmc-storage
 depends: mediacard/mmc-insert
-command: removable_storage_test sdio usb scsi
+command: removable_storage_test --memorycard sdio usb scsi
 _description:
  This test is automated and executes after the mediacard/mmc-insert
  test is run. It tests reading and writing to the MMC card.
@@ -24,7 +24,7 @@
 plugin: manual
 name: mediacard/mmc-remove
 depends: mediacard/mmc-storage
-command: removable_storage_watcher remove sdio usb scsi
+command: removable_storage_watcher --memorycard remove sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the system correctly detects 
@@ -39,7 +39,7 @@
 plugin: manual
 name: mediacard/mmc-insert-after-suspend
 depends: suspend/suspend_advanced
-command: removable_storage_watcher insert sdio usb scsi
+command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the systems media card reader can
@@ -55,7 +55,7 @@
 plugin: shell
 name: mediacard/mmc-storage-after-suspend
 depends: mediacard/mmc-insert-after-suspend
-command: removable_storage_test sdio usb scsi
+command: removable_storage_test --memorycard sdio usb scsi
 _description:
  This test is automated and executes after the mediacard/mmc-insert-after-suspend test
  is run. It tests reading and writing to the MMC card after the system has been suspended.
@@ -63,7 +63,7 @@
 plugin: manual
 name: mediacard/mmc-remove-after-suspend
 depends: mediacard/mmc-storage-after-suspend
-command: removable_storage_watcher remove sdio usb scsi
+command: removable_storage_watcher --memorycard remove sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the system correctly detects the removal
@@ -77,7 +77,7 @@
 
 plugin: manual
 name: mediacard/sd-insert
-command: removable_storage_watcher insert sdio usb scsi
+command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the systems media card reader can
@@ -93,7 +93,7 @@
 plugin: shell
 name: mediacard/sd-storage
 depends: mediacard/sd-insert
-command: removable_storage_test sdio usb scsi
+command: removable_storage_test --memorycard sdio usb scsi
 _description:
  This test is automated and executes after the mediacard/sd-insert
  test is run. It tests reading and writing to the SD card.
@@ -101,7 +101,7 @@
 plugin: manual
 name: mediacard/sd-remove
 depends: mediacard/sd-storage
-command: removable_storage_watcher remove sdio usb scsi
+command: removable_storage_watcher --memorycard remove sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the system correctly detects 
@@ -116,7 +116,7 @@
 plugin: manual
 name: mediacard/sd-insert-after-suspend
 depends: suspend/suspend_advanced
-command: removable_storage_watcher insert sdio usb scsi
+command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the systems media card reader can
@@ -132,7 +132,7 @@
 plugin: shell
 name: mediacard/sd-storage-after-suspend
 depends: mediacard/sd-insert-after-suspend
-command: removable_storage_test sdio usb scsi
+command: removable_storage_test --memorycard sdio usb scsi
 _description:
  This test is automated and executes after the mediacard/sd-insert-after-suspend test
  is run. It tests reading and writing to the SD card after the system has been suspended.
@@ -140,7 +140,7 @@
 plugin: manual
 name: mediacard/sd-remove-after-suspend
 depends: mediacard/sd-storage-after-suspend
-command: removable_storage_watcher remove sdio usb scsi
+command: removable_storage_watcher --memorycard remove sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the system correctly detects 
@@ -154,7 +154,7 @@
 
 plugin: manual
 name: mediacard/sdhc-insert
-command: removable_storage_watcher insert sdio usb scsi
+command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the systems media card reader can
@@ -170,7 +170,7 @@
 plugin: shell
 name: mediacard/sdhc-storage
 depends: mediacard/sdhc-insert
-command: removable_storage_test sdio usb scsi
+command: removable_storage_test --memorycard sdio usb scsi
 _description:
  This test is automated and executes after the mediacard/sdhc-insert
  test is run. It tests reading and writing to the SDHC card.
@@ -178,7 +178,7 @@
 plugin: manual
 name: mediacard/sdhc-remove
 depends: mediacard/sdhc-storage
-command: removable_storage_watcher remove sdio usb scsi
+command: removable_storage_watcher --memorycard remove sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the system correctly detects 
@@ -193,7 +193,7 @@
 plugin: manual
 name: mediacard/sdhc-insert-after-suspend
 depends: suspend/suspend_advanced
-command: removable_storage_watcher insert sdio usb scsi
+command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the systems media card reader can
@@ -209,7 +209,7 @@
 plugin: shell
 name: mediacard/sdhc-storage-after-suspend
 depends: mediacard/sdhc-insert-after-suspend
-command: removable_storage_test sdio usb scsi
+command: removable_storage_test --memorycard sdio usb scsi
 _description:
  This test is automated and executes after the mediacard/sdhc-insert-after-suspend test
  is run. It tests reading and writing to the SDHC card after the system has been suspended.
@@ -217,7 +217,7 @@
 plugin: manual
 name: mediacard/sdhc-remove-after-suspend
 depends: mediacard/sdhc-storage-after-suspend
-command: removable_storage_watcher remove sdio usb scsi
+command: removable_storage_watcher --memorycard remove sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the system correctly detects the removal
@@ -231,7 +231,7 @@
 
 plugin: manual
 name: mediacard/cf-insert
-command: removable_storage_watcher insert sdio usb scsi
+command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the systems media card reader can
@@ -247,7 +247,7 @@
 plugin: shell
 name: mediacard/cf-storage
 depends: mediacard/cf-insert
-command: removable_storage_test sdio usb scsi
+command: removable_storage_test --memorycard sdio usb scsi
 _description:
  This test is automated and executes after the mediacard/cf-insert
  test is run. It tests reading and writing to the CF card.
@@ -255,7 +255,7 @@
 plugin: manual
 name: mediacard/cf-remove
 depends: mediacard/cf-storage
-command: removable_storage_watcher remove sdio usb scsi
+command: removable_storage_watcher --memorycard remove sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the system correctly detects 
@@ -270,7 +270,7 @@
 plugin: manual
 name: mediacard/cf-insert-after-suspend
 depends: suspend/suspend_advanced
-command: removable_storage_watcher insert sdio usb scsi
+command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the systems media card reader can
@@ -286,7 +286,7 @@
 plugin: shell
 name: mediacard/cf-storage-after-suspend
 depends: mediacard/cf-insert-after-suspend
-command: removable_storage_test sdio usb scsi
+command: removable_storage_test --memorycard sdio usb scsi
 _description:
  This test is automated and executes after the mediacard/cf-insert-after-suspend test
  is run. It tests reading and writing to the CF card after the system has been suspended.
@@ -294,7 +294,7 @@
 plugin: manual
 name: mediacard/cf-remove-after-suspend
 depends: mediacard/cf-storage-after-suspend
-command: removable_storage_watcher remove sdio usb scsi
+command: removable_storage_watcher --memorycard remove sdio usb scsi
 _description:
  PURPOSE:
      This test will check that the system correctly detects the removal

=== modified file 'scripts/removable_storage_test'
--- scripts/removable_storage_test	2012-08-20 18:13:17 +0000
+++ scripts/removable_storage_test	2012-10-09 17:53:24 +0000
@@ -1,17 +1,31 @@
 #!/usr/bin/env python3
 
+import argparse
+import collections
 import dbus
+import hashlib
+import logging
+import os
+import subprocess
 import sys
-import random
-import os
 import tempfile
-import hashlib
-import argparse
-import subprocess
-import threading
 import time
 
-from shutil import copy2
+from gi.repository import GUdev
+
+from checkbox.dbus import connect_to_system_bus
+from checkbox.dbus.udisks2 import UDISKS2_BLOCK_INTERFACE
+from checkbox.dbus.udisks2 import UDISKS2_DRIVE_INTERFACE
+from checkbox.dbus.udisks2 import UDISKS2_FILESYSTEM_INTERFACE
+from checkbox.dbus.udisks2 import UDisks2Model, UDisks2Observer
+from checkbox.dbus.udisks2 import is_udisks2_supported
+from checkbox.dbus.udisks2 import lookup_udev_device
+from checkbox.dbus.udisks2 import map_udisks1_connection_bus
+from checkbox.heuristics.udisks2 import is_memory_card
+from checkbox.parsers.udevadm import CARD_READER_RE, GENERIC_RE, FLASH_RE
+from checkbox.udev import get_interconnect_speed
+from checkbox.udev import get_udev_block_devices
+
 
 class ActionTimer():
     '''Class to implement a simple timer'''
@@ -23,105 +37,268 @@
         self.stop = time.time()
         self.interval = self.stop - self.start
 
-class DiskTest():
-    ''' Class to contain various methods for testing USB disks '''
-    def __init__(self):
-        self.process = None
-        self.cmd = None
-        self.timeout = 3
-        self.returnCode = None
-        self.rem_disks = {}     # mounted before the script running
-        self.rem_disks_nm = {}  # not mounted before the script running
 
-    def generate_test_data(self, size):
-        '''Generate a random data file of a given size'''
-        min = 100
-        max = 1000000
+class RandomData():
+    '''Class to create data files'''
+    def __init__(self, size):
         self.tfile = tempfile.NamedTemporaryFile(delete=False)
+        self.path = ''
+        self.name = ''
+        self.path, self.name = os.path.split(self.tfile.name)
+        self._write_test_data_file(size)
+
+    def _generate_test_data(self):
+        seed = "104872948765827105728492766217823438120"
+        phrase = '''
+        Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam
+        nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat
+        volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation
+        ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat.
+        Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse
+        molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero
+        eros et accumsan et iusto odio dignissim qui blandit praesent luptatum
+        zzril delenit augue duis dolore te feugait nulla facilisi.
+        '''
+        words = phrase.replace('\n', '').split()
+        word_deque = collections.deque(words)
+        seed_deque = collections.deque(seed)
+        while True:
+            yield ' '.join(list(word_deque))
+            word_deque.rotate(int(seed_deque[0]))
+            seed_deque.rotate(1)
+
+    def _write_test_data_file(self, size):
+        data = self._generate_test_data()
         while os.path.getsize(self.tfile.name) < size:
-            self.tfile.write(str(random.randint(min, max)).encode('UTF-8'))
-
-    def md5_hash_file(self, path):
-        try:
-            fh = open(path, 'r')
-        except IOError:
-            print("ERROR: unable to open file %s" % path, file=sys.stderr)
-            return 1
-        md5 = hashlib.md5()
-        try:
+            self.tfile.write(next(data).encode('UTF-8'))
+        return self
+
+
+def md5_hash_file(path):
+    md5 = hashlib.md5()
+    try:
+        with open(path, 'rb') as stream:
             while True:
-                data = fh.read(8192)
+                data = stream.read(8192)
                 if not data:
                     break
-                md5.update(data.encode('utf-8'))
-        finally:
-            fh.close()
+                md5.update(data)
+    except IOError as exc:
+        logging.error("unable to checksum %s: %s", path, exc)
+        return None
+    else:
         return md5.hexdigest()
 
-    def copy_file(self, source, dest):
-        try:
-            copy2(source, dest)
-        except IOError:
-            print("ERROR: Unable to copy the file to %s" % dest,
-                file=sys.stderr)
-            return False
-        else:
-            return True
-
-    def compare_hash(self, parent, child):
-        if not parent == child:
-            return False
-        else:
-            return True
+
+class DiskTest():
+    ''' Class to contain various methods for testing removable disks '''
+
+    def __init__(self, device, memorycard):
+        self.rem_disks = {}     # mounted before the script running
+        self.rem_disks_nm = {}  # not mounted before the script running
+        self.rem_disks_memory_cards = {}
+        self.rem_disks_memory_cards_nm = {}
+        self.rem_disks_speed = {}
+        self.data = ''
+        self.device = device
+        self.memorycard = memorycard
+        self._probe_disks()
+
+    def read_file(self, source):
+        with open(source, 'rb') as infile:
+            try:
+                self.data = infile.read()
+            except IOError as exc:
+                logging.error("Unable to read data from %s: %s", source, exc)
+                return False
+            else:
+                return True
+
+    def write_file(self, data, dest):
+        with open(dest, 'wb', 0) as outfile:
+            try:
+                outfile.write(self.data)
+            except IOError as exc:
+                logging.error("Unable to write data to %s: %s", dest, exc)
+                return False
+            else:
+                outfile.flush()
+                os.fsync(outfile.fileno())
+                return True
 
     def clean_up(self, target):
         try:
             os.unlink(target)
-        except:
-            print("ERROR: Unable to remove tempfile %s" % target,
-                file=sys.stderr)
-
-    def get_disk_info(self, device):
-        ''' Probes dbus to find any attached/mounted devices'''
-        bus = dbus.SystemBus()
+        except OSError as exc:
+            logging.error("Unable to remove tempfile %s: %s", target, exc)
+
+    def _probe_disks(self):
+        """
+        Internal method used to probe for available disks
+
+        Indirectly sets:
+            self.rem_disks{,_nm,_memory_cards,_memory_cards_nm,_speed}
+        """
+        bus, loop = connect_to_system_bus()
+        if is_udisks2_supported(bus):
+            self._probe_disks_udisks2(bus)
+        else:
+            self._probe_disks_udisks1(bus)
+
+    def _probe_disks_udisks2(self, bus):
+        """
+        Internal method used to probe / discover available disks using udisks2
+        dbus interface using the provided dbus bus (presumably the system bus)
+        """
+        # We'll need udisks2 and udev to get the data we need
+        udisks2_observer = UDisks2Observer()
+        udisks2_model = UDisks2Model(udisks2_observer)
+        udisks2_observer.connect_to_bus(bus)
+        udev_client = GUdev.Client()
+        # Get a collection of all udev devices corresponding to block devices
+        udev_devices = get_udev_block_devices(udev_client)
+        # Get a collection of all udisks2 objects
+        udisks2_objects = udisks2_model.managed_objects
+        # Let's get a helper to simplify the loop below
+
+        def iter_filesystems_on_block_devices():
+            """
+            Generate a collection of UDisks2 object paths that
+            have both the filesystem and block device interfaces
+            """
+            for udisks2_object_path, interfaces in udisks2_objects.items():
+                if (UDISKS2_FILESYSTEM_INTERFACE in interfaces
+                    and UDISKS2_BLOCK_INTERFACE in interfaces):
+                    yield udisks2_object_path
+        # We need to know about all IO candidates,
+        # let's iterate over all the block devices reported by udisks2
+        for udisks2_object_path in iter_filesystems_on_block_devices():
+            # Get interfaces implemented by this object
+            udisks2_object = udisks2_objects[udisks2_object_path]
+            # Find the path of the udisks2 object that represents the drive
+            # this object is a part of
+            drive_object_path = (
+                udisks2_object[UDISKS2_BLOCK_INTERFACE]['Drive'])
+            # Lookup the drive object, if any. This can fail when
+            try:
+                drive_object = udisks2_objects[drive_object_path]
+            except KeyError:
+                logging.error(
+                    "Unable to locate drive associated with %s",
+                    udisks2_object_path)
+                continue
+            else:
+                drive_props = drive_object[UDISKS2_DRIVE_INTERFACE]
+            # Get the connection bus property from the drive interface of the
+            # drive object. This is required to filter out the devices we don't
+            # want to look at now.
+            connection_bus = drive_props["ConnectionBus"]
+            desired_connection_buses = set([
+                map_udisks1_connection_bus(device)
+                for device in self.device])
+            # Skip devices that are attached to undesired connection buses
+            if connection_bus not in desired_connection_buses:
+                continue
+            # Lookup the udev object that corresponds to this object
+            try:
+                udev_device = lookup_udev_device(udisks2_object, udev_devices)
+            except LookupError:
+                logging.error(
+                    "Unable to locate udev object that corresponds to: %s",
+                    udisks2_object_path)
+                continue
+            # Get the block device pathname,
+            # to avoid the confusion, this is something like /dev/sdbX
+            dev_file = udev_device.get_device_file()
+            # Get the list of mount points of this block device
+            mount_points = (
+                udisks2_object[UDISKS2_FILESYSTEM_INTERFACE]['MountPoints'])
+            # Get the speed of the interconnect that is associated with the
+            # block device we're looking at. This is purely informational but
+            # it is a part of the required API
+            interconnect_speed = get_interconnect_speed(udev_device)
+            if interconnect_speed:
+                self.rem_disks_speed[dev_file] = (
+                    interconnect_speed * 10 ** 6)
+            else:
+                self.rem_disks_speed[dev_file] = None
+            # We need to skip-non memory cards if we look for memory cards and
+            # vice-versa so let's inspect the drive and use heuristics to
+            # detect memory cards (a memory card reader actually) now.
+            if self.memorycard != is_memory_card(drive_props['Vendor'],
+                                                 drive_props['Model'],
+                                                 drive_props['Media']):
+                continue
+            # The if/else test below simply distributes the mount_point to the
+            # appropriate variable, to keep the API requirements. It is
+            # confusing as _memory_cards is variable is somewhat dummy.
+            if mount_points:
+                # XXX: Arbitrarily pick the first of the mount points
+                mount_point = mount_points[0]
+                self.rem_disks_memory_cards[dev_file] = mount_point
+                self.rem_disks[dev_file] = mount_point
+            else:
+                self.rem_disks_memory_cards_nm[dev_file] = None
+                self.rem_disks_nm[dev_file] = None
+
+    def _probe_disks_udisks1(self, bus):
+        """
+        Internal method used to probe / discover available disks using udisks1
+        dbus interface using the provided dbus bus (presumably the system bus)
+        """
         ud_manager_obj = bus.get_object("org.freedesktop.UDisks",
                                         "/org/freedesktop/UDisks")
         ud_manager = dbus.Interface(ud_manager_obj, 'org.freedesktop.UDisks')
-        self.rem_disks = {}
-        self.rem_disks_nm = {}
         for dev in ud_manager.EnumerateDevices():
             device_obj = bus.get_object("org.freedesktop.UDisks", dev)
             device_props = dbus.Interface(device_obj, dbus.PROPERTIES_IFACE)
             udisks = 'org.freedesktop.UDisks.Device'
             if not device_props.Get(udisks, "DeviceIsDrive"):
-                if device_props.Get(udisks,
-                                    "DriveConnectionInterface") in device:
+                dev_bus = device_props.Get(udisks, "DriveConnectionInterface")
+                if dev_bus in self.device:
+                    parent_model = parent_vendor = ''
+                    if device_props.Get(udisks, "DeviceIsPartition"):
+                        parent_obj = bus.get_object(
+                            "org.freedesktop.UDisks",
+                            device_props.Get(udisks, "PartitionSlave"))
+                        parent_props = dbus.Interface(
+                            parent_obj, dbus.PROPERTIES_IFACE)
+                        parent_model = parent_props.Get(udisks, "DriveModel")
+                        parent_vendor = parent_props.Get(udisks, "DriveVendor")
+                        parent_media = parent_props.Get(udisks, "DriveMedia")
+                    if self.memorycard:
+                        if (dev_bus != 'sdio'
+                            and not FLASH_RE.search(parent_media)
+                            and not CARD_READER_RE.search(parent_model)
+                            and not GENERIC_RE.search(parent_vendor)):
+                            continue
+                    else:
+                        if (FLASH_RE.search(parent_media)
+                            or CARD_READER_RE.search(parent_model)
+                            or GENERIC_RE.search(parent_vendor)):
+                            continue
                     dev_file = str(device_props.Get(udisks, "DeviceFile"))
-
+                    dev_speed = str(device_props.Get(udisks,
+                                                     "DriveConnectionSpeed"))
+                    self.rem_disks_speed[dev_file] = dev_speed
                     if len(device_props.Get(udisks, "DeviceMountPaths")) > 0:
                         devPath = str(device_props.Get(udisks,
                                                        "DeviceMountPaths")[0])
                         self.rem_disks[dev_file] = devPath
+                        self.rem_disks_memory_cards[dev_file] = devPath
                     else:
                         self.rem_disks_nm[dev_file] = None
+                        self.rem_disks_memory_cards_nm[dev_file] = None
 
     def mount(self):
         passed_mount = {}
 
-        for key, dummy in self.rem_disks_nm.items():
-            file = tempfile.mkdtemp(dir='/tmp')
-
-            result = False
-            try:
-                result = self.make_thread(self._mount(key, file))
-            except:
-                pass
-
-            # remove those devices fail at mounting
-            if result:
-                passed_mount[key] = file
+        for key in self.rem_disks_nm:
+            temp_dir = tempfile.mkdtemp()
+            if self._mount(key, temp_dir) != 0:
+                logging.error("can't mount %s", key)
             else:
-                print("ERROR: can't mount %s" % (key), file=sys.stderr)
+                passed_mount[key] = temp_dir
 
         if len(self.rem_disks_nm) == len(passed_mount):
             self.rem_disks_nm = passed_mount
@@ -131,72 +308,69 @@
             self.rem_disks_nm = passed_mount
             return count
 
-    def _mount(self, dev_file, tmp_dir):
-        cmd = ['/bin/mount', dev_file, tmp_dir]
-        self.process = subprocess.Popen(cmd)
-        self.process.communicate()
+    def _mount(self, dev_file, mount_point):
+        return subprocess.call(['mount', dev_file, mount_point])
 
     def umount(self):
         errors = 0
-
         for disk in self.rem_disks_nm:
-            result = False
-            try:
-                result = self.make_thread(self._umount(disk))
-            except:
+            if not self.rem_disks_nm[disk]:
+                continue
+            if self._umount(disk) != 0:
                 errors += 1
-                pass
-
-            if not result:
-                print("ERROR: can't umount %s on %s"
-                       % (disk, self.rem_disks_nm[disk]), file=sys.stderr)
-
+                logging.error("can't umount %s on %s",
+                              disk, self.rem_disks_nm[disk])
         return errors
 
-    def _umount(self, dir):
+    def _umount(self, mount_point):
         # '-l': lazy umount, dealing problem of unable to umount the device.
-        cmd = ['/bin/umount', '-l', dir]
-        self.process = subprocess.Popen(cmd)
-        self.process.communicate()
+        return subprocess.call(['umount', '-l', mount_point])
 
     def clean_tmp_dir(self):
         for disk in self.rem_disks_nm:
+            if not self.rem_disks_nm[disk]:
+                continue
             if not os.path.ismount(self.rem_disks_nm[disk]):
                 os.rmdir(self.rem_disks_nm[disk])
 
-    def make_thread(self, target):
-        thread = threading.Thread(target=target)
-        thread.start()
-        thread.join(self.timeout)
-
-        if thread.is_alive():
-            self.process.terminate()
-            thread.join()
-
-        result = getattr(self.process, 'returncode', 1)
-
-        if result == 0:
-            return True
-        else:
-            return False
-
 
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('device',
-                        choices=['usb', 'firewire', 'sdio', 'scsi', 'ata_serial_esata'],
+                        choices=['usb', 'firewire', 'sdio',
+                                 'scsi', 'ata_serial_esata'],
                         nargs='+',
                         help=("The type of removable media "
-                              "(usb, firewire, sdio, scsi or ata_serial_esata) to test."))
+                              "(usb, firewire, sdio, scsi or ata_serial_esata)"
+                              "to test."))
     parser.add_argument('-l', '--list',
                         action='store_true',
                         default=False,
                         help="List the removable devices and mounting status")
+    parser.add_argument('-m', '--min-speed',
+                        action='store',
+                        default=0,
+                        type=int,
+                        help="Minimum speed a device must support to be "
+                             "considered eligible for being tested (bits/s)")
+    parser.add_argument('-p', '--pass-speed',
+                        action='store',
+                        default=0,
+                        type=int,
+                        help="Minimum average throughput from all eligible"
+                             "devices for the test to pass (MB/s)")
+    parser.add_argument('-i', '--iterations',
+                        action='store',
+                        default='1',
+                        type=int,
+                        help=("The number of test cycles to run. One cycle is"
+                              "comprised of generating --count data files of "
+                              "--size bytes and writing them to each device."))
     parser.add_argument('-c', '--count',
                         action='store',
                         default='1',
                         type=int,
-                        help='The number of times to run the test')
+                        help='The number of random data files to generate')
     parser.add_argument('-s', '--size',
                         action='store',
                         type=int,
@@ -208,12 +382,14 @@
                         default=False,
                         help=("skip the removable devices "
                               "which haven't been mounted before the test."))
+    parser.add_argument('--memorycard', action="store_true",
+                        help=("Memory cards devices on bus other than sdio "
+                              "require this parameter to identify "
+                              "them as such"))
 
     args = parser.parse_args()
 
-    test = DiskTest()
-
-    test.get_disk_info(args.device)
+    test = DiskTest(args.device, args.memorycard)
 
     errors = 0
     # If we do have removable drives attached and mounted
@@ -221,24 +397,38 @@
         if args.list:  # Simply output a list of drives detected
             print('-' * 20)
             print("Removable devices currently mounted:")
-            if len(test.rem_disks) > 0:
-                for disk, mount_point in test.rem_disks.items():
-                    print("%s : %s" % (disk, mount_point))
-            else:
-                print("None")
-
-            print("Removable devices currently not mounted:")
-            if len(test.rem_disks_nm) > 0:
-                for disk, dummy in test.rem_disks_nm.items():
-                    print(disk)
-            else:
-                print("None")
+            if args.memorycard:
+                if len(test.rem_disks_memory_cards) > 0:
+                    for disk, mnt_point in test.rem_disks_memory_cards.items():
+                        print("%s : %s" % (disk, mnt_point))
+                else:
+                    print("None")
+
+                print("Removable devices currently not mounted:")
+                if len(test.rem_disks_memory_cards_nm) > 0:
+                    for disk in test.rem_disks_memory_cards_nm:
+                        print(disk)
+                else:
+                    print("None")
+            else:
+                if len(test.rem_disks) > 0:
+                    for disk, mnt_point in test.rem_disks.items():
+                        print("%s : %s" % (disk, mnt_point))
+                else:
+                    print("None")
+
+                print("Removable devices currently not mounted:")
+                if len(test.rem_disks_nm) > 0:
+                    for disk in test.rem_disks_nm:
+                        print(disk)
+                else:
+                    print("None")
 
             print('-' * 20)
 
             return 0
 
-        else:  # Create a file, copy to USB and compare hashes
+        else:  # Create a file, copy to disk and compare hashes
             if args.skip_not_mount:
                 disks_all = test.rem_disks
             else:
@@ -255,72 +445,132 @@
 
             if len(disks_all) > 0:
                 print("Found the following mounted %s partitions:"
-                       % args.device)
+                       % ', '.join(args.device))
 
                 for disk, mount_point in disks_all.items():
-                    print("    %s : %s" % (disk, mount_point))
+                    supported_speed = test.rem_disks_speed[disk]
+                    print("    %s : %s : %s bits/s" %
+                            (disk, mount_point, supported_speed),
+                            end="")
+                    if (args.min_speed
+                        and int(args.min_speed) > int(supported_speed)):
+                        print(" (Will not test it, speed is below %s bits/s)" %
+                                args.min_speed, end="")
+
+                    print("")
 
                 print('-' * 20)
 
-                write_times = []
+                disks_eligible = {disk: disks_all[disk] for disk in disks_all
+                                  if not args.min_speed or
+                                  int(test.rem_disks_speed[disk])
+                                  >= int(args.min_speed)}
+                write_sizes = []
+                test_files = {}
+                # Generate our data file(s)
+                for count in range(args.count):
+                    test_files[count] = RandomData(args.size)
+                    write_sizes.append(os.path.getsize(
+                                        test_files[count].tfile.name))
+                    total_write_size = sum(write_sizes)
+
                 try:
-                    for iteration in range(args.count):
-                        test.generate_test_data(args.size)
-                        parent_hash = test.md5_hash_file(test.tfile.name)
-                        for disk, mount_point in disks_all.items():
-                            with ActionTimer() as timer:
-                                if not test.copy_file(test.tfile.name, mount_point):
-                                    print("ERROR: Failed to copy %s to %s" %
-                                        (test.tfile.name, mount_point), file=sys.stderr)
+                    for disk, mount_point in disks_eligible.items():
+                        print("%s (Total Data Size / iteration: %0.4f MB):" %
+                              (disk, (total_write_size / 1024 / 1024)))
+                        iteration_write_size = (
+                            total_write_size * args.iterations) / 1024 / 1024
+                        iteration_write_times = []
+                        for iteration in range(args.iterations):
+                            target_file_list = []
+                            write_times = []
+                            for file_index in range(args.count):
+                                parent_file = test_files[file_index].tfile.name
+                                parent_hash = md5_hash_file(parent_file)
+                                target_filename = (
+                                    test_files[file_index].name +
+                                    '.%s' % iteration)
+                                target_path = mount_point
+                                target_file = os.path.join(target_path,
+                                                           target_filename)
+                                target_file_list.append(target_file)
+                                test.read_file(parent_file)
+                                with ActionTimer() as timer:
+                                    if not test.write_file(test.data,
+                                                           target_file):
+                                        logging.error(
+                                            "Failed to copy %s to %s",
+                                            parent_file, target_file)
+                                        errors += 1
+                                        continue
+                                write_times.append(timer.interval)
+                                child_hash = md5_hash_file(target_file)
+                                if parent_hash != child_hash:
+                                    logging.warning(
+                                        "[Iteration %s] Parent and Child"
+                                        " copy hashes mismatch on %s!",
+                                        iteration, target_file)
+                                    logging.warning(
+                                        "\tParent hash: %s", parent_hash)
+                                    logging.warning(
+                                        "\tChild hash: %s", child_hash)
                                     errors += 1
-                                    continue
-                            print("[Iteration %s] Copy took %0.3f secs." %
-                                    (iteration, timer.interval))
-                            write_times.append(timer.interval)
-
-                            target = os.path.join(mount_point,
-                                          os.path.basename(test.tfile.name))
-                            child_hash = test.md5_hash_file(target)
-                            if not test.compare_hash(parent_hash, child_hash):
-                                print("ERROR: [Iteration %s] Parent and Child"
-                                        "copy hashes mismatch on %s!" %
-                                        (iteration,mount_point), file=sys.stderr)
-                                print("\tParent hash: %s" % parent_hash,
-                                        file=sys.stderr)
-                                print("\tChild hash: %s" % child_hash,
-                                        file=sys.stderr)
-                                errors += 1
-                            test.clean_up(target)
-                        test.clean_up(test.tfile.name)
+                            for file in target_file_list:
+                                test.clean_up(file)
+                            total_write_time = sum(write_times)
+                            avg_write_time = total_write_time / args.count
+                            avg_write_speed = ((
+                                total_write_size / total_write_time)
+                                / 1024 / 1024)
+                            iteration_write_times.append(total_write_time)
+                            print("\t[Iteration %s] Average Speed: %0.4f"
+                                  % (iteration, avg_write_speed))
+                        for iteration in range(args.iterations):
+                            iteration_write_time = sum(iteration_write_times)
+                        print("\tSummary:")
+                        print("\t\tTotal Data Written: %0.4f MB"
+                              % iteration_write_size)
+                        print("\t\tTotal Time to write: %0.4f secs"
+                              % iteration_write_time)
+                        print("\t\tAverage Write Time: %0.4f secs" %
+                              (iteration_write_time / args.iterations))
+                        print("\t\tAverage Write Speed: %0.4f MB/s" %
+                              (iteration_write_size / iteration_write_time))
                 finally:
+                    for key in range(args.count):
+                        test.clean_up(test_files[key].tfile.name)
                     if (len(test.rem_disks_nm) > 0):
                         if test.umount() != 0:
                             errors += 1
                         test.clean_tmp_dir()
 
                 if errors > 0:
-                    print("ERROR: Completed %s test iterations, "
-                           "but there were errors" % args.count, file=sys.stderr)
-                    return 1
+                    logging.warning(
+                        "Completed %s test iterations, but there were"
+                        " errors", args.count)
+                    return 1
+                elif len(disks_eligible) == 0:
+                    logging.error(
+                        "No %s disks with speed higher than %s bits/s",
+                        args.device, args.min_speed)
+                    return 1
+
                 else:
-                    print("Successfully completed %s %s file transfer "
-                           "test iterations"
-                           % (args.count, args.device))
-                    total_write_time = sum(write_times)
-                    avg_write_time = total_write_time / args.count
-                    avg_write_speed = (args.size / avg_write_time) / 1024
-                    print("Total time writing data: %0.4f" % total_write_time)
-                    print("Average time per write: %0.4f" % avg_write_time)
-                    print("Average write speed: %0.4f KB/s" %
-                            avg_write_speed)
-                    return 0
+                    #Pass is not assured!
+                    if (not args.pass_speed or
+                        avg_write_speed >= args.pass_speed):
+                        return 0
+                    else:
+                        print("FAIL: Average speed was lower than desired "
+                              "pass speed of %s MB/s" % args.pass_speed)
+                        return 1
             else:
-                print("ERROR: No device being mounted successfully for testing, "
-                      "aborting", file=sys.stderr)
+                logging.error("No device being mounted successfully "
+                              "for testing, aborting")
                 return 1
 
     else:  # If we don't have removable drives attached and mounted
-        print("ERROR: No removable drives were detected, aborting", file=sys.stderr)
+        logging.error("No removable drives were detected, aborting")
         return 1
 
 if __name__ == '__main__':

=== modified file 'scripts/removable_storage_watcher'
--- scripts/removable_storage_watcher	2012-08-20 18:13:17 +0000
+++ scripts/removable_storage_watcher	2012-10-09 17:53:24 +0000
@@ -1,67 +1,217 @@
 #!/usr/bin/env python3
 
+import argparse
+import collections
+import copy
+import dbus
+import logging
 import sys
-import dbus
-import argparse
-
-from gi.repository import GObject
-from dbus.mainloop.glib import DBusGMainLoop
-
-
-class StorageDeviceListener:
-
-    def __init__(self, action, devices):
+
+from gi.repository import GObject, GUdev
+
+from checkbox.dbus import connect_to_system_bus
+from checkbox.dbus.udisks2 import UDisks2Model, UDisks2Observer
+from checkbox.dbus.udisks2 import is_udisks2_supported
+from checkbox.dbus.udisks2 import lookup_udev_device
+from checkbox.dbus.udisks2 import map_udisks1_connection_bus
+from checkbox.heuristics.udisks2 import is_memory_card
+from checkbox.parsers.udevadm import CARD_READER_RE, GENERIC_RE, FLASH_RE
+from checkbox.udev import get_interconnect_speed, get_udev_block_devices
+
+# Record representing properties of a UDisks1 Drive object needed by the
+# UDisks1 version of the watcher implementation
+UDisks1DriveProperties = collections.namedtuple(
+    'UDisks1DriveProperties', 'file bus speed model vendor media')
+
+# Delta record that encapsulates difference:
+# delta_dir -- directon of the difference, either DELTA_DIR_PLUS or
+#              DELTA_DIR_MINUS
+# value -- the actual value being removed or added, either InterfaceDelta or
+# PropertyDelta instance, see below
+DeltaRecord = collections.namedtuple("DeltaRecord", "delta_dir value")
+
+# Delta value for representing interface changes
+InterfaceDelta = collections.namedtuple(
+    "InterfaceDelta",
+    "delta_type object_path iface_name")
+
+# Delta value for representing property changes
+PropertyDelta = collections.namedtuple(
+    "PropertyDelta",
+    "delta_type object_path iface_name prop_name prop_value")
+
+# Tokens that encode additions and removals
+DELTA_DIR_PLUS = '+'
+DELTA_DIR_MINUS = '-'
+
+# Tokens that encode interface and property deltas
+DELTA_TYPE_IFACE = 'i'
+DELTA_TYPE_PROP = 'p'
+
+
+def format_bytes(size):
+    """
+    Format size to be easily read by humans
+
+    The result is disk-size compatible (using multiples of 10
+    rather than 2) string like "4.5GB"
+    """
+    for index, prefix in enumerate(" KMGTPEZY", 0):
+        factor = 10 ** (index * 3)
+        if size // factor <= 1000:
+            break
+    return "{}{}B".format(size // factor, prefix.strip())
+
+
+class UDisks1StorageDeviceListener:
+
+    def __init__(self, system_bus, loop, action, devices, minimum_speed,
+                 memorycard):
         self._action = action
         self._devices = devices
-        self._bus = dbus.SystemBus(mainloop=DBusGMainLoop())
-        self._loop = GObject.MainLoop()
+        self._minimum_speed = minimum_speed
+        self._memorycard = memorycard
+        self._bus = system_bus
+        self._loop = loop
         self._error = False
+        self._change_cache = []
 
     def check(self, timeout):
         udisks = 'org.freedesktop.UDisks'
         if self._action == 'insert':
+            signal = 'DeviceAdded'
+            logging.debug("Adding signal listener for %s.%s", udisks, signal)
             self._bus.add_signal_receiver(self.add_detected,
-                                          signal_name='DeviceAdded',
+                                          signal_name=signal,
                                           dbus_interface=udisks)
         elif self._action == 'remove':
+            signal = 'DeviceRemoved'
+            logging.debug("Adding signal listener for %s.%s", udisks, signal)
             self._bus.add_signal_receiver(self.remove_detected,
-                                          signal_name='DeviceRemoved',
+                                          signal_name=signal,
                                           dbus_interface=udisks)
 
+        self._starting_devices = self.get_existing_devices()
+        logging.debug("Starting with the following devices: %r",
+                      self._starting_devices)
+
         def timeout_callback():
             print("%s seconds have expired "
                   "waiting for the device to be inserted." % timeout)
             self._error = True
             self._loop.quit()
 
+        logging.debug("Adding timeout listener, timeout=%r", timeout)
         GObject.timeout_add_seconds(timeout, timeout_callback)
+        logging.debug("Starting event loop...")
         self._loop.run()
 
         return self._error
 
+    def verify_device_change(self, changed_devices, message=""):
+        logging.debug("Verifying device change: %s", changed_devices)
+        # Filter the applicable bus types, as provided on the command line
+        # (values of self._devices can be 'usb', 'firewire', etc)
+        desired_bus_devices = [
+            device
+            for device in changed_devices
+            if device.bus in self._devices]
+        logging.debug("Desired bus devices: %s", desired_bus_devices)
+        for dev in desired_bus_devices:
+            if self._memorycard:
+                if (dev.bus != 'sdio'
+                    and not FLASH_RE.search(dev.media)
+                    and not CARD_READER_RE.search(dev.model)
+                    and not GENERIC_RE.search(dev.vendor)):
+                    logging.debug("The device does not seem to be a memory"
+                                  " card (bus: %r, model: %r), skipping",
+                                 dev.bus, dev.model)
+                    return
+                print(message % {'bus': 'memory card', 'file': dev.file})
+            else:
+                if (FLASH_RE.search(dev.media)
+                    or CARD_READER_RE.search(dev.model)
+                    or GENERIC_RE.search(dev.vendor)):
+                    logging.debug("The device seems to be a memory"
+                                  " card (bus: %r (model: %r), skipping",
+                                  dev.bus, dev.model)
+                    return
+                print(message % {'bus': dev.bus, 'file': dev.file})
+            if self._minimum_speed:
+                if dev.speed >= self._minimum_speed:
+                    print("with speed of %(speed)s bits/s "
+                          "higher than %(min_speed)s bits/s" %
+                          {'speed': dev.speed,
+                           'min_speed': self._minimum_speed})
+                else:
+                    print("ERROR: speed of %(speed)s bits/s lower "
+                          "than %(min_speed)s bits/s" %
+                          {'speed': dev.speed,
+                           'min_speed': self._minimum_speed})
+                    self._error = True
+            logging.debug("Device matches requirements, exiting event loop")
+            self._loop.quit()
+
     def job_change_detected(self, devices, job_in_progress, job_id,
                             job_num_tasks, job_cur_task_id,
                             job_cur_task_percentage):
-        if job_id == "FilesystemMount" and self.is_device_inserted():
-            print("Expected device %s inserted" % self._device)
-            self._loop.quit()
+        logging.debug("UDisks1 reports a job change has been detected:"
+                      " devices: %s, job_in_progress: %s, job_id: %s,"
+                      " job_num_tasks: %s, job_cur_task_id: %s,"
+                      " job_cur_task_percentage: %s",
+                      devices, job_in_progress, job_id, job_num_tasks,
+                      job_cur_task_id, job_cur_task_percentage)
+        if job_id == "FilesystemMount":
+            if devices in self._change_cache:
+                logging.debug("Ignoring filesystem mount,"
+                              " the device is present in change cache")
+                return
+            logging.debug("Adding devices to change cache: %r", devices)
+            self._change_cache.append(devices)
+            logging.debug("Starting devices were: %s", self._starting_devices)
+            current_devices = self.get_existing_devices()
+            logging.debug("Current devices are: %s", current_devices)
+            inserted_devices = list(set(current_devices) -
+                                    set(self._starting_devices))
+            logging.debug("Computed inserted devices: %s", inserted_devices)
+            if self._memorycard:
+                message = "Expected memory card device %(file)s inserted"
+            else:
+                message = "Expected %(bus)s device %(file)s inserted"
+            self.verify_device_change(inserted_devices,
+                      message=message)
 
     def add_detected(self, added_path):
+        logging.debug("UDisks1 reports device has been added: %s", added_path)
+        logging.debug("Resetting change_cache to []")
+        self._change_cache = []
+        signal_name = 'DeviceJobChanged'
+        dbus_interface = 'org.freedesktop.UDisks'
+        logging.debug("Adding signal listener for %s.%s",
+                      dbus_interface, signal_name)
         self._bus.add_signal_receiver(self.job_change_detected,
-                                      signal_name='DeviceJobChanged',
-                                      dbus_interface='org.freedesktop.UDisks')
+                                      signal_name=signal_name,
+                                      dbus_interface=dbus_interface)
 
     def remove_detected(self, removed_path):
-        if not self.is_device_inserted():
-            print("Removable storage device has been removed")
-        #TODO: figure out a way to get the DriveConnectionInterface of the
-        #device that was just removed.
-        self._loop.quit()
-
-    def is_device_inserted(self):
+        logging.debug("UDisks1 reports device has been removed: %s",
+                      removed_path)
+
+        logging.debug("Starting devices were: %s", self._starting_devices)
+        current_devices = self.get_existing_devices()
+        logging.debug("Current devices are: %s", current_devices)
+        removed_devices = list(set(self._starting_devices) -
+                               set(current_devices))
+        logging.debug("Computed removed devices: %s", removed_devices)
+        self.verify_device_change(removed_devices,
+                  message="Removable %(bus)s device %(file)s has been removed")
+
+    def get_existing_devices(self):
+        logging.debug("Getting existing devices from UDisks1")
         ud_manager_obj = self._bus.get_object("org.freedesktop.UDisks",
                                               "/org/freedesktop/UDisks")
         ud_manager = dbus.Interface(ud_manager_obj, 'org.freedesktop.UDisks')
+        existing_devices = []
         for dev in ud_manager.EnumerateDevices():
             try:
                 device_obj = self._bus.get_object("org.freedesktop.UDisks",
@@ -69,30 +219,666 @@
                 device_props = dbus.Interface(device_obj,
                                               dbus.PROPERTIES_IFACE)
                 udisks = 'org.freedesktop.UDisks.Device'
-                self._device = device_props.Get(udisks,
-                                                "DriveConnectionInterface")
+                _device_file = device_props.Get(udisks,
+                                           "DeviceFile")
+                _bus = device_props.Get(udisks,
+                                           "DriveConnectionInterface")
+                _speed = device_props.Get(udisks,
+                                                "DriveConnectionSpeed")
+                _parent_model = ''
+                _parent_media = ''
+                _parent_vendor = ''
+
+                if device_props.Get(udisks, "DeviceIsPartition"):
+                    parent_obj = self._bus.get_object(
+                        "org.freedesktop.UDisks",
+                        device_props.Get(udisks, "PartitionSlave"))
+                    parent_props = dbus.Interface(
+                        parent_obj, dbus.PROPERTIES_IFACE)
+                    _parent_model = parent_props.Get(udisks, "DriveModel")
+                    _parent_vendor = parent_props.Get(udisks, "DriveVendor")
+                    _parent_media = parent_props.Get(udisks, "DriveMedia")
+
                 if not device_props.Get(udisks, "DeviceIsDrive"):
-                    if self._device in self._devices:
-                        return True
+                    device = UDisks1DriveProperties(
+                        file=str(_device_file),
+                        bus=str(_bus),
+                        speed=int(_speed),
+                        model=str(_parent_model),
+                        vendor=str(_parent_vendor),
+                        media=str(_parent_media))
+                    existing_devices.append(device)
+
             except dbus.DBusException:
                 pass
 
-        return False
+        return existing_devices
+
+
+def udisks2_objects_delta(old, new):
+    """
+    Compute the delta between two snapshots of udisks2 objects
+
+    The objects are encoded as {s:{s:{s:v}}} where the first dictionary maps
+    from DBus object path to a dictionary that maps from interface name to a
+    dictionary that finally maps from property name to property value.
+
+    The result is a generator of DeltaRecord objects that encodes the changes:
+        * the 'delta_dir' is either DELTA_DIR_PLUS or DELTA_DIR_MINUS
+        * the 'value' is a tuple that differs for interfaces and properties.
+          Interfaces use the format (DELTA_TYPE_IFACE, object_path, iface_name)
+          while properties use the format (DELTA_TYPE_PROP, object_path,
+          iface_name, prop_name, prop_value)
+
+    Interfaces are never "changed", they are only added or removed. Properties
+    can be changed and this is encoded as removal followed by an addition where
+    both differ only by the 'delta_dir' and the last element of the 'value'
+    tuple.
+    """
+    # Traverse all objects, old or new
+    all_object_paths = set()
+    all_object_paths |= old.keys()
+    all_object_paths |= new.keys()
+    for object_path in sorted(all_object_paths):
+        old_object = old.get(object_path, {})
+        new_object = new.get(object_path, {})
+        # Traverse all interfaces of each object, old or new
+        all_iface_names = set()
+        all_iface_names |= old_object.keys()
+        all_iface_names |= new_object.keys()
+        for iface_name in sorted(all_iface_names):
+            if iface_name not in old_object and iface_name in new_object:
+                # Report each ADDED interface
+                assert iface_name in new_object
+                delta_value = InterfaceDelta(
+                    DELTA_TYPE_IFACE, object_path, iface_name)
+                yield DeltaRecord(DELTA_DIR_PLUS, delta_value)
+                # Report all properties ADDED on that interface
+                for prop_name, prop_value in new_object[iface_name].items():
+                    delta_value = PropertyDelta(DELTA_TYPE_PROP, object_path,
+                                                iface_name, prop_name,
+                                                prop_value)
+                    yield DeltaRecord(DELTA_DIR_PLUS, delta_value)
+            elif iface_name not in new_object and iface_name in old_object:
+                # Report each REMOVED interface
+                assert iface_name in old_object
+                delta_value = InterfaceDelta(
+                    DELTA_TYPE_IFACE, object_path, iface_name)
+                yield DeltaRecord(DELTA_DIR_MINUS, delta_value)
+                # Report all properties REMOVED on that interface
+                for prop_name, prop_value in old_object[iface_name].items():
+                    delta_value = PropertyDelta(DELTA_TYPE_PROP, object_path,
+                                                iface_name, prop_name,
+                                                prop_value)
+                    yield DeltaRecord(DELTA_DIR_MINUS, delta_value)
+            else:
+                # Analyze properties of each interface that existed both in old
+                # and new object trees.
+                assert iface_name in new_object
+                assert iface_name in old_object
+                old_props = old_object[iface_name]
+                new_props = new_object[iface_name]
+                all_prop_names = set()
+                all_prop_names |= old_props.keys()
+                all_prop_names |= new_props.keys()
+                # Traverse all properties, old or new
+                for prop_name in sorted(all_prop_names):
+                    if prop_name not in old_props and prop_name in new_props:
+                        # Report each ADDED property
+                        delta_value = PropertyDelta(
+                            DELTA_TYPE_PROP, object_path, iface_name,
+                            prop_name, new_props[prop_name])
+                        yield DeltaRecord(DELTA_DIR_PLUS, delta_value)
+                    elif prop_name not in new_props and prop_name in old_props:
+                        # Report each REMOVED property
+                        delta_value = PropertyDelta(
+                            DELTA_TYPE_PROP, object_path, iface_name,
+                            prop_name, old_props[prop_name])
+                        yield DeltaRecord(DELTA_DIR_MINUS, delta_value)
+                    else:
+                        old_value = old_props[prop_name]
+                        new_value = new_props[prop_name]
+                        if old_value != new_value:
+                            # Report each changed property
+                            yield DeltaRecord(DELTA_DIR_MINUS, PropertyDelta(
+                                DELTA_TYPE_PROP, object_path, iface_name,
+                                prop_name, old_value))
+                            yield DeltaRecord(DELTA_DIR_PLUS, PropertyDelta(
+                                DELTA_TYPE_PROP, object_path, iface_name,
+                                prop_name, new_value))
+
+
+class UDisks2StorageDeviceListener:
+    """
+    Implementation of the storage device listener concept for UDisks2 backend.
+    Loosely modeled on the UDisks-based implementation above.
+
+    Implementation details
+    ^^^^^^^^^^^^^^^^^^^^^^
+
+    The class, once configured reacts to asynchronous events from the event
+    loop. Those are either DBus signals or GLib timeout.
+
+    The timeout, if reached, terminates the test and fails with an appropriate
+    end-user message. The user is expected to manipulate storage devices while
+    the test is running.
+
+    DBus signals (that correspond to UDisks2 DBus signals) cause callbacks into
+    this code. Each time a signal is reported "delta" is computed and verified
+    to determine if there was a successful match. The delta contains a list or
+    DeltaRecord objects that encode difference (either addition or removal) and
+    the value of the difference (interface name or interface property value).
+    This delta is computed by udisks2_objects_delta(). The delta is then passed
+    to _validate_delta() which has a chance to end the test but also prints
+    diagnostic messages in verbose mode. This is very useful for understanding
+    what the test actually sees occurring.
+
+    Insertion/removal detection strategy
+    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    Compared to initial state, the following changes objects need to be
+    detected
+
+    * At least one UDisks2 object with the following _all_ interfaces:
+        * UDisks2.Partition
+            (because we want a partitioned device)
+        * UDisks2.Block
+            (because we want that device to have a block device that users can
+            format)
+            - having IdUsage == 'filesystem'
+            (because it should not be a piece of raid or lvm)
+            - having Size > 0
+            (because it should not be and empty removable storage reader)
+        * UDisks2.Filesystem
+            (because we want to ensure that a filesystem gets mounted)
+            - having MountPoints != []
+            - as a special exception this rule is REMOVED from eSATA and SATA
+              devices as they are not automatically mounted anymore.
+
+    This object must be traceable to an UDisks.Drive object:
+        (because we need the medium to be inserted somewhere)
+            - having ConnectionBus in (desired_connection_buses)
+            - as a special exception this rule is weakened for eSATA because
+              for such devices the ConnectionBus property is empty.
+    """
+
+    # Name of the DBus interface exposed UDisks2 for various drives
+    UDISKS2_DRIVE_INTERFACE = "org.freedesktop.UDisks2.Drive"
+
+    # Name of the DBus property provided by the "Drive" interface above
+    UDISKS2_DRIVE_PROPERTY_CONNECTION_BUS = "ConnectionBus"
+
+    def __init__(self, system_bus, loop, action, devices, minimum_speed,
+                 memorycard):
+        # Store the desired minimum speed of the device in Mbit/s. The argument
+        # is passed as the number of bits per second so let's fix that.
+        self._desired_minimum_speed = minimum_speed / 10 ** 6
+        # Compute the allowed UDisks2.Drive.ConnectionBus value based on the
+        # legacy arguments passed from the command line.
+        self._desired_connection_buses = set([
+            map_udisks1_connection_bus(device) for device in devices])
+        # Check if we are explicitly looking for memory cards
+        self._desired_memory_card = memorycard
+        # Store the desired "delta" direction depending on
+        # whether we test for insertion or removal
+        if action == "insert":
+            self._desired_delta_dir = DELTA_DIR_PLUS
+        elif action == "remove":
+            self._desired_delta_dir = DELTA_DIR_MINUS
+        else:
+            raise ValueError("Unsupported action: {}".format(action))
+        # Store DBus bus object as we need to pass it to UDisks2 observer
+        self._bus = system_bus
+        # Store event loop object
+        self._loop = loop
+        # Setup UDisks2Observer class to track changes published by UDisks2
+        self._udisks2_observer = UDisks2Observer()
+        # Set the initial value of reference_objects.
+        # The actual value is only set once in check()
+        self._reference_objects = None
+        # As above, just initializing in init for sake of consistency
+        self._is_reference = None
+        # Setup UDisks2Model to know what the current state is. This is needed
+        # when remove events are reported as they don't carry enough state for
+        # the program to work correctly. Since UDisks2Model only applies the
+        # changes _after_ processing the signals from UDisks2Observer we can
+        # reliably check all of the properties of the removed object / device.
+        self._udisks2_model = UDisks2Model(self._udisks2_observer)
+        # Whenever anything changes call our local change handler
+        # This handler always computes the full delta (versus the
+        # reference state) and decides if we have a match or not
+        self._udisks2_model.on_change.connect(self._on_change)
+        # We may need an udev context for checking the speed of USB devices
+        self._udev_client = GUdev.Client()
+        # A snapshot of udev devices, set in check()
+        self._reference_udev_devices = None
+        # Assume the test passes, this is changed when timeout expires or when
+        # an incorrect device gets inserted.
+        self._error = False
+
+    def _dump_reference_udisks_objects(self):
+        logging.debug("Reference UDisks2 objects:")
+        for udisks2_object in self._reference_objects:
+            logging.debug(" - %s", udisks2_object)
+
+    def _dump_reference_udev_devices(self):
+        logging.debug("Reference udev devices:")
+        for udev_device in self._reference_udev_devices:
+            interconnect_speed = get_interconnect_speed(udev_device)
+            if interconnect_speed:
+                logging.debug(" - %s (USB %dMBit/s)",
+                              udev_device.get_device_file(),
+                              interconnect_speed)
+            else:
+                logging.debug(" - %s", udev_device.get_device_file())
+
+    def check(self, timeout):
+        """
+        Run the configured test and return the result
+
+        The result is False if the test has failed.  The timeout, when
+        non-zero, will make the test fail after the specified seconds have
+        elapsed without conclusive result.
+        """
+        # Setup a timeout if requested
+        if timeout > 0:
+            GObject.timeout_add_seconds(timeout, self._on_timeout_expired)
+        # Connect the observer to the bus. This will start giving us events
+        # (actually when the loop starts later below)
+        self._udisks2_observer.connect_to_bus(self._bus)
+        # Get the reference snapshot of available devices
+        self._reference_objects = copy.deepcopy(self._current_objects)
+        self._dump_reference_udisks_objects()
+        # Mark the current _reference_objects as ... reference, this is sadly
+        # needed by _summarize_changes() as it sees the snapshot _after_ a
+        # change has occurred and cannot determine if the slope of the 'edge'
+        # of the change. It is purely needed for UI in verbose mode
+        self._is_reference = True
+        # A collection of objects that we gladly ignore because we already
+        # reported on them being somehow inappropriate
+        self._ignored_objects = set()
+        # Get the reference snapshot of available udev devices
+        self._reference_udev_devices = get_udev_block_devices(
+            self._udev_client)
+        self._dump_reference_udev_devices()
+        # Start the loop and wait. The loop will exit either when:
+        # 1) A proper device has been detected (either insertion or removal)
+        # 2) A timeout (optional) has expired
+        self._loop.run()
+        # Return the outcome of the test
+        return self._error
+
+    def _on_timeout_expired(self):
+        """
+        Internal function called when the timer expires.
+
+        Basically it's just here to tell the user the test failed or that the
+        user was unable to alter the device during the allowed time.
+        """
+        print("You have failed to perform the required manipulation in time")
+        # Fail the test when the timeout was reached
+        self._error = True
+        # Stop the loop now
+        self._loop.quit()
+
+    def _on_change(self):
+        """
+        Internal method called by UDisks2Model whenever a change had occurred
+        """
+        # Compute the changes that had occurred since the reference point
+        delta_records = list(self._get_delta_records())
+        # Display a summary of changes when we are done
+        self._summarize_changes(delta_records)
+        # If the changes are what we wanted stop the loop
+        matching_devices = self._get_matching_devices(delta_records)
+        if matching_devices:
+            print("Expected device manipulation complete: {}".format(
+                ', '.join(matching_devices)))
+            # And call it a day
+            self._loop.quit()
+
+    def _get_matching_devices(self, delta_records):
+        """
+        Internal method called that checks if the delta records match the type
+        of device manipulation we were expecting. Only called from _on_change()
+
+        Returns a set of paths of block devices that matched
+        """
+        # Results
+        results = set()
+        # Group changes by DBus object path
+        grouped_records = collections.defaultdict(list)
+        for record in delta_records:
+            grouped_records[record.value.object_path].append(record)
+        # Create another snapshot od udev devices so that we don't do it over
+        # and over in the loop below (besides, if we did that then results
+        # could differ each time).
+        current_udev_devices = get_udev_block_devices(self._udev_client)
+        # Iterate over all UDisks2 objects and their delta records
+        for object_path, records_for_object in grouped_records.items():
+            # Skip objects we already ignored and complained about before
+            if object_path in self._ignored_objects:
+                continue
+            needs = set(('block-fs', 'partition', 'non-empty', 'mounted'))
+            # As a special exception when the ConnectionBus is allowed to be
+            # empty, as is the case with eSATA devices, do not require the
+            # filesystem to be mounted as gvfs may choose not to mount it
+            # automatically.
+            if "" in self._desired_connection_buses:
+                needs.remove('mounted')
+            found = set()
+            drive_object_path = None
+            object_block_device = None
+            for record in records_for_object:
+                # Skip changes opposite to the ones we need
+                if record.delta_dir != self._desired_delta_dir:
+                    continue
+                # Detect block devices designated for filesystems
+                if (record.value.iface_name ==
+                    "org.freedesktop.UDisks2.Block"
+                    and record.value.delta_type == DELTA_TYPE_PROP
+                    and record.value.prop_name == "IdUsage"
+                    and record.value.prop_value == "filesystem"):
+                    found.add('block-fs')
+                # Memorize the block device path
+                elif (record.value.iface_name ==
+                    "org.freedesktop.UDisks2.Block"
+                    and record.value.delta_type == DELTA_TYPE_PROP
+                    and record.value.prop_name == "PreferredDevice"):
+                    object_block_device = record.value.prop_value
+                # Ensure the device is a partition
+                elif (record.value.iface_name ==
+                      "org.freedesktop.UDisks2.Partition"
+                      and record.value.delta_type == DELTA_TYPE_IFACE):
+                    found.add('partition')
+                # Ensure the device is not empty
+                elif (record.value.iface_name ==
+                      "org.freedesktop.UDisks2.Block"
+                      and record.value.delta_type == DELTA_TYPE_PROP
+                      and record.value.prop_name == "Size"
+                      and record.value.prop_value > 0):
+                    found.add('non-empty')
+                # Ensure the filesystem is mounted
+                elif (record.value.iface_name ==
+                      "org.freedesktop.UDisks2.Filesystem"
+                      and record.value.delta_type == DELTA_TYPE_PROP
+                      and record.value.prop_name == "MountPoints"
+                      and record.value.prop_value != []):
+                    found.add('mounted')
+                # Finally memorize the drive the block device belongs to
+                elif (record.value.iface_name ==
+                      "org.freedesktop.UDisks2.Block"
+                      and record.value.delta_type == DELTA_TYPE_PROP
+                      and record.value.prop_name == "Drive"):
+                    drive_object_path = record.value.prop_value
+            logging.debug("Finished analyzing %s, found: %s,"
+                          " drive_object_path: %s", object_path, found,
+                          drive_object_path)
+            if needs != found or drive_object_path is None:
+                continue
+            # We've found our candidate, let's look at the drive it belongs
+            # to. We need to do this as some properties are associated with
+            # the drive, not the filesystem/block device and the drive may
+            # not have been inserted at all.
+            try:
+                drive_object = self._current_objects[drive_object_path]
+            except KeyError:
+                # The drive may be removed along with the device, let's check
+                # if we originally saw it
+                try:
+                    drive_object = self._reference_objects[drive_object_path]
+                except KeyError:
+                    logging.error(
+                        "A block device belongs to a drive we could not find")
+                    logging.error("missing drive: %r", drive_object_path)
+                    continue
+            try:
+                drive_props = drive_object["org.freedesktop.UDisks2.Drive"]
+            except KeyError:
+                logging.error(
+                    "A block device belongs to an object that is not a Drive")
+                logging.error("strange object: %r", drive_object_path)
+                continue
+            # Ensure the drive is on the appropriate bus
+            connection_bus = drive_props["ConnectionBus"]
+            if connection_bus not in self._desired_connection_buses:
+                logging.warning("The object %r belongs to drive %r that"
+                                " is attached to the bus %r but but we are"
+                                " looking for one of %r so it cannot match",
+                                object_block_device, drive_object_path,
+                                connection_bus,
+                                ", ".join(self._desired_connection_buses))
+                # Ignore this object so that we don't spam the user twice
+                self._ignored_objects.add(object_path)
+                continue
+            # Ensure it is a media card reader if this was explicitly requested
+            drive_is_reader = is_memory_card(
+                drive_props['Vendor'], drive_props['Model'],
+                drive_props['Media'])
+            if self._desired_memory_card and not drive_is_reader:
+                logging.warning(
+                    "The object %s belongs to drive %s that does not seem to"
+                    " be a media reader", object_block_device,
+                    drive_object_path)
+                # Ignore this object so that we don't spam the user twice
+                self._ignored_objects.add(object_path)
+                continue
+            # Ensure the desired minimum speed is enforced
+            if self._desired_minimum_speed:
+                # We need to discover the speed of the UDisks2 object that is
+                # about to be matched. Sadly UDisks2 no longer supports this
+                # property so we need to poke deeper and resort to udev.
+                #
+                # The UDisks2 object that we are interested in implements a
+                # number of interfaces, most notably
+                # org.freedesktop.UDisks2.Block, that has the Device property
+                # holding the unix filesystem path (like /dev/sdb1). We already
+                # hold a reference to that as 'object_block_device'
+                #
+                # We take this as a start and attempt to locate the udev Device
+                # (don't confuse with UDisks2.Device, they are _not_ the same)
+                # that is associated with that path.
+                if self._desired_delta_dir == DELTA_DIR_PLUS:
+                    # If we are looking for additions then look at _current_
+                    # collection of udev devices
+                    udev_devices = current_udev_devices
+                    udisks2_object = self._current_objects[object_path]
+                else:
+                    # If we are looking for removals then look at referece
+                    # collection of udev devices
+                    udev_devices = self._reference_udev_devices
+                    udisks2_object = self._reference_objects[object_path]
+                try:
+                    # Try to locate the corresponding udev device among the
+                    # collection we've selected. Use the drive object as the
+                    # key -- this looks for the drive, not partition objects!
+                    udev_device = lookup_udev_device(udisks2_object,
+                                                     udev_devices)
+                except LookupError:
+                    logging.error("Unable to map UDisks2 object %s to udev",
+                                  object_block_device)
+                    # Ignore this object so that we don't spam the user twice
+                    self._ignored_objects.add(object_path)
+                    continue
+                interconnect_speed = get_interconnect_speed(udev_device)
+                # Now that we know the speed of the interconnect we can try to
+                # validate it against our desired speed.
+                if interconnect_speed is None:
+                    logging.warning("Unable to determine interconnect speed of"
+                                    " device %s", object_block_device)
+                    # Ignore this object so that we don't spam the user twice
+                    self._ignored_objects.add(object_path)
+                    continue
+                elif interconnect_speed < self._desired_minimum_speed:
+                    logging.warning(
+                        "Device %s is connected via an interconnect that has"
+                        " the speed of %dMbit/s but the required speed was"
+                        " %dMbit/s", object_block_device, interconnect_speed,
+                        self._desired_minimum_speed)
+                    # Ignore this object so that we don't spam the user twice
+                    self._ignored_objects.add(object_path)
+                    continue
+                else:
+                    logging.info("Device %s is connected via an USB"
+                                 " interconnect with the speed of %dMbit/s",
+                                 object_block_device, interconnect_speed)
+            # Yay, success
+            results.add(object_block_device)
+        return results
+
+    @property
+    def _current_objects(self):
+        return self._udisks2_model.managed_objects
+
+    def _get_delta_records(self):
+        """
+        Internal method used to compute the delta between reference devices and
+        current devices. The result is a generator of DeltaRecord objects.
+        """
+        assert self._reference_objects is not None, "Only usable after check()"
+        old = self._reference_objects
+        new = self._current_objects
+        return udisks2_objects_delta(old, new)
+
+    def _summarize_changes(self, delta_records):
+        """
+        Internal method used to summarize changes (compared to reference state)
+        called whenever _on_change() gets called. Only visible in verbose mode
+        """
+        # Filter out anything but interface changes
+        flat_records = [record
+                        for record in delta_records
+                        if record.value.delta_type == DELTA_TYPE_IFACE]
+        # Group changes by DBus object path
+        grouped_records = collections.defaultdict(list)
+        for record in flat_records:
+            grouped_records[record.value.object_path].append(record)
+        # Bail out quickly when nothing got changed
+        if not flat_records:
+            if not self._is_reference:
+                logging.info("You have returned to the reference state")
+                self._is_reference = True
+            return
+        else:
+            self._is_reference = False
+        # Iterate over grouped delta records for all objects
+        logging.info("Compared to the reference state you have:")
+        for object_path in sorted(grouped_records.keys()):
+            records_for_object = sorted(
+                grouped_records[object_path],
+                key=lambda record: record.value.iface_name)
+            # Skip any job objects as they just add noise
+            if any((record.value.iface_name == "org.freedesktop.UDisks2.Job"
+                    for record in records_for_object)):
+                continue
+            logging.info("For object %s", object_path)
+            for record in records_for_object:
+                # Ignore property changes for now
+                if record.value.delta_type != DELTA_TYPE_IFACE:
+                    continue
+                # Get the name of the interface that was affected
+                iface_name = record.value.iface_name
+                # Get the properties for that interface (for removals get the
+                # reference values, for additions get the current values)
+                if record.delta_dir == DELTA_DIR_PLUS:
+                    props = self._current_objects[object_path][iface_name]
+                    action = "inserted"
+                else:
+                    props = self._reference_objects[object_path][iface_name]
+                    action = "removed"
+                # Display some human-readable information associated with each
+                # interface change
+                if iface_name == "org.freedesktop.UDisks2.Drive":
+                    logging.info("\t * %s a drive", action)
+                    logging.info("\t   vendor and name: %r %r",
+                                 props['Vendor'], props['Model'])
+                    logging.info("\t   bus: %s", props['ConnectionBus'])
+                    logging.info("\t   size: %s", format_bytes(props['Size']))
+                    logging.info("\t   is media card: %s", is_memory_card(
+                        props['Vendor'], props['Model'], props['Media']))
+                    logging.info("\t   current media: %s",
+                                 props['Media'] or "???" if
+                                 props['MediaAvailable'] else "N/A")
+                elif iface_name == "org.freedesktop.UDisks2.Block":
+                    logging.info("\t * %s block device", action)
+                    logging.info("\t   from drive: %s", props['Drive'])
+                    logging.info("\t   having device: %s", props['Device'])
+                    logging.info("\t   having usage, type and version:"
+                                 " %s %s %s", props['IdUsage'],
+                                 props['IdType'], props['IdVersion'])
+                    logging.info("\t   having label: %s", props['IdLabel'])
+                elif iface_name == "org.freedesktop.UDisks2.PartitionTable":
+                    logging.info("\t * %s partition table", action)
+                    logging.info("\t   having type: %r", props['Type'])
+                elif iface_name == "org.freedesktop.UDisks2.Partition":
+                    logging.info("\t * %s partition", action)
+                    logging.info("\t   from partition table: %s",
+                                 props['Table'])
+                    logging.info("\t   having size: %s",
+                                 format_bytes(props['Size']))
+                    logging.info("\t   having name: %r", props['Name'])
+                elif iface_name == "org.freedesktop.UDisks2.Filesystem":
+                    logging.info("\t * %s file system", action)
+                    logging.info("\t   having mount points: %r",
+                                 props['MountPoints'])
 
 
 def main():
     description = "Wait for the specified device to be inserted or removed."
     parser = argparse.ArgumentParser(description=description)
     parser.add_argument('action', choices=['insert', 'remove'])
-    parser.add_argument('device', 
-                        choices=['usb', 'sdio', 'firewire', 
-                        'scsi', 'ata_serial_esata'],
-                        nargs=argparse.REMAINDER)
+    parser.add_argument('device', choices=['usb', 'sdio', 'firewire', 'scsi',
+                                 'ata_serial_esata'], nargs="+")
+    memorycard_help = ("Memory cards devices on bus other than sdio require "
+                       "this parameter to identify them as such")
+    parser.add_argument('--memorycard', action="store_true",
+                        help=memorycard_help)
     parser.add_argument('--timeout', type=int, default=20)
+    min_speed_help = ("Will only accept a device if its connection speed "
+                      "attribute is higher than this value "
+                      "(in bits/s)")
+    parser.add_argument('--minimum_speed', '-m', help=min_speed_help,
+                        type=int, default=0)
+    parser.add_argument('--verbose', action='store_const', const=logging.INFO,
+                        dest='logging_level', help="Enable verbose output")
+    parser.add_argument('--debug', action='store_const', const=logging.DEBUG,
+                        dest='logging_level', help="Enable debugging")
+    parser.set_defaults(logging_level=logging.WARNING)
     args = parser.parse_args()
 
-    listener = StorageDeviceListener(args.action, args.device)
-    return(listener.check(args.timeout))
+    # Configure logging as requested
+    # XXX: This may be incorrect as logging.basicConfig() fails after any other
+    # call to logging.log(). The proper solution is to setup a verbose logging
+    # configuration and I didn't want to do it now.
+    logging.basicConfig(
+        level=args.logging_level,
+        format='[%(asctime)s] %(levelname)s:%(name)s:%(message)s')
+
+    # Connect to the system bus, we also get the event
+    # loop as we need it to start listening for signals.
+    system_bus, loop = connect_to_system_bus()
+
+    # Check if system bus has the UDisks2 object
+    if is_udisks2_supported(system_bus):
+        # Construct the listener with all of the arguments provided on the
+        # command line and the explicit system_bus, loop objects.
+        logging.debug("Using UDisks2 interface")
+        listener = UDisks2StorageDeviceListener(
+            system_bus, loop,
+            args.action, args.device, args.minimum_speed, args.memorycard)
+    else:
+        # Construct the listener with all of the arguments provided on the
+        # command line and the explicit system_bus, loop objects.
+        logging.debug("Using UDisks1 interface")
+        listener = UDisks1StorageDeviceListener(
+            system_bus, loop,
+            args.action, args.device, args.minimum_speed, args.memorycard)
+    # Run the actual listener and wait till it either times out of discovers
+    # the appropriate media changes
+    try:
+        return listener.check(args.timeout)
+    except KeyboardInterrupt:
+        return 1
 
 if __name__ == "__main__":
     sys.exit(main())

=== modified file 'setup.py'
--- setup.py	2012-10-04 02:54:55 +0000
+++ setup.py	2012-10-09 17:53:24 +0000
@@ -233,8 +233,11 @@
         ("share/apport/package-hooks/", ["apport/source_checkbox.py"]),
         ("share/apport/general-hooks/", ["apport/checkbox.py"])],
     scripts = ["bin/checkbox-cli", "bin/checkbox-gtk", "bin/checkbox-urwid", "bin/checkbox-qt"],
-    packages = ["checkbox", "checkbox.contrib", "checkbox.lib", "checkbox.parsers",
-        "checkbox.reports", "checkbox_cli", "checkbox_gtk", "checkbox_urwid", "checkbox_qt"],
+
+     packages=[
+         "checkbox", "checkbox.contrib", "checkbox.dbus", "checkbox.lib",
+         "checkbox.parsers", "checkbox.reports", "checkbox.heuristics",
+         "checkbox_cli", "checkbox_gtk", "checkbox_urwid", "checkbox_qt"],
     package_data = {
         "": ["cputable"]},
     cmdclass = {