Merge lp:~nataliabidart/ubuntuone-control-panel/add-file-sync-status into lp:ubuntuone-control-panel

[Natalia Bidart]

* File sync status is retrieved and displayed in the right top corner (LP: #673670).

 * Adding handling for file sync disabled (only backend for now).

 * Management panel is not twined itself if CredentialsFound signal is received
   several times (LP: #683649).

To test, do the following (you will need to point PYTHONPATH to current's u1client trunk):

in terminal 1:

PYTHONPATH=~/canonical/ubuntuone/client/trunk/:. ./bin/ubuntuone-control-panel-backend

in terminal 2:

PYTHONPATH=~/canonical/ubuntuone/client/trunk/:. ./bin/ubuntuone-control-panel-gtk

You can check in the top right corner how the file sync is updated.

[lp:~nataliabidart/ubuntuone-control-panel/add-file-sync-status]

37. By Natalia Bidart on 2010-12-09

Files sync availability is queried to SyncdaemonTool.

[Roberto Alsina (ralsina)]

I have checked the code and I see nothing wrong with it. Keep in mind that I am not very familiar with the codebase yet, so the second reviewer should be extra careful ;-)

review: Approve

[lp:~nataliabidart/ubuntuone-control-panel/add-file-sync-status]

38. By Natalia Bidart on 2010-12-10

Fixing typo.

[Alejandro J. Cura (alecu)]

Very nice!

review: Approve

=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2010-12-02 16:23:03 +0000
+++ ubuntuone/controlpanel/backend.py	2010-12-10 15:05:12 +0000
@@ -22,8 +22,12 @@
 from twisted.internet.defer import inlineCallbacks, returnValue
 
 from ubuntuone.controlpanel import dbus_client
+from ubuntuone.controlpanel.logger import setup_logging, log_call
 from ubuntuone.controlpanel.webclient import WebClient
 
+
+logger = setup_logging('backend')
+
 ACCOUNT_API = "account/"
 QUOTA_API = "quota/"
 DEVICES_API = "1.0/devices/"
@@ -33,6 +37,17 @@
 UPLOAD_KEY = "max_upload_speed"
 DOWNLOAD_KEY = "max_download_speed"
 
+FILE_SYNC_DISABLED = 'file-sync-disabled'
+FILE_SYNC_DISCONNECTED = 'file-sync-disconnected'
+FILE_SYNC_ERROR = 'file-sync-error'
+FILE_SYNC_IDLE = 'file-sync-idle'
+FILE_SYNC_STARTING = 'file-sync-starting'
+FILE_SYNC_SYNCING = 'file-sync-syncing'
+FILE_SYNC_UNKNOWN = 'file-sync-unknown'
+
+MSG_KEY = 'message'
+STATUS_KEY = 'status'
+
 
 class ControlBackend(object):
     """The control panel backend."""
@@ -40,6 +55,68 @@
     def __init__(self):
         """Initialize the webclient."""
         self.wc = WebClient(dbus_client.get_credentials)
+        self._status_changed_handler = None
+        self.status_changed_handler = lambda *a: None
+
+    def _process_file_sync_status(self, status):
+        """Process raw file sync status into custom format.
+
+        Return a dictionary with two members:
+        * STATUS_KEY: the current status of syncdaemon, can be one of:
+            FILE_SYNC_DISABLED, FILE_SYNC_STARTING, FILE_SYNC_DISCONNECTED,
+            FILE_SYNC_SYNCING, FILE_SYNC_IDLE, FILE_SYNC_ERROR,
+            FILE_SYNC_UNKNOWN
+        * MSG_KEY: a non translatable but human readable string of the status.
+
+        """
+        if not status:
+            return {MSG_KEY: '', STATUS_KEY: FILE_SYNC_DISABLED}
+
+        msg = '%s (%s)' % (status['description'], status['name'])
+        result = {MSG_KEY: msg}
+
+        # file synch is enabled
+        is_error = bool(status['is_error'])
+        is_synching = bool(status['is_connected'])
+        is_idle = bool(status['is_online']) and status['queues'] == 'IDLE'
+        is_disconnected = status['name'] == 'READY' and \
+                          'Not User' in status['connection']
+        is_starting = status['name'] in ('INIT', 'LOCAL_RESCAN', 'READY')
+
+        if is_error:
+            result[STATUS_KEY] = FILE_SYNC_ERROR
+        elif is_idle:
+            result[STATUS_KEY] = FILE_SYNC_IDLE
+        elif is_synching:
+            result[STATUS_KEY] = FILE_SYNC_SYNCING
+        elif is_disconnected:
+            result[STATUS_KEY] = FILE_SYNC_DISCONNECTED
+        elif is_starting:
+            result[STATUS_KEY] = FILE_SYNC_STARTING
+        else:
+            logger.warning('file_sync_status: unknown (got %r)', status)
+            result[STATUS_KEY] = FILE_SYNC_UNKNOWN
+
+        return result
+
+    def _set_status_changed_handler(self, handler):
+        """Set 'handler' to be called when file sync status changes."""
+        logger.debug('setting status_changed_handler to %r', handler)
+
+        def process_and_callback(status):
+            """Process syncdaemon's status and callback 'handler'."""
+            result = self._process_file_sync_status(status)
+            handler(result)
+
+        self._status_changed_handler = process_and_callback
+        dbus_client.set_status_changed_handler(process_and_callback)
+
+    def _get_status_changed_handler(self, handler):
+        """Return the handler to be called when file sync status changes."""
+        return self._status_changed_handler
+
+    status_changed_handler = property(_get_status_changed_handler,
+                                      _set_status_changed_handler)
 
     @inlineCallbacks
     def get_token(self):
@@ -145,10 +222,16 @@
         yield self.wc.call_api(api)
         returnValue(device_id)
 
+    @log_call(logger.info)
+    @inlineCallbacks
     def file_sync_status(self):
         """Return the status of the file sync service."""
-        # still pending (LP: #673670)
-        returnValue((True, "Synchronizing"))
+        enabled = yield dbus_client.files_sync_enabled()
+        if enabled:
+            status = yield dbus_client.get_current_status()
+        else:
+            status = {}
+        returnValue(self._process_file_sync_status(status))
 
     @inlineCallbacks
     def volumes_info(self):

=== modified file 'ubuntuone/controlpanel/dbus_client.py'
--- ubuntuone/controlpanel/dbus_client.py	2010-12-02 16:35:31 +0000
+++ ubuntuone/controlpanel/dbus_client.py	2010-12-10 15:05:12 +0000
@@ -25,7 +25,8 @@
 from twisted.internet import defer
 
 from ubuntuone.clientdefs import APP_NAME
-from ubuntuone.syncdaemon import dbus_interface as sd_dbus_iface
+from ubuntuone.platform.linux import dbus_interface as sd_dbus_iface
+from ubuntuone.platform.linux.tools import SyncDaemonTool
 
 from ubuntuone.controlpanel.logger import setup_logging
 
@@ -106,6 +107,12 @@
                                 sd_dbus_iface.DBUS_IFACE_FOLDERS_NAME)
 
 
+def get_status_syncdaemon_proxy():
+    """Get a DBus proxy for syncdaemon status calls."""
+    return get_syncdaemon_proxy("/status",
+                                sd_dbus_iface.DBUS_IFACE_STATUS_NAME)
+
+
 def get_throttling_limits():
     """Get the speed limits from the syncdaemon."""
     d = defer.Deferred()
@@ -183,3 +190,30 @@
 
     d.addBoth(cleanup_signals)
     return d
+
+
+def get_current_status():
+    """Retrieve the current status from syncdaemon."""
+    d = defer.Deferred()
+    proxy = get_status_syncdaemon_proxy()
+    proxy.current_status(reply_handler=d.callback, error_handler=d.errback)
+    return d
+
+
+def set_status_changed_handler(handler):
+    """Connect 'handler' with syncdaemon's StatusChanged signal."""
+    proxy = get_status_syncdaemon_proxy()
+    sig = proxy.connect_to_signal('StatusChanged', handler)
+    return proxy, sig
+
+
+def files_sync_enabled():
+    """Get if file sync service is enabled."""
+    enabled = SyncDaemonTool(bus=None).is_files_sync_enabled()
+    return defer.succeed(enabled)
+
+
[e-mail]
+def set_files_sync_enabled(enabled):
+    """Set the file sync service to be 'enabled'."""
+    yield SyncDaemonTool(bus=dbus.SessionBus()).enable_files_sync(enabled)

=== modified file 'ubuntuone/controlpanel/dbus_service.py'
--- ubuntuone/controlpanel/dbus_service.py	2010-12-02 16:35:31 +0000
+++ ubuntuone/controlpanel/dbus_service.py	2010-12-10 15:05:12 +0000
@@ -28,9 +28,15 @@
 from twisted.python.failure import Failure
 
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
-    DBUS_PREFERENCES_IFACE, utils)
-from ubuntuone.controlpanel.backend import ControlBackend
-from ubuntuone.controlpanel.logger import setup_logging
+    DBUS_PREFERENCES_IFACE)
+from ubuntuone.controlpanel.backend import (
+    ControlBackend, FILE_SYNC_DISABLED, FILE_SYNC_DISCONNECTED,
+    FILE_SYNC_ERROR, FILE_SYNC_IDLE, FILE_SYNC_STARTING, FILE_SYNC_SYNCING,
+    MSG_KEY, STATUS_KEY,
+)
+from ubuntuone.controlpanel.logger import setup_logging, log_call
+from ubuntuone.controlpanel.utils import (ERROR_TYPE, ERROR_MESSAGE,
+    failure_to_error_dict, exception_to_error_dict)
 
 
 logger = setup_logging('dbus_service')
@@ -55,15 +61,15 @@
     """
     result = {}
     if isinstance(error, Failure):
-        result = utils.failure_to_error_dict(error)
+        result = failure_to_error_dict(error)
     elif isinstance(error, Exception):
-        result = utils.exception_to_error_dict(error)
+        result = exception_to_error_dict(error)
     elif isinstance(error, dict):
         # ensure that both keys and values are unicodes
         result = dict(map(make_unicode, i) for i in error.iteritems())
     else:
         msg = 'Got unexpected error argument %r' % error
-        result = {utils.ERROR_TYPE: 'UnknownError', utils.ERROR_MESSAGE: msg}
+        result = {ERROR_TYPE: 'UnknownError', ERROR_MESSAGE: msg}
 
     return result
 
@@ -89,7 +95,10 @@
         """Create this instance of the backend."""
         super(ControlPanelBackend, self).__init__(*args, **kwargs)
         self.backend = backend
-        logger.debug('ControlPanelBackend created with %r, %r', args, kwargs)
+        self.backend.status_changed_handler = self.process_status
+        logger.debug('ControlPanelBackend: created with %r, %r.\n'
+                     'status_changed_handler is %r.',
+                     args, kwargs, self.process_status)
 
     # pylint: disable=C0103
 
@@ -161,17 +170,62 @@
 
     #---
 
+    def process_status(self, status_dict):
+        """Match status with signals."""
+        logger.info('process_status: new status received %r', status_dict)
+        status = status_dict[STATUS_KEY]
+        msg = status_dict[MSG_KEY]
+        if status == FILE_SYNC_DISABLED:
+            self.FileSyncStatusDisabled(msg)
+        elif status == FILE_SYNC_STARTING:
+            self.FileSyncStatusStarting(msg)
+        elif status == FILE_SYNC_DISCONNECTED:
+            self.FileSyncStatusDisconnected(msg)
+        elif status == FILE_SYNC_SYNCING:
+            self.FileSyncStatusSyncing(msg)
+        elif status == FILE_SYNC_IDLE:
+            self.FileSyncStatusIdle(msg)
+        elif status == FILE_SYNC_ERROR:
+            error_dict = {ERROR_TYPE: 'FileSyncStatusError',
+                          ERROR_MESSAGE: msg}
+            self.FileSyncStatusError(error_dict)
+        else:
+            self.FileSyncStatusError(error_handler(status_dict))
+
+    @log_call(logger.info)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def file_sync_status(self):
         """Get the status of the file sync service."""
         d = self.backend.file_sync_status()
-        d.addCallback(lambda args: self.FileSyncStatusReady(*args))
+        d.addCallback(self.process_status)
         d.addErrback(transform_failure(self.FileSyncStatusError))
 
-    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="bs")
-    def FileSyncStatusReady(self, enabled, status):
-        """The new file sync status is available."""
-
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusDisabled(self, msg):
+        """The file sync status is disabled."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusStarting(self, msg):
+        """The file sync service is starting."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusDisconnected(self, msg):
+        """The file sync service is waiting for user to request connection."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusSyncing(self, msg):
+        """The file sync service is currently syncing."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusIdle(self, msg):
+        """The file sync service is idle."""
+
+    @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def FileSyncStatusError(self, error):
         """Problem getting the file sync status."""
@@ -185,12 +239,12 @@
         d.addCallback(self.VolumesInfoReady)
         d.addErrback(transform_failure(self.VolumesInfoError))
 
-    @utils.log_call(logger.info)
+    @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="aa{ss}")
     def VolumesInfoReady(self, info):
         """The info for the volumes is available right now."""
 
-    @utils.log_call(logger.error)
+    @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def VolumesInfoError(self, error):
         """The info for the volumes is currently unavailable."""

=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2010-12-01 12:51:55 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2010-12-10 15:05:12 +0000
@@ -46,8 +46,8 @@
 
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
     DBUS_PREFERENCES_IFACE)
-from ubuntuone.controlpanel.logger import setup_logging
-from ubuntuone.controlpanel.utils import get_data_file, log_call
+from ubuntuone.controlpanel.logger import setup_logging, log_call
+from ubuntuone.controlpanel.utils import get_data_file
 
 
 logger = setup_logging('gtk.gui')
@@ -188,7 +188,9 @@
 
     def on_show_management_panel(self, *args, **kwargs):
         """Show the netbook (main panel)."""
-        self.add(ManagementPanel())
+        if self.overview in self.get_children():
+            self.remove(self.overview)
+            self.add(ManagementPanel())
 
 
 class UbuntuOneBin(gtk.VBox):
@@ -486,6 +488,16 @@
     """
 
     QUOTA_LABEL = _('%(used)s used of %(total)s (%(percentage).1f%%)')
+    FILE_SYNC_DISABLED = _('File synchronization service is not enabled.')
+    FILE_SYNC_STARTING = _('File synchronization service is starting,\n'
+                           'please wait...')
+    FILE_SYNC_DISCONNECTED = _('File synchronization service is ready,\nplease'
+                               ' connect it to access your personal cloud. ')
+    FILE_SYNC_SYNCING = _('File synchronization service is fully functional,\n'
+                          'performing synchronization now...')
+    FILE_SYNC_IDLE = _('File synchronization service is idle,\n'
+                       'all the files are synchronized.')
+    FILE_SYNC_ERROR = _('File synchronization status can not be retrieved.')
 
     def __init__(self):
         gtk.VBox.__init__(self)
@@ -498,6 +510,19 @@
         self.backend.connect_to_signal('AccountInfoError',
                                        self.on_account_info_error)
 
+        self.backend.connect_to_signal('FileSyncStatusDisabled',
+                                       self.on_file_sync_status_disabled)
+        self.backend.connect_to_signal('FileSyncStatusStarting',
+                                       self.on_file_sync_status_starting)
+        self.backend.connect_to_signal('FileSyncStatusDisconnected',
+                                       self.on_file_sync_status_disconnected)
+        self.backend.connect_to_signal('FileSyncStatusSyncing',
+                                       self.on_file_sync_status_syncing)
+        self.backend.connect_to_signal('FileSyncStatusIdle',
+                                       self.on_file_sync_status_idle)
+        self.backend.connect_to_signal('FileSyncStatusError',
+                                       self.on_file_sync_status_error)
+
         self.header.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(DEFAULT_BG))
         self.quota_label = LabelLoading(LOADING, fg_color=DEFAULT_FG)
         self.status_label = LabelLoading(LOADING, fg_color=DEFAULT_FG)
@@ -521,6 +546,7 @@
             self.notebook.insert_page(getattr(self, tab), position=page_num)
 
         self.backend.account_info()
+        self.backend.file_sync_status()
 
     def _update_quota(self, msg, data=None):
         """Update the quota info."""
@@ -532,6 +558,11 @@
             fraction = data.get('percentage', 0.0) / 100
         self.quota_progressbar.set_fraction(fraction)
 
+    def _update_status(self, msg):
+        """Update the status info."""
+        self.status_label.set_markup(msg)
+        self.status_label.stop()
+
     @log_call(logger.debug)
     def on_account_info_ready(self, info):
         """Backend notifies of account info."""
@@ -546,6 +577,39 @@
         """Backend notifies of an error when fetching account info."""
         self._update_quota(WARNING_MARKUP % self.VALUE_ERROR)
 
+    @log_call(logger.info)
+    def on_file_sync_status_disabled(self, msg):
+        """Backend notifies of file sync status being disabled."""
+        self._update_status(self.FILE_SYNC_DISABLED)
+
+    @log_call(logger.info)
+    def on_file_sync_status_starting(self, msg):
+        """Backend notifies of file sync status being starting."""
+        self._update_status(self.FILE_SYNC_STARTING)
+
+    @log_call(logger.info)
+    def on_file_sync_status_disconnected(self, msg):
+        """Backend notifies of file sync status being ready."""
+        self._update_status(self.FILE_SYNC_DISCONNECTED)
+
+    @log_call(logger.info)
+    def on_file_sync_status_syncing(self, msg):
+        """Backend notifies of file sync status being syncing."""
+        self._update_status(self.FILE_SYNC_SYNCING)
+
+    @log_call(logger.info)
+    def on_file_sync_status_idle(self, msg):
+        """Backend notifies of file sync status being idle."""
+        self._update_status(self.FILE_SYNC_IDLE)
+
+    @log_call(logger.error)
+    def on_file_sync_status_error(self, error_dict=None):
+        """Backend notifies of an error when fetching file sync status."""
+        msg = error_dict.get('error_msg', None)
+        if msg is None:
+            msg = error_dict.get('message', self.VALUE_ERROR)
+        self._update_status(WARNING_MARKUP % msg)
+
 
 gobject.signal_new('credentials-found', OverviewPanel,
                     gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-02 16:23:03 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-10 15:05:12 +0000
@@ -302,6 +302,13 @@
         children = self.ui.get_children()
         self.assertIsInstance(children[-1], gui.ManagementPanel)
 
+    def test_on_show_management_panel_is_idempotent(self):
+        """Only one ManagementPanel is shown."""
+        self.ui.on_show_management_panel()
+        self.ui.on_show_management_panel()
+
+        self.assertEqual(1, len(self.ui.get_children()))
+
 
 class UbuntuOneBinTestCase(BaseTestCase):
     """The test suite for a Ubuntu One panel."""
@@ -842,7 +849,7 @@
 class ManagementPanelAccountTestCase(ManagementPanelTestCase):
     """The test suite for the management panel (account tab)."""
 
-    def test_backend_signals(self):
+    def test_backend_account_signals(self):
         """The proper signals are connected to the backend."""
         self.assertEqual(self.ui.backend._signals['AccountInfoReady'],
                          [self.ui.on_account_info_ready])
@@ -898,3 +905,68 @@
         for widget in (self.ui.quota_label,):
             self.assert_warning_correct(widget, self.ui.VALUE_ERROR)
             self.assertFalse(widget.active)
+
+    def test_backend_file_sync_signals(self):
+        """The proper signals are connected to the backend."""
+        matches = (
+            ('FileSyncStatusDisabled', [self.ui.on_file_sync_status_disabled]),
+            ('FileSyncStatusStarting', [self.ui.on_file_sync_status_starting]),
+            ('FileSyncStatusDisconnected',
+             [self.ui.on_file_sync_status_disconnected]),
+            ('FileSyncStatusSyncing', [self.ui.on_file_sync_status_syncing]),
+            ('FileSyncStatusIdle', [self.ui.on_file_sync_status_idle]),
+            ('FileSyncStatusError', [self.ui.on_file_sync_status_error]),
+        )
+        for sig, handlers in matches:
+            self.assertEqual(self.ui.backend._signals[sig], handlers)
+
+    def test_file_sync_status_is_requested(self):
+        """The file sync status is requested to the backend."""
+        self.assert_backend_called('file_sync_status', ())
+
+    def test_on_file_sync_status_disabled(self):
+        """The file sync is disabled."""
+        self.ui.on_file_sync_status_disabled('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_DISABLED)
+
+    def test_on_file_sync_status_starting(self):
+        """The file sync status is starting."""
+        self.ui.on_file_sync_status_starting('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_STARTING)
+
+    def test_on_file_sync_status_disconnected(self):
+        """The file sync status is disconnected."""
+        self.ui.on_file_sync_status_disconnected('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_DISCONNECTED)
+
+    def test_on_file_sync_status_syncing(self):
+        """The file sync status is syncing."""
+        self.ui.on_file_sync_status_syncing('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_SYNCING)
+
+    def test_on_file_sync_status_idle(self):
+        """The file sync status is idle."""
+        self.ui.on_file_sync_status_idle('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_IDLE)
+
+    def test_on_file_sync_status_error(self):
+        """The file sync status couldn't be retrieved."""
+        self.ui.on_file_sync_status_error({'error_msg': 'error msg'})
+
+        self.assert_warning_correct(self.ui.status_label, 'error msg')
+        self.assertFalse(self.ui.status_label.active)

=== modified file 'ubuntuone/controlpanel/integrationtests/__init__.py'
--- ubuntuone/controlpanel/integrationtests/__init__.py	2010-12-02 16:23:03 +0000
+++ ubuntuone/controlpanel/integrationtests/__init__.py	2010-12-10 15:05:12 +0000
@@ -43,8 +43,13 @@
     def setUp(self):
         super(DBusClientTestCase, self).setUp()
         self.mock = None
+        self._called = False
         dbus_service.init_mainloop()
 
+    def _set_called(self, *args, **kwargs):
+        """Keep track of function calls, useful for monkeypatching."""
+        self._called = (args, kwargs)
+
     def register_mockserver(self, bus_name, object_path, object_class,
                             **kwargs):
         """The mock service is registered on the DBus."""

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py	2010-12-06 15:03:58 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py	2010-12-10 15:05:12 +0000
@@ -204,13 +204,13 @@
 
 
 class FoldersMockDBusSyncDaemon(sd_dbus_iface.Folders):
-    """A mock object that mimicks syncdaemon regarding the folders iface."""
+    """A mock object that mimicks syncdaemon regarding the Folders iface."""
 
     # __init__ method from a non direct base class 'Object' is called
     # __init__ method from base class 'Folders' is not called
     # pylint: disable=W0231, W0233
 
-    def __init__(self, object_path, conn, vm=None):
+    def __init__(self, object_path, conn):
         self.udfs = {}
         self.udf_id = 1
         dbus.service.Object.__init__(self,
@@ -327,6 +327,25 @@
         self.assertEqual(result, [sd_dbus_iface._get_udf_dict(expected)])
 
     @inlineCallbacks
+    def test_get_folders_error(self):
+        """Handle error when retrieving current syncdaemon status."""
+        path = '~/bar/baz'
+        yield dbus_client.create_volume(path)
+
+        def fail(value):
+            """Fake an error."""
+            raise TestDBusException(value)
+
+        self.patch(sd_dbus_iface, '_get_udf_dict', fail)
+
+        try:
+            yield dbus_client.get_volumes()
+        except dbus.DBusException:
+            pass  # test passes!
+        else:
+            self.fail('dbus_client.get_folders should be errbacking')
+
+    @inlineCallbacks
     def test_create_volume(self):
         """Create a new volume."""
         path = '~/bar/baz'
@@ -342,3 +361,106 @@
             yield dbus_client.create_volume(path='')
         except dbus_client.VolumesError, e:
             self.assertEqual(e[0], {'path': ''})
+
+
+class StatusMockDBusSyncDaemon(dbus.service.Object):
+    """A mock object that mimicks syncdaemon regarding the Status iface."""
+
+    state_dict = {
+        'name': 'TEST',
+        'description': 'Some test state, nothing else.',
+        'is_error': '',
+        'is_connected': 'True',
+        'is_online': '',
+        'queues': 'GORGEOUS',
+        'connection': '',
+    }
+
+    def _get_current_state(self):
+        """Get the current status of the system."""
+        return self.state_dict
+
+    @dbus.service.method(sd_dbus_iface.DBUS_IFACE_STATUS_NAME,
+                         in_signature='', out_signature='a{ss}')
+    def current_status(self):
+        """Return the current faked status of the system."""
+        return self._get_current_state()
+
+    # pylint: disable=C0103
+    # Invalid name "StatusChanged"
+
+    @dbus.service.signal(sd_dbus_iface.DBUS_IFACE_STATUS_NAME)
+    def StatusChanged(self, status):
+        """Fire a signal to notify that the status of the system changed."""
+
+    def emit_status_changed(self, state=None):
+        """Emit StatusChanged."""
+        self.StatusChanged(self._get_current_state())
+
+
+class StatusTestCase(DBusClientTestCase):
+    """Test for the volumes dbus client methods."""
+
+    def setUp(self):
+        super(StatusTestCase, self).setUp()
+        self.register_mockserver(sd_dbus_iface.DBUS_IFACE_NAME,
+                                 "/status", StatusMockDBusSyncDaemon)
+
+    @inlineCallbacks
+    def test_get_current_status(self):
+        """Retrieve current syncdaemon status."""
+        status = yield dbus_client.get_current_status()
+
+        self.assertEqual(StatusMockDBusSyncDaemon.state_dict, status)
+
+    @inlineCallbacks
+    def test_get_current_status_error(self):
+        """Handle error when retrieving current syncdaemon status."""
+
+        def fail(value):
+            """Fake an error."""
+            raise TestDBusException(value)
+
+        self.patch(StatusMockDBusSyncDaemon, '_get_current_state', fail)
+
+        try:
+            yield dbus_client.get_current_status()
+        except dbus.DBusException:
+            pass  # test passes!
+        else:
+            self.fail('dbus_client.get_current_status should be errbacking')
+
+    def test_status_changed(self):
+        """A proper callback can be connected to StatusChanged signal."""
+        _, sig = dbus_client.set_status_changed_handler(self._set_called)
+
+        self.assertEqual(sig._handler, self._set_called)
+        self.assertEqual(sig._member, 'StatusChanged')
+        self.assertEqual(sig._path, '/status')
+        self.assertEqual(sig._interface, sd_dbus_iface.DBUS_IFACE_STATUS_NAME)
+
+
+class FileSyncTestCase(DBusClientTestCase):
+    """Test for the files sync enabled dbus client methods."""
+
+    @inlineCallbacks
+    def test_files_sync_enabled(self):
+        """Retrieve whether file sync is enabled."""
+        expected = object()
+        self.patch(dbus_client.SyncDaemonTool, 'is_files_sync_enabled',
+                   lambda _: expected)
+
+        enabled = yield dbus_client.files_sync_enabled()
+
+        self.assertEqual(expected, enabled)
+
+    @inlineCallbacks
+    def test_set_files_sync_enabled(self):
+        """Set if file sync is enabled or not."""
+        self.patch(dbus_client.SyncDaemonTool, 'enable_files_sync',
+                   self._set_called)
+        expected = object()
+        # set the opposite value
+        yield dbus_client.set_files_sync_enabled(expected)
+
+        self.assertEqual(self._called, ((expected,), {}))

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_service.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2010-12-02 16:35:31 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2010-12-10 15:05:12 +0000
@@ -115,7 +115,13 @@
 
 class MockBackend(object):
     """A mock backend."""
+
     exception = None
+    sample_status = {
+        dbus_service.MSG_KEY: 'test me please',
+        dbus_service.STATUS_KEY: dbus_service.FILE_SYNC_IDLE,
+    }
+    status_changed_handler = None
 
     def _process(self, result):
         """Process the request with the given result."""
@@ -142,7 +148,7 @@
 
     def file_sync_status(self):
         """Return the status of the file sync service."""
-        return self._process((True, "Synchronizing"))
+        return self._process(self.sample_status)
 
     def volumes_info(self):
         """Get the user volumes info."""
@@ -170,6 +176,11 @@
         """Initialize each test run."""
         super(DBusServiceTestCase, self).setUp()
         dbus_service.init_mainloop()
+        self._called = False
+
+    def _set_called(self, *args, **kwargs):
+        """Keep track of function calls, useful for monkeypatching."""
+        self._called = (args, kwargs)
 
     def test_register_service(self):
         """The DBus service is successfully registered."""
@@ -193,7 +204,7 @@
     def test_error_handler_with_failure(self):
         """Ensure to build a string-string dict to pass to error signals."""
         error = dbus_service.Failure(TypeError('oh no!'))
-        expected = dbus_service.utils.failure_to_error_dict(error)
+        expected = dbus_service.failure_to_error_dict(error)
 
         result = dbus_service.error_handler(error)
 
@@ -202,7 +213,7 @@
     def test_error_handler_with_exception(self):
         """Ensure to build a string-string dict to pass to error signals."""
         error = TypeError('oh no, no again!')
-        expected = dbus_service.utils.exception_to_error_dict(error)
+        expected = dbus_service.exception_to_error_dict(error)
 
         result = dbus_service.error_handler(error)
 
@@ -231,8 +242,8 @@
     def test_error_handler_default(self):
         """Ensure to build a string-string dict to pass to error signals."""
         msg = 'Got unexpected error argument %r' % None
-        expected = {dbus_service.utils.ERROR_TYPE: 'UnknownError',
-                    dbus_service.utils.ERROR_MESSAGE: msg}
+        expected = {dbus_service.ERROR_TYPE: 'UnknownError',
+                    dbus_service.ERROR_MESSAGE: msg}
 
         result = dbus_service.error_handler(None)
 
@@ -372,19 +383,6 @@
                 self.backend.remove_device, sample_token)
         return self.assert_correct_method_call(*args)
 
-    def test_file_sync_status(self):
-        """The file sync status is reported."""
-
-        def got_signal(enabled, status):
-            """The correct status was received."""
-            self.assertEqual(enabled, True)
-            self.assertEqual(status, "Synchronizing")
-            self.deferred.callback("success")
-
-        args = ("FileSyncStatusReady", "FileSyncStatusError", got_signal,
-                self.backend.file_sync_status)
-        return self.assert_correct_method_call(*args)
-
     def test_volumes_info(self):
         """The volumes info is reported."""
 
@@ -453,9 +451,79 @@
 
         def got_error_signal(error_dict):
             """The error signal was received."""
-            self.assertEqual(error_dict[dbus_service.utils.ERROR_TYPE],
+            self.assertEqual(error_dict[dbus_service.ERROR_TYPE],
                              'AssertionError')
             self.deferred.callback("success")
 
         return super(OperationsErrorTestCase, self).assert_correct_method_call(
             error_sig, success_sig, got_error_signal, method, *args)
+
+
+class FileSyncTestCase(OperationsTestCase):
+    """Test for the DBus service when requesting file sync status."""
+
+    def assert_correct_status_signal(self, status, sync_signal,
+                                     error_signal="FileSyncStatusError",
+                                     expected_msg=None):
+        """The file sync status is reported properly."""
+        MockBackend.sample_status[dbus_service.STATUS_KEY] = status
+        if expected_msg is None:
+            expected_msg = MockBackend.sample_status[dbus_service.MSG_KEY]
+
+        def got_signal(msg):
+            """The correct status was received."""
+            self.assertEqual(msg, expected_msg)
+            self.deferred.callback("success")
+
+        args = (sync_signal, error_signal, got_signal,
+                self.backend.file_sync_status)
+        return self.assert_correct_method_call(*args)
+
+    def test_file_sync_status_unknown(self):
+        """The file sync status is reported properly."""
+        msg = MockBackend.sample_status
+        args = ('invalid-file-sync-status', "FileSyncStatusError",
+                "FileSyncStatusIdle", msg)
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_error(self):
+        """The file sync status is reported properly."""
+        msg = MockBackend.sample_status[dbus_service.MSG_KEY]
+        err_dict = {dbus_service.ERROR_TYPE: 'FileSyncStatusError',
+                    dbus_service.ERROR_MESSAGE: msg}
+        args = (dbus_service.FILE_SYNC_ERROR, "FileSyncStatusError",
+                "FileSyncStatusIdle", err_dict)
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_disabled(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_DISABLED, "FileSyncStatusDisabled")
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_starting(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_STARTING, "FileSyncStatusStarting")
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_disconnected(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_DISCONNECTED,
+                "FileSyncStatusDisconnected")
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_syncing(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_SYNCING, "FileSyncStatusSyncing")
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_idle(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_IDLE, "FileSyncStatusIdle")
+        return self.assert_correct_status_signal(*args)
+
+    def test_status_changed_handler(self):
+        """The status changed handler is properly set."""
+        be = MockBackend()
+        cpbe = dbus_service.ControlPanelBackend(backend=be)
+
+        self.assertEqual(be.status_changed_handler, cpbe.process_status)

=== modified file 'ubuntuone/controlpanel/logger.py'
--- ubuntuone/controlpanel/logger.py	2010-12-02 16:35:31 +0000
+++ ubuntuone/controlpanel/logger.py	2010-12-10 15:05:12 +0000
@@ -22,6 +22,7 @@
 import os
 import sys
 
+from functools import wraps
 from logging.handlers import RotatingFileHandler
 
 # pylint: disable=F0401,E0611
@@ -41,7 +42,7 @@
 MAIN_HANDLER.setLevel(LOG_LEVEL)
 
 
-def setup_logging(log_domain):
+def setup_logging(log_domain, prefix=None):
     """Create a logger for 'log_domain'.
 
     Final domain will be 'ubuntuone.controlpanel.<log_domain>.
@@ -52,6 +53,28 @@
     logger.addHandler(MAIN_HANDLER)
     if os.environ.get('DEBUG'):
         debug_handler = logging.StreamHandler(sys.stderr)
+        if prefix is not None:
+            fmt = prefix + "%(name)s - %(levelname)s\n%(message)s\n"
+            formatter = logging.Formatter(fmt)
+            debug_handler.setFormatter(formatter)
         logger.addHandler(debug_handler)
 
     return logger
+
+
+def log_call(log_func):
+    """Decorator to add log info using 'log_func'."""
+
+    def middle(f):
+        """Add logging when calling 'f'."""
+
+        @wraps(f)
+        def inner(*args, **kwargs):
+            """Call f(*args, **kwargs)."""
+            log_func('%s: args %r, kwargs %r.', f.__name__, args, kwargs)
+            res = f(*args, **kwargs)
+            return res
+
+        return inner
+
+    return middle

=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2010-12-02 16:23:03 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2010-12-10 15:05:12 +0000
@@ -23,10 +23,21 @@
 
 from twisted.internet import defer
 from twisted.internet.defer import inlineCallbacks
+from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.controlpanel import backend
-from ubuntuone.controlpanel.backend import (ACCOUNT_API, QUOTA_API,
-                                            DEVICES_API, DEVICE_REMOVE_API)
+from ubuntuone.controlpanel.backend import (ACCOUNT_API,
+    DEVICES_API, DEVICE_REMOVE_API, QUOTA_API,
+    FILE_SYNC_DISABLED,
+    FILE_SYNC_DISCONNECTED,
+    FILE_SYNC_ERROR,
+    FILE_SYNC_IDLE,
+    FILE_SYNC_STARTING,
+    FILE_SYNC_SYNCING,
+    FILE_SYNC_UNKNOWN,
+    MSG_KEY, STATUS_KEY,
+)
+
 from ubuntuone.controlpanel.tests import TestCase
 from ubuntuone.controlpanel.webclient import WebClientError
 
@@ -152,6 +163,13 @@
     creds = SAMPLE_CREDENTIALS
     throttling = False
     limits = {"download": -1, "upload": -1}
+    file_sync = True
+    status = {
+        'name': 'TEST', 'queues': 'GORGEOUS', 'connection': '',
+        'description': 'Some test state, nothing else.',
+        'is_error': '', 'is_connected': 'True', 'is_online': '',
+    }
+    status_changed_handler = None
 
     def get_credentials(self):
         """Return the mock credentials."""
@@ -178,10 +196,26 @@
         """Disable bw throttling."""
         self.throttling = False
 
+    def files_sync_enabled(self):
+        """Get if file sync service is enabled."""
+        return self.file_sync
+
+    def set_files_sync_enabled(self, enabled):
+        """Set the file sync service to be 'enabled'."""
+        self.file_sync = enabled
+
     def get_volumes(self):
         """Grab list of folders and shares."""
         return SAMPLE_VOLUMES
 
+    def get_current_status(self):
+        """Grab syncdaemon status."""
+        return MockDBusClient.status
+
+    def set_status_changed_handler(self, handler):
+        """Connect a handler for tracking syncdaemon status changes."""
+        self.status_changed_handler = handler
+
 
 class BackendBasicTestCase(TestCase):
     """Simple tests for the backend."""
@@ -189,11 +223,15 @@
     timeout = 3
 
     def setUp(self):
+        super(BackendBasicTestCase, self).setUp()
         self.patch(backend, "WebClient", MockWebClient)
         self.patch(backend, "dbus_client", MockDBusClient())
         self.local_token = "Computer" + SAMPLE_CREDENTIALS["token"]
         self.be = backend.ControlBackend()
 
+        self.memento = MementoHandler()
+        backend.logger.addHandler(self.memento)
+
     def test_backend_creation(self):
         """The backend instance is successfully created."""
         self.assertEqual(self.be.wc.__class__, MockWebClient)
@@ -314,3 +352,158 @@
         """The volumes_info method exercises its callback."""
         result = yield self.be.volumes_info()
         self.assertEqual(result, SAMPLE_VOLUMES)
+
+
+class BackendSyncStatusTestCase(BackendBasicTestCase):
+    """Syncdaemon state for the backend."""
+
+    def _build_msg(self):
+        """Build expected message regarding file sync status."""
+        return '%s (%s)' % (MockDBusClient.status['description'],
+                            MockDBusClient.status['name'])
+
+    @inlineCallbacks
+    def assert_correct_status(self, status, msg=None):
+        """Check that the resulting status is correct."""
+        expected = {MSG_KEY: self._build_msg() if msg is None else msg,
+                    STATUS_KEY: status}
+        result = yield self.be.file_sync_status()
+        self.assertEqual(expected, result)
+
+    @inlineCallbacks
+    def test_disabled(self):
+        """The syncdaemon status is processed and emitted."""
+        self.patch(MockDBusClient, 'file_sync', False)
+        yield self.assert_correct_status(FILE_SYNC_DISABLED, msg='')
+
+    @inlineCallbacks
+    def test_error(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': 'True',  # nothing else matters
+            'is_online': '', 'is_connected': '',
+            'name': 'AUTH_FAILED', 'connection': '', 'queues': '',
+            'description': 'auth failed',
+        }
+        yield self.assert_correct_status(FILE_SYNC_ERROR)
+
+    @inlineCallbacks
+    def test_starting_when_init_not_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'Not User With Network', 'queues': '',
+            'name': 'INIT', 'description': 'something new',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_starting_when_init_with_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'With User With Network', 'queues': '',
+            'name': 'INIT', 'description': 'something new',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_starting_when_local_rescan_not_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'Not User With Network', 'queues': '',
+            'name': 'LOCAL_RESCAN', 'description': 'something new',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_starting_when_local_rescan_with_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'With User With Network', 'queues': '',
+            'name': 'LOCAL_RESCAN', 'description': 'something new',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_starting_when_ready_with_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'With User With Network', 'queues': '',
+            'name': 'READY', 'description': 'something nicer',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_disconnected(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'queues': '', 'description': 'something new',
+            'connection': 'Not User With Network',  # user didn't connect
+            'name': 'READY',  # must be READY, otherwise is STARTING
+        }
+        yield self.assert_correct_status(FILE_SYNC_DISCONNECTED)
+
+    @inlineCallbacks
+    def test_syncing_if_online(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': 'True', 'is_connected': 'True',
+            'name': 'QUEUE_MANAGER', 'connection': '',
+            'queues': 'WORKING_ON_CONTENT',  # anything but IDLE
+            'description': 'something nicer',
+        }
+        yield self.assert_correct_status(FILE_SYNC_SYNCING)
+
+    @inlineCallbacks
+    def test_syncing_even_if_not_online(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': 'True',
+            'name': 'CHECK_VERSION', 'connection': '',
+            'queues': 'WORKING_ON_CONTENT',
+            'description': 'something nicer',
+        }
+        yield self.assert_correct_status(FILE_SYNC_SYNCING)
+
+    @inlineCallbacks
+    def test_idle(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': 'True', 'is_connected': 'True',
+            'name': 'QUEUE_MANAGER', 'connection': '',
+            'queues': 'IDLE',
+            'description': 'something nice',
+        }
+        yield self.assert_correct_status(FILE_SYNC_IDLE)
+
+    @inlineCallbacks
+    def test_unknown(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'name': '', 'connection': '', 'queues': '',
+            'description': '',
+        }
+        yield self.assert_correct_status(FILE_SYNC_UNKNOWN)
+
+        has_warning = self.memento.check_warning('file_sync_status: unknown',
+                                                 repr(MockDBusClient.status))
+        self.assertTrue(has_warning)
+
+    def test_status_changed(self):
+        """The file_sync_status is the status changed handler."""
+        self.be.status_changed_handler = self._set_called
+        status = {'name': 'foo', 'description': 'bar', 'is_error': '',
+                  'is_connected': '', 'is_online': '', 'queues': ''}
+        # pylint: disable=E1101
+        backend.dbus_client.status_changed_handler(status)
+
+        # pylint: disable=W0212
+        # Access to a protected member _process_file_sync_status
+        expected_status = self.be._process_file_sync_status(status)
+        self.assertEqual(self._called, ((expected_status,), {}))

=== modified file 'ubuntuone/controlpanel/utils.py'
--- ubuntuone/controlpanel/utils.py	2010-12-02 16:35:31 +0000
+++ ubuntuone/controlpanel/utils.py	2010-12-10 15:05:12 +0000
@@ -20,8 +20,6 @@
 
 import os
 
-from functools import wraps
-
 import dbus
 
 from ubuntuone.controlpanel.logger import setup_logging
@@ -68,24 +66,6 @@
     return os.path.join(get_project_dir(), filename)
 
 
-def log_call(log_func):
-    """Decorator to add log info using 'log_func'."""
-
-    def middle(f):
-        """Add logging when calling 'f'."""
-
-        @wraps(f)
-        def inner(*args, **kwargs):
-            """Call f(*args, **kwargs)."""
-            log_func('%s: args %r, kwargs %r.', f.__name__, args, kwargs)
-            res = f(*args, **kwargs)
-            return res
-
-        return inner
-
-    return middle
-
-
 def is_dbus_no_reply(failure):
     """Decide if 'failure' is a DBus NoReply Error."""
     exc = failure.value