Merge lp:~nataliabidart/ubuntu/natty/ubuntuone-control-panel/ubuntuone-control-panel-0.9.5 into lp:ubuntu/natty/ubuntuone-control-panel

[Natalia Bidart]

  * New upstream release:

    [ <email address hidden> ]
      - Now that we set the launcher urgency from ubuntuone-client, the control
      panel needs to remove it when its window receives focus (LP: #747677).
      - changed default value for switch_to to empty string, and now don't call
      switch_to method when the value is empty string (or anything else falsy)
      (LP: #752943).
      - Added proper defaults to the command line arguments (LP: #746489).
      - Fixed issue where closing the panel resulted in a runtime error
      (LP: #745987).
      - This adds a method to the dbus service that allows switching between
      panels, and/or drawing attention to the control panel (LP: #742008).
      - Removed the shortcut group that causes two Ubuntu One entries to appear
      in the messaging menu when syncdaemon is not running (LP: #721525).
    [ Natalia B. Bidart <email address hidden> ]
      - If servers reply with a 401, clear credentials and ask user to
      authenticate (LP: #726612).
      - Moving style_check down so the exit code from u1trial is not hidden by
      && operator.
      - Unify disable/enable file sync functionality among Services tab and
      global file sync status (LP: #729301).
      - Cloud Folders tab is now disabled when the file sync service is
      (LP: #747482).
      - Improving legend for plugin installation to ease translations
      (LP: #746374).
      - Added volumes.ui to the translation list (LP: #746370).
      - Small improvement to show something else besides the generic "Value can
      not be retrieved." error (LP: #722485).
      - Made the backend robust against possible None values (or any non
      basestring instance) sent from the API server (LP: #745790).
      - Decoupled device list retrieved from the web from the local settings
      retrieved from syncdaemon (LP: #720704).
      - Stop the control panel backend once the UI is done
      (LP: #704434).
      - After initial computer adding, syncdameon is asked to connect
      (LP: #715873).

[lp:~nataliabidart/ubuntu/natty/ubuntuone-control-panel/ubuntuone-control-panel-0.9.5]

21. By Natalia Bidart on 2011-04-08

Fixing editor's email address.

=== modified file 'PKG-INFO'
--- PKG-INFO	2011-03-23 20:33:42 +0000
+++ PKG-INFO	2011-04-08 19:43:13 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntuone-control-panel
-Version: 0.9.4
+Version: 0.9.5
 Summary: Ubuntu One Control Panel
 Home-page: https://launchpad.net/ubuntuone-control-panel
 Author: Natalia Bidart
 
=== modified file 'bin/ubuntuone-control-panel-gtk'
--- bin/ubuntuone-control-panel-gtk	2011-03-23 16:06:41 +0000
+++ bin/ubuntuone-control-panel-gtk	2011-04-08 19:43:13 +0000
@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Natalia B Bidart <[e-mail]>
+#          Eric Casteleijn <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -20,20 +21,16 @@
 
 # Invalid name "ubuntuone-control-panel-gtk", pylint: disable=C0103
 
+import gettext
 import sys
 
-import dbus.mainloop.glib
-import gettext
-
 from optparse import OptionParser
 
-from ubuntuone.controlpanel.gtk import DBUS_BUS_NAME, TRANSLATION_DOMAIN
+from ubuntuone.controlpanel.gtk import TRANSLATION_DOMAIN
 
-dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
 gettext.textdomain(TRANSLATION_DOMAIN)
-
 # import the GUI after the translation domain has been set
-from ubuntuone.controlpanel.gtk.gui import ControlPanelWindow
+from ubuntuone.controlpanel.gtk.gui import main
 
 
 def parser_options():
@@ -41,26 +38,17 @@
     usage = "Usage: %prog [option]"
     result = OptionParser(usage=usage)
     result.add_option("", "--switch-to", dest="switch_to", type="string",
-                      metavar="PANEL_NAME",
+                      metavar="PANEL_NAME", default="",
                       help="Start the Ubuntu One Control Panel (GTK) in the "
                            "PANEL_NAME tab. Possible values are: "
                            "dashboard, volumes, devices, applications")
     result.add_option("-a", "--alert", dest="alert", action="store_true",
-                      help="Start the Ubuntu One Control Panel (GTK) alerting "
-                      "the user to its presence.")
+                      default=False, help="Start the Ubuntu One Control Panel "
+                      "(GTK) alerting the user to its presence.")
     return result
 
 
 if __name__ == "__main__":
-    bus = dbus.SessionBus()
-    name = bus.request_name(DBUS_BUS_NAME,
-                            dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
-    if name == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
-        sys.exit(0)
-
-    bus_name = dbus.service.BusName(DBUS_BUS_NAME, bus=dbus.SessionBus())
     parser = parser_options()
     (options, args) = parser.parse_args(sys.argv)
-    gui = ControlPanelWindow(
-        switch_to=options.switch_to, alert=options.alert)
-    gui.main()
+    main(switch_to=options.switch_to, alert=options.alert)
 
=== modified file 'debian/changelog'
--- debian/changelog	2011-03-23 20:44:08 +0000
+++ debian/changelog	2011-04-08 19:43:13 +0000
@@ -1,3 +1,45 @@
+ubuntuone-control-panel (0.9.5-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release:
+
+    [ [e-mail] ]
+      - Now that we set the launcher urgency from ubuntuone-client, the control
+      panel needs to remove it when its window receives focus (LP: #747677).
+      - changed default value for switch_to to empty string, and now don't call
+      switch_to method when the value is empty string (or anything else falsy)
+      (LP: #752943).
+      - Added proper defaults to the command line arguments (LP: #746489).
+      - Fixed issue where closing the panel resulted in a runtime error
+      (LP: #745987).
+      - This adds a method to the dbus service that allows switching between
+      panels, and/or drawing attention to the control panel (LP: #742008).
+      - Removed the shortcut group that causes two Ubuntu One entries to appear
+      in the messaging menu when syncdaemon is not running (LP: #721525).
+    [ Natalia B. Bidart <[e-mail]> ]
+      - If servers reply with a 401, clear credentials and ask user to
+      authenticate (LP: #726612).
+      - Moving style_check down so the exit code from u1trial is not hidden by
+      && operator.
+      - Unify disable/enable file sync functionality among Services tab and
+      global file sync status (LP: #729301).
+      - Cloud Folders tab is now disabled when the file sync service is
+      (LP: #747482).
+      - Improving legend for plugin installation to ease translations
+      (LP: #746374).
+      - Added volumes.ui to the translation list (LP: #746370).
+      - Small improvement to show something else besides the generic "Value can
+      not be retrieved." error (LP: #722485).
+      - Made the backend robust against possible None values (or any non
+      basestring instance) sent from the API server (LP: #745790).
+      - Decoupled device list retrieved from the web from the local settings
+      retrieved from syncdaemon (LP: #720704).
+      - Stop the control panel backend once the UI is done
+      (LP: #704434).
+      - After initial computer adding, syncdameon is asked to connect
+      (LP: #715873).
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Fri, 08 Apr 2011 15:53:02 -0300
+
 ubuntuone-control-panel (0.9.4-0ubuntu1) natty; urgency=low
 
   * New upstream release:
 
=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2011-01-07 20:07:39 +0000
+++ po/POTFILES.in	2011-04-08 19:43:13 +0000
@@ -7,3 +7,4 @@
 [type: gettext/glade] data/management.ui
 [type: gettext/glade] data/overview.ui
 [type: gettext/glade] data/services.ui
+[type: gettext/glade] data/volumes.ui
 
=== modified file 'run-tests'
--- run-tests	2010-12-06 12:27:11 +0000
+++ run-tests	2011-04-08 19:43:13 +0000
@@ -19,19 +19,8 @@
 set -e
 
 if [ $# -ne 0 ]; then
-    # an extra argument was given
-    if [ $1 == "--integration" ]; then
-        # run only integration tests
-        MODULE="ubuntuone/controlpanel/integrationtests"
-    else
-        if [ $1 == "--unittests" ]; then
-            # run only non-integration tests (unittests)
-            MODULE="ubuntuone/controlpanel/tests"
-        else
-            # run specific module given by the caller
-            MODULE="$@"
-        fi
-    fi
+    # run specific module given by the caller
+    MODULE="$@"
 else
     # run all tests, useful for tarmac and reviews
     MODULE="ubuntuone/controlpanel"
@@ -40,12 +29,13 @@
 style_check() {
     pylint ubuntuone/
     if [ -x `which pep8` ]; then
-        pep8 --repeat ubuntuone/
+        pep8 --repeat bin/ $MODULE
     else
         echo "Please install the 'pep8' package."
     fi
 }
 
 echo "Running test suite for ""$MODULE"
-`which xvfb-run` u1trial "$MODULE" && style_check
+`which xvfb-run` u1trial "$MODULE"
+style_check
 rm -rf _trial_temp
 
=== modified file 'setup.py'
--- setup.py	2011-03-23 20:33:42 +0000
+++ setup.py	2011-04-08 19:43:13 +0000
@@ -79,7 +79,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntuone-control-panel',
-    version='0.9.4',
+    version='0.9.5',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',
 
=== modified file 'ubuntuone-control-panel-gtk.desktop.in'
--- ubuntuone-control-panel-gtk.desktop.in	2011-02-23 13:57:42 +0000
+++ ubuntuone-control-panel-gtk.desktop.in	2011-04-08 19:43:13 +0000
@@ -7,10 +7,4 @@
 Type=Application
 Categories=GNOME;GTK;Settings;
 StartupNotify=true
-X-Ayatana-Desktop-Shortcuts=U1
 X-Ayatana-Appmenu-Show-Stubs=False
-
-[U1 Shortcut Group]
-Name=Ubuntu One
-Exec=ubuntuone-control-panel-gtk
-OnlyShowIn=Messaging Menu
 
=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2011-03-10 02:59:44 +0000
+++ ubuntuone/controlpanel/backend.py	2011-04-08 19:43:13 +0000
@@ -20,14 +20,17 @@
 """A backend for the Ubuntu One Control Panel."""
 
 from collections import defaultdict
+from functools import wraps
 
 from twisted.internet.defer import inlineCallbacks, returnValue
 
 from ubuntuone.controlpanel import dbus_client
 from ubuntuone.controlpanel import replication_client
 from ubuntuone.controlpanel.logger import setup_logging, log_call
-from ubuntuone.controlpanel.webclient import WebClient
-
+# pylint: disable=W0611
+from ubuntuone.controlpanel.webclient import (UnauthorizedError,
+    WebClient, WebClientError)
+# pylint: enable=W0611
 
 logger = setup_logging('backend')
 
@@ -61,6 +64,35 @@
     return 'True' if value else ''
 
 
+def filter_field(info, field):
+    """Return a copy of 'info' where each item has 'field' hidden."""
+    result = []
+    for item in info:
+        item = item.copy()
+        item[field] = '<hidden>'
+        result.append(item)
+    return result
+
+
+def process_unauthorized(f):
+    """Decorator to catch UnauthorizedError from the webclient and act upon."""
+
+    @inlineCallbacks
+    @wraps(f)
+    def inner(*args, **kwargs):
+        """Handle UnauthorizedError and clear credentials."""
+        try:
+            result = yield f(*args, **kwargs)
+        except UnauthorizedError, e:
+            logger.exception('process_unauthorized (clearing credentials):')
+            yield dbus_client.clear_credentials()
+            raise e
+
+        returnValue(result)
+
+    return inner
+
+
 class ControlBackend(object):
     """The control panel backend."""
 
@@ -68,14 +100,17 @@
     FOLDER_TYPE = u'UDF'
     SHARE_TYPE = u'SHARE'
     NAME_NOT_SET = u'ENAMENOTSET'
+    STATUS_DISABLED = {MSG_KEY: '', STATUS_KEY: FILE_SYNC_DISABLED}
 
-    def __init__(self):
+    def __init__(self, shutdown_func=None):
         """Initialize the webclient."""
+        self.shutdown_func = shutdown_func
         self.wc = WebClient(dbus_client.get_credentials)
         self._status_changed_handler = None
         self.status_changed_handler = lambda *a: None
 
         self._volumes = {}  # cache last known volume info
+        self.file_sync_disabled = False
 
     def _process_file_sync_status(self, status):
         """Process raw file sync status into custom format.
@@ -89,7 +124,8 @@
 
         """
         if not status:
-            return {MSG_KEY: '', STATUS_KEY: FILE_SYNC_DISABLED}
+            self.file_sync_disabled = True
+            return self.STATUS_DISABLED
 
         msg = '%s (%s)' % (status['description'], status['name'])
         result = {MSG_KEY: msg}
@@ -113,6 +149,7 @@
         elif is_disconnected:
             result[STATUS_KEY] = FILE_SYNC_DISCONNECTED
         elif is_starting:
+            self.file_sync_disabled = False
             result[STATUS_KEY] = FILE_SYNC_STARTING
         elif is_stopped:
             result[STATUS_KEY] = FILE_SYNC_STOPPED
@@ -120,7 +157,10 @@
             logger.warning('file_sync_status: unknown (got %r)', status)
             result[STATUS_KEY] = FILE_SYNC_UNKNOWN
 
-        return result
+        if self.file_sync_disabled:
+            return self.STATUS_DISABLED
+        else:
+            return result
 
     def _set_status_changed_handler(self, handler):
         """Set 'handler' to be called when file sync status changes."""
@@ -142,6 +182,56 @@
                                       _set_status_changed_handler)
 
     @inlineCallbacks
+    def _process_device_web_info(self, devices, enabled, limit_bw, limits,
+                                 show_notifs):
+        """Return a lis of processed devices."""
+        result = []
+        for d in devices:
+            di = {}
+            di["type"] = d["kind"]
+            di["name"] = d["description"]
+            di["configurable"] = ''
+            if di["type"] == DEVICE_TYPE_COMPUTER:
+                di["device_id"] = di["type"] + d["token"]
+            if di["type"] == DEVICE_TYPE_PHONE:
+                di["device_id"] = di["type"] + str(d["id"])
+
+            is_local = yield self.device_is_local(di["device_id"])
+            di["is_local"] = bool_str(is_local)
+            # currently, only local devices are configurable.
+            # eventually, more devices will be configurable.
+            di["configurable"] = bool_str(is_local and enabled)
+
+            if bool(di["configurable"]):
+                di["limit_bandwidth"] = bool_str(limit_bw)
+                di["show_all_notifications"] = bool_str(show_notifs)
+                upload = limits["upload"]
+                download = limits["download"]
+                di[UPLOAD_KEY] = str(upload)
+                di[DOWNLOAD_KEY] = str(download)
+
+            # date_added is not in the webservice yet (LP: #673668)
+            # di["date_added"] = ""
+
+            # missing values (LP: #673668)
+            # di["available_services"] = ""
+            # di["enabled_services"] = ""
+
+            # make a sanity check
+            for key, val in di.iteritems():
+                if not isinstance(val, basestring):
+                    logger.warning('_process_device_web_info: (key %r), '
+                                   'val %r is not a basestring.', key, val)
+                    di[key] = repr(val)
+
+            if is_local:  # prepend the local device!
+                result.insert(0, di)
+            else:
+                result.append(di)
+
+        returnValue(result)
+
+    @inlineCallbacks
     def get_token(self):
         """Return the token from the credentials."""
         credentials = yield dbus_client.get_credentials()
@@ -153,10 +243,10 @@
         dtype, did = self.type_n_id(device_id)
         local_token = yield self.get_token()
         is_local = (dtype == DEVICE_TYPE_COMPUTER and did == local_token)
-        logger.info('device_is_local: result %r, ', is_local)
         returnValue(is_local)
 
     @log_call(logger.debug)
+    @process_unauthorized
     @inlineCallbacks
     def account_info(self):
         """Get the user account info."""
@@ -184,50 +274,55 @@
         returnValue(result)
 
     @log_call(logger.debug)
+    @process_unauthorized
     @inlineCallbacks
     def devices_info(self):
         """Get the user devices info."""
-        result = []
-        limit_bw = yield dbus_client.bandwidth_throttling_enabled()
-        show_all_notif = yield dbus_client.show_all_notifications_enabled()
-        limits = yield dbus_client.get_throttling_limits()
-
-        devices = yield self.wc.call_api(DEVICES_API)
-        for d in devices:
-            di = {}
-            di["type"] = d["kind"]
-            di["name"] = d["description"]
-            di["configurable"] = ''
-            if di["type"] == DEVICE_TYPE_COMPUTER:
-                di["device_id"] = di["type"] + d["token"]
-            if di["type"] == DEVICE_TYPE_PHONE:
-                di["device_id"] = di["type"] + str(d["id"])
-
-            is_local = yield self.device_is_local(di["device_id"])
-            di["is_local"] = bool_str(is_local)
-            # currently, only local devices are configurable.
-            # eventually, more the devices will be configurable.
-            di["configurable"] = bool_str(is_local)
-
-            if bool(di["configurable"]):
-                di["limit_bandwidth"] = bool_str(limit_bw)
-                di["show_all_notifications"] = bool_str(show_all_notif)
+        result = limit_bw = limits = show_notifs = None
+        enabled = yield dbus_client.files_sync_enabled()
+        if enabled:
+            limit_bw = yield dbus_client.bandwidth_throttling_enabled()
+            show_notifs = yield dbus_client.show_all_notifications_enabled()
+            limits = yield dbus_client.get_throttling_limits()
+
+        logger.debug('devices_info: file sync enabled? %s limit_bw %s, limits '
+                     '%s, show_notifs %s',
+                     enabled, limit_bw, limits, show_notifs)
+
+        try:
+            devices = yield self.wc.call_api(DEVICES_API)
+        except UnauthorizedError:
+            raise
+        except WebClientError:
+            logger.exception('devices_info: web client failure:')
+        else:
+            result = yield self._process_device_web_info(devices, enabled,
+                                                         limit_bw, limits,
+                                                         show_notifs)
+        if result is None:
+            logger.info('devices_info: result is None after calling '
+                        'devices/ API, building the local device.')
+            credentials = yield dbus_client.get_credentials()
+            local_device = {}
+            local_device["type"] = DEVICE_TYPE_COMPUTER
+            local_device["name"] = credentials['name']
+            device_id = local_device["type"] + credentials["token"]
+            local_device["device_id"] = device_id
+            local_device["is_local"] = bool_str(True)
+            local_device["configurable"] = bool_str(enabled)
+            if bool(local_device["configurable"]):
+                local_device["limit_bandwidth"] = bool_str(limit_bw)
+                show_notifs = bool_str(show_notifs)
+                local_device["show_all_notifications"] = show_notifs
                 upload = limits["upload"]
                 download = limits["download"]
-                di[UPLOAD_KEY] = str(upload)
-                di[DOWNLOAD_KEY] = str(download)
-
-            # date_added is not in the webservice yet (LP: #673668)
-            # di["date_added"] = ""
-
-            # missing values (LP: #673668)
-            # di["available_services"] = ""
-            # di["enabled_services"] = ""
-
-            if is_local:  # prepend the local device!
-                result.insert(0, di)
-            else:
-                result.append(di)
+                local_device[UPLOAD_KEY] = str(upload)
+                local_device[DOWNLOAD_KEY] = str(download)
+            result = [local_device]
+        else:
+            logger.info('devices_info: result is not None after calling '
+                        'devices/ API: %r',
+                        filter_field(result, field='device_id'))
 
         returnValue(result)
 
@@ -239,7 +334,7 @@
             return DEVICE_TYPE_PHONE, device_id[5:]
         return "No device", device_id
 
-    @log_call(logger.info)
+    @log_call(logger.info, with_args=False)
     @inlineCallbacks
     def change_device_settings(self, device_id, settings):
         """Change the settings for the given device."""
@@ -275,7 +370,8 @@
         # still pending: more work on the settings dict (LP: #673674)
         returnValue(device_id)
 
-    @log_call(logger.warning)
+    @log_call(logger.warning, with_args=False)
+    @process_unauthorized
     @inlineCallbacks
     def remove_device(self, device_id):
         """Remove a device's tokens from the sso server."""
@@ -286,8 +382,8 @@
         yield self.wc.call_api(api)
 
         if is_local:
-            logger.warning('remove_device: device is local, id %r, '
-                           'clearing credentials.', device_id)
+            logger.warning('remove_device: device is local! removing and '
+                           'clearing credentials.')
             yield dbus_client.clear_credentials()
 
         returnValue(device_id)
@@ -308,12 +404,14 @@
     def enable_files(self):
         """Enable the files service."""
         yield dbus_client.set_files_sync_enabled(True)
+        self.file_sync_disabled = False
 
     @log_call(logger.debug)
     @inlineCallbacks
     def disable_files(self):
         """Enable the files service."""
         yield dbus_client.set_files_sync_enabled(False)
+        self.file_sync_disabled = True
 
     @log_call(logger.debug)
     @inlineCallbacks
@@ -478,3 +576,10 @@
         """Install the extension to sync bookmarks."""
         # still pending (LP: #673673)
         returnValue(None)
+
+    @log_call(logger.info)
+    def shutdown(self):
+        """Stop this service."""
+        # do any other needed cleanup
+        if self.shutdown_func is not None:
+            self.shutdown_func()
 
=== modified file 'ubuntuone/controlpanel/dbus_client.py'
--- ubuntuone/controlpanel/dbus_client.py	2011-02-23 13:57:42 +0000
+++ ubuntuone/controlpanel/dbus_client.py	2011-04-08 19:43:13 +0000
@@ -64,7 +64,6 @@
 
     def found_credentials(app_name, creds):
         """Credentials have been found."""
-        logger.debug('credentials were found for app_name %r.', app_name)
         if app_name == APP_NAME:
             logger.info('credentials were found! (%r).', APP_NAME)
             d.callback(creds)
 
=== modified file 'ubuntuone/controlpanel/dbus_service.py'
--- ubuntuone/controlpanel/dbus_service.py	2011-01-25 19:08:59 +0000
+++ ubuntuone/controlpanel/dbus_service.py	2011-04-08 19:43:13 +0000
@@ -32,7 +32,8 @@
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
     DBUS_PREFERENCES_IFACE)
 from ubuntuone.controlpanel.backend import (
-    ControlBackend, FILE_SYNC_DISABLED, FILE_SYNC_DISCONNECTED,
+    ControlBackend, filter_field, UnauthorizedError,
+    FILE_SYNC_DISABLED, FILE_SYNC_DISCONNECTED,
     FILE_SYNC_ERROR, FILE_SYNC_IDLE, FILE_SYNC_STARTING, FILE_SYNC_STOPPED,
     FILE_SYNC_SYNCING,
     MSG_KEY, STATUS_KEY,
@@ -77,7 +78,7 @@
     return result
 
 
-def transform_failure(f):
+def transform_failure(f, auth_error=None):
     """Decorator to apply to DBus error signals.
 
     With this call, a Failure is transformed into a string-string dict.
@@ -85,8 +86,11 @@
     """
     def inner(error, _=None):
         """Do the Failure transformation."""
+        logger.error('processing failure: %r', error.printTraceback())
         error_dict = error_handler(error)
-        if _ is not None:
+        if auth_error is not None and error.check(UnauthorizedError):
+            result = auth_error(error_dict)
+        elif _ is not None:
             result = f(_, error_dict)
         else:
             result = f(error_dict)
@@ -115,19 +119,25 @@
         super(ControlPanelBackend, self).__init__(*args, **kwargs)
         self.backend = backend
         self.backend.status_changed_handler = self.process_status
+        self.transform = lambda f: transform_failure(f, self.UnauthorizedError)
         logger.debug('ControlPanelBackend: created with %r, %r.\n'
                      'status_changed_handler is %r.',
                      args, kwargs, self.process_status)
 
     # pylint: disable=C0103
 
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
+    def UnauthorizedError(self, error):
+        """The credentials are not valid."""
+
     @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def account_info(self):
         """Find out the account info for the current logged in user."""
         d = self.backend.account_info()
         d.addCallback(self.AccountInfoReady)
-        d.addErrback(transform_failure(self.AccountInfoError))
+        d.addErrback(self.transform(self.AccountInfoError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
@@ -147,12 +157,13 @@
         """Find out the devices info for the logged in user."""
         d = self.backend.devices_info()
         d.addCallback(self.DevicesInfoReady)
-        d.addErrback(transform_failure(self.DevicesInfoError))
+        d.addErrback(self.transform(self.DevicesInfoError))
 
-    @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="aa{ss}")
     def DevicesInfoReady(self, info):
         """The info for the devices is available right now."""
+        logger.debug('DevicesInfoReady: args %r',
+                     filter_field(info, field='device_id'))
 
     @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
@@ -161,41 +172,41 @@
 
     #---
 
-    @log_call(logger.info)
+    @log_call(logger.info, with_args=False)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="sa{ss}")
     def change_device_settings(self, device_id, settings):
         """Configure a given device."""
         d = self.backend.change_device_settings(device_id, settings)
         d.addCallback(self.DeviceSettingsChanged)
-        d.addErrback(transform_failure(self.DeviceSettingsChangeError),
+        d.addErrback(self.transform(self.DeviceSettingsChangeError),
                      device_id)
 
-    @log_call(logger.info)
+    @log_call(logger.info, with_args=False)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
     def DeviceSettingsChanged(self, device_id):
         """The settings for the device were changed."""
 
-    @log_call(logger.error)
+    @log_call(logger.error, with_args=False)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="sa{ss}")
     def DeviceSettingsChangeError(self, device_id, error):
         """Problem changing settings for the device."""
 
     #---
 
-    @log_call(logger.warning)
+    @log_call(logger.warning, with_args=False)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="s")
     def remove_device(self, device_id):
         """Remove a given device."""
         d = self.backend.remove_device(device_id)
         d.addCallback(self.DeviceRemoved)
-        d.addErrback(transform_failure(self.DeviceRemovalError), device_id)
+        d.addErrback(self.transform(self.DeviceRemovalError), device_id)
 
-    @log_call(logger.warning)
+    @log_call(logger.warning, with_args=False)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
     def DeviceRemoved(self, device_id):
         """The removal for the device was completed."""
 
-    @log_call(logger.error)
+    @log_call(logger.error, with_args=False)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="sa{ss}")
     def DeviceRemovalError(self, device_id, error):
         """Problem removing the device."""
@@ -234,7 +245,7 @@
         """Get the status of the file sync service."""
         d = self.backend.file_sync_status()
         d.addCallback(self.process_status)
-        d.addErrback(transform_failure(self.FileSyncStatusError))
+        d.addErrback(self.transform(self.FileSyncStatusError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
@@ -284,7 +295,7 @@
         """Enable the files service."""
         d = self.backend.enable_files()
         d.addCallback(lambda _: self.FilesEnabled())
-        d.addErrback(transform_failure(self.FilesEnableError))
+        d.addErrback(self.transform(self.FilesEnableError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
@@ -304,7 +315,7 @@
         """Disable the files service."""
         d = self.backend.disable_files()
         d.addCallback(lambda _: self.FilesDisabled())
-        d.addErrback(transform_failure(self.FilesDisableError))
+        d.addErrback(self.transform(self.FilesDisableError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
@@ -324,7 +335,7 @@
         """Connect the files service."""
         d = self.backend.connect_files()
         d.addCallback(lambda _: self.FilesConnected())
-        d.addErrback(transform_failure(self.FilesConnectError))
+        d.addErrback(self.transform(self.FilesConnectError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
@@ -344,7 +355,7 @@
         """Disconnect the files service."""
         d = self.backend.disconnect_files()
         d.addCallback(lambda _: self.FilesDisconnected())
-        d.addErrback(transform_failure(self.FilesDisconnectError))
+        d.addErrback(self.transform(self.FilesDisconnectError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
@@ -364,7 +375,7 @@
         """Restart the files service."""
         d = self.backend.restart_files()
         d.addCallback(lambda _: self.FilesRestarted())
-        d.addErrback(transform_failure(self.FilesRestartError))
+        d.addErrback(self.transform(self.FilesRestartError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
@@ -384,7 +395,7 @@
         """Start the files service."""
         d = self.backend.start_files()
         d.addCallback(lambda _: self.FilesStarted())
-        d.addErrback(transform_failure(self.FilesStartError))
+        d.addErrback(self.transform(self.FilesStartError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
@@ -404,7 +415,7 @@
         """Stop the files service."""
         d = self.backend.stop_files()
         d.addCallback(lambda _: self.FilesStopped())
-        d.addErrback(transform_failure(self.FilesStopError))
+        d.addErrback(self.transform(self.FilesStopError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
@@ -424,7 +435,7 @@
         """Find out the volumes info for the logged in user."""
         d = self.backend.volumes_info()
         d.addCallback(self.VolumesInfoReady)
-        d.addErrback(transform_failure(self.VolumesInfoError))
+        d.addErrback(self.transform(self.VolumesInfoError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a(ssaa{ss})")
@@ -444,7 +455,7 @@
         """Configure a given volume."""
         d = self.backend.change_volume_settings(volume_id, settings)
         d.addCallback(self.VolumeSettingsChanged)
-        d.addErrback(transform_failure(self.VolumeSettingsChangeError),
+        d.addErrback(self.transform(self.VolumeSettingsChangeError),
                      volume_id)
 
     @log_call(logger.info)
@@ -465,7 +476,7 @@
         """Return the replications info."""
         d = self.backend.replications_info()
         d.addCallback(self.ReplicationsInfoReady)
-        d.addErrback(transform_failure(self.ReplicationsInfoError))
+        d.addErrback(self.transform(self.ReplicationsInfoError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="aa{ss}")
@@ -485,7 +496,7 @@
         """Configure a given replication."""
         d = self.backend.change_replication_settings(replication_id, settings)
         d.addCallback(self.ReplicationSettingsChanged)
-        d.addErrback(transform_failure(self.ReplicationSettingsChangeError),
+        d.addErrback(self.transform(self.ReplicationSettingsChangeError),
                      replication_id)
 
     @log_call(logger.info)
@@ -506,7 +517,7 @@
         """Check if the extension to sync bookmarks is installed."""
         d = self.backend.query_bookmark_extension()
         d.addCallback(self.QueryBookmarksResult)
-        d.addErrback(transform_failure(self.QueryBookmarksError))
+        d.addErrback(self.transform(self.QueryBookmarksError))
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="b")
@@ -526,7 +537,7 @@
         """Install the extension to sync bookmarks."""
         d = self.backend.install_bookmarks_extension()
         d.addCallback(lambda _: self.InstallBookmarksSuccess())
-        d.addErrback(transform_failure(self.InstallBookmarksError))
+        d.addErrback(self.transform(self.InstallBookmarksError))
 
     @log_call(logger.info)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="")
@@ -538,15 +549,24 @@
     def InstallBookmarksError(self, error):
         """Problem installing the extension to sync bookmarks."""
 
+    #---
+
+    @log_call(logger.info)
+    @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
+    def shutdown(self):
+        """Shutdown this service."""
+        self.backend.shutdown()
+
 
 def init_mainloop():
     """Start the DBus mainloop."""
     DBusGMainLoop(set_as_default=True)
 
 
-def run_mainloop():
+def run_mainloop(loop=None):
     """Run the gobject main loop."""
-    loop = gobject.MainLoop()
+    if loop is None:
+        loop = gobject.MainLoop()
     loop.run()
 
 
@@ -566,10 +586,10 @@
     return dbus.service.BusName(DBUS_BUS_NAME, bus=dbus.SessionBus())
 
 
-def publish_backend(backend=None):
+def publish_backend(backend=None, shutdown_func=None):
     """Publish the backend on the DBus."""
     if backend is None:
-        backend = ControlBackend()
+        backend = ControlBackend(shutdown_func=shutdown_func)
     return ControlPanelBackend(backend=backend,
                                object_path=DBUS_PREFERENCES_PATH,
                                bus_name=get_busname())
@@ -579,7 +599,8 @@
     """Hook the DBus listeners and start the main loop."""
     init_mainloop()
     if register_service():
-        publish_backend()
-        run_mainloop()
+        loop = gobject.MainLoop()
+        publish_backend(shutdown_func=loop.quit)
+        run_mainloop(loop=loop)
     else:
         print "Control panel backend already running."
 
=== modified file 'ubuntuone/controlpanel/gtk/__init__.py'
--- ubuntuone/controlpanel/gtk/__init__.py	2011-03-23 16:06:41 +0000
+++ ubuntuone/controlpanel/gtk/__init__.py	2011-04-08 19:43:13 +0000
@@ -18,5 +18,7 @@
 
 """The GTK graphical interface for the control panel for Ubuntu One."""
 
-DBUS_BUS_NAME = "com.ubuntuone.controlpanel.gui"
-TRANSLATION_DOMAIN = "ubuntuone-control-panel"
+DBUS_BUS_NAME = 'com.ubuntuone.controlpanel.gui'
+DBUS_PATH = '/gui'
+DBUS_IFACE_GUI = 'com.ubuntuone.controlpanel.gui'
+TRANSLATION_DOMAIN = 'ubuntuone-control-panel'
 
=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2011-03-23 16:06:41 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2011-04-08 19:43:13 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Natalia B Bidart <[e-mail]>
+#          Eric Casteleijn <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -31,6 +32,7 @@
 import gobject
 import ubuntu_sso
 
+from dbus.mainloop.glib import DBusGMainLoop
 from ubuntu_sso import networkstate
 from ubuntu_sso.credentials import (TC_URL_KEY, HELP_TEXT_KEY, WINDOW_ID_KEY,
     PING_URL_KEY)
@@ -41,6 +43,9 @@
     PING_URL as U1_PING_URL, DESCRIPTION as U1_DESCRIPTION)
 # pylint: enable=E0611,F0401
 
+from ubuntuone.controlpanel.gtk import (
+    DBUS_IFACE_GUI, DBUS_BUS_NAME as DBUS_BUS_NAME_GUI,
+    DBUS_PATH as DBUS_PATH_GUI)
 from ubuntuone.controlpanel.gtk.widgets import LabelLoading, PanelTitle
 # Use ubiquity package when ready (LP: #673665)
 from ubuntuone.controlpanel.gtk.widgets import GreyableBin
@@ -50,10 +55,18 @@
 from ubuntuone.controlpanel.backend import (DEVICE_TYPE_PHONE,
     DEVICE_TYPE_COMPUTER, bool_str)
 from ubuntuone.controlpanel.logger import setup_logging, log_call
-from ubuntuone.controlpanel.utils import get_data_file
+from ubuntuone.controlpanel.utils import (get_data_file,
+    ERROR_TYPE, ERROR_MESSAGE)
 
 from ubuntuone.controlpanel.gtk import package_manager, TRANSLATION_DOMAIN
 
+try:
+    from gi.repository import Unity     # pylint: disable=E0611
+    USE_LIBUNITY = True
+    U1_DOTDESKTOP = "ubuntuone-control-panel-gtk.desktop"
+except ImportError:
+    USE_LIBUNITY = False
+
 logger = setup_logging('gtk.gui')
 _ = gettext.gettext
 
@@ -63,6 +76,7 @@
 ERROR_COLOR = 'red'
 LOADING = _('Loading...')
 VALUE_ERROR = _('Value could not be retrieved.')
+UNKNOWN_ERROR = _('Unknown error')
 WARNING_MARKUP = '<span foreground="%s"><b>%%s</b></span>' % ERROR_COLOR
 KILOBYTES = 1024
 NO_OP = lambda *a, **kw: None
@@ -74,6 +88,49 @@
     logger.error('Error handler received: %r, %r', args, kwargs)
 
 
+def register_service(bus):
+    """Try to register DBus service for making sure we run only one instance.
+
+    Return True if succesfully registered, False if already running.
+    """
+    name = bus.request_name(DBUS_BUS_NAME_GUI,
+                                    dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
+    return name != dbus.bus.REQUEST_NAME_REPLY_EXISTS
+
+
+def publish_service(window=None, switch_to='', alert=False):
+    """Publish the service on DBus."""
+    if window is None:
+        window = ControlPanelWindow(switch_to=switch_to, alert=alert)
+    return ControlPanelService(window)
+
+
+def main(switch_to='', alert=False):
+    """Hook the DBus listeners and start the main loop."""
+    DBusGMainLoop(set_as_default=True)
+    bus = dbus.SessionBus()
+    if register_service(bus):
+        publish_service(switch_to=switch_to, alert=alert)
+    else:
+        obj = bus.get_object(DBUS_BUS_NAME_GUI, DBUS_PATH_GUI)
+        service = dbus.Interface(obj, dbus_interface=DBUS_IFACE_GUI)
+
+        def gui_error_handler(*args, **kwargs):
+            """Log errors when calling D-Bus methods in a async way."""
+            logger.error('Error handler received: %r, %r', args, kwargs)
+            gtk.main_quit()
+
+        def gui_reply_handler(*args, **kwargs):
+            """Exit when done."""
+            gtk.main_quit()
+
+        service.switch_to_alert(
+            switch_to, alert, reply_handler=gui_reply_handler,
+            error_handler=gui_error_handler)
+
+    gtk.main()
+
+
 def filter_by_app_name(f):
     """Excecute 'f' filtering by app_name."""
 
@@ -192,10 +249,19 @@
         self.message.set_markup(message)
 
     @log_call(logger.error)
-    def on_error(self, message=None):
+    def on_error(self, message=None, error_dict=None):
         """Use this callback to stop the Loading and set a warning message."""
-        if message == None:
+        if message is None and error_dict is None:
             message = VALUE_ERROR
+        elif message is None and error_dict is not None:
+            error_type = error_dict.get(ERROR_TYPE, UNKNOWN_ERROR)
+            error_msg = error_dict.get(ERROR_MESSAGE)
+            if error_msg:
+                message = "%s (%s: %s)" % (VALUE_ERROR, error_type, error_msg)
+            else:
+                message = "%s (%s)" % (VALUE_ERROR, error_type)
+
+        assert message is not None
 
         self.message.stop()
         self.message.set_markup(WARNING_MARKUP % message)
@@ -492,6 +558,10 @@
                 elif name == self.MUSIC_DISPLAY_NAME:
                     icon_name = self.MUSIC_ICON_NAME
 
+                if volume[u'path'] is None:
+                    logger.warning('on_volumes_info_ready: about to store a '
+                                   'volume with None path: %r', volume)
+
                 row = (name, bool(volume[u'subscribed']), icon_name, True,
                        sensitive, gtk.ICON_SIZE_MENU, volume['volume_id'],
                        volume[u'path'])
@@ -509,7 +579,7 @@
     @log_call(logger.error)
     def on_volumes_info_error(self, error_dict=None):
         """Backend notifies of an error when fetching volumes info."""
-        self.on_error()
+        self.on_error(error_dict=error_dict)
 
     @log_call(logger.info)
     def on_volume_settings_changed(self, volume_id):
@@ -548,7 +618,14 @@
         """The user double clicked on a row."""
         treeiter = self.volumes_store.get_iter(path)
         volume_path = self.volumes_store.get_value(treeiter, 7)
-        uri_hook(None, FILE_URI_PREFIX + volume_path)
+        if volume_path is None:
+            logger.warning('on_volumes_view_row_activated: volume_path for '
+                           'tree_path %r is None', path)
+        elif not os.path.exists(volume_path):
+            logger.warning('on_volumes_view_row_activated: path %r '
+                           'does not exist', volume_path)
+        else:
+            uri_hook(None, FILE_URI_PREFIX + volume_path)
 
     def load(self):
         """Load the volume list."""
@@ -827,7 +904,7 @@
     @log_call(logger.error)
     def on_devices_info_error(self, error_dict=None):
         """Backend notifies of an error when fetching volumes info."""
-        self.on_error()
+        self.on_error(error_dict=error_dict)
         self.is_processing = False
 
     @log_call(logger.warning)
@@ -992,7 +1069,8 @@
     def on_file_sync_status_changed(self, status):
         """File Sync status changed."""
         enabled = status != backend.FILE_SYNC_DISABLED
-        logger.info('FileSyncService: enabled? %r', enabled)
+        logger.info('FileSyncService: on_file_sync_status_changed: '
+                    'status %r, enabled? %r', status, enabled)
         self.check_button.set_active(enabled)
         # if service is disabled, disable the action_button
         self.action_button.set_sensitive(enabled)
@@ -1025,8 +1103,8 @@
 class DesktopcouchService(Service):
     """A desktopcouch service."""
 
-    INSTALL_PACKAGE = _('Install the %(plugin_name)s '
-                        'for %(service_name)s sync')
+    INSTALL_PACKAGE = _('Install the %(plugin_name)s for the sync service: '
+                        '%(service_name)s')
 
     def __init__(self, service_id, name, enabled,
                  container, check_button,
@@ -1152,6 +1230,7 @@
     @log_call(logger.debug)
     def load(self):
         """Load info."""
+        self.replications.hide()
         if self.install_box is not None:
             self.itself.remove(self.install_box)
             self.install_box = None
@@ -1159,7 +1238,6 @@
         logger.info('load: has_desktopcouch? %r', self.has_desktopcouch)
         if not self.has_desktopcouch:
             self.message.set_text('')
-            self.replications.hide()
 
             self.install_box = InstallPackage(self.DESKTOPCOUCH_PKG)
             self.install_box.connect('finished', self.load_replications)
@@ -1211,7 +1289,7 @@
            error_dict.get('error_type', None) == 'NoPairingRecord':
             self.on_error(self.NO_PAIRING_RECORD)
         else:
-            self.on_error()
+            self.on_error(error_dict=error_dict)
 
 
 class FileSyncStatus(gtk.HBox, ControlPanelMixin):
@@ -1252,6 +1330,8 @@
         self.button.connect('clicked', self._on_button_clicked)
         self.pack_start(self.button, expand=False)
 
+        self.show_all()
+
         self.backend.connect_to_signal('FileSyncStatusDisabled',
                                        self.on_file_sync_status_disabled)
         self.backend.connect_to_signal('FileSyncStatusStarting',
@@ -1268,10 +1348,10 @@
                                        self.on_file_sync_status_error)
         self.backend.connect_to_signal('FilesStartError',
                                        self.on_files_start_error)
-
-        self.backend.file_sync_status(reply_handler=NO_OP,
-                                      error_handler=error_handler)
-        self.show_all()
+        self.backend.connect_to_signal('FilesEnabled',
+                                       self.on_file_sync_status_starting)
+        self.backend.connect_to_signal('FilesDisabled',
+                                       self.on_file_sync_status_disabled)
 
     def _update_status(self, msg, action, callback,
                        icon=None, color=None, tooltip=None):
@@ -1296,42 +1376,42 @@
         button.get_data('callback')(button)
 
     @log_call(logger.info)
-    def on_file_sync_status_disabled(self, msg):
+    def on_file_sync_status_disabled(self, msg=None):
         """Backend notifies of file sync status being disabled."""
         self._update_status(self.FILE_SYNC_DISABLED,
                             self.ENABLE, self.on_enable_clicked,
                             '✘', 'red', self.ENABLE_TOOLTIP)
 
     @log_call(logger.info)
-    def on_file_sync_status_starting(self, msg):
+    def on_file_sync_status_starting(self, msg=None):
         """Backend notifies of file sync status being starting."""
         self._update_status(self.FILE_SYNC_STARTING,
                             self.STOP, self.on_stop_clicked,
                             '⇅', ORANGE, self.STOP_TOOLTIP)
 
     @log_call(logger.info)
-    def on_file_sync_status_stopped(self, msg):
+    def on_file_sync_status_stopped(self, msg=None):
         """Backend notifies of file sync being stopped."""
         self._update_status(self.FILE_SYNC_STOPPED,
                             self.START, self.on_start_clicked,
                             '✘', 'red', self.START_TOOLTIP)
 
     @log_call(logger.info)
-    def on_file_sync_status_disconnected(self, msg):
+    def on_file_sync_status_disconnected(self, msg=None):
         """Backend notifies of file sync status being ready."""
         self._update_status(self.FILE_SYNC_DISCONNECTED,
                             self.CONNECT, self.on_connect_clicked,
                             '✘', 'red', self.CONNECT_TOOLTIP,)
 
     @log_call(logger.info)
-    def on_file_sync_status_syncing(self, msg):
+    def on_file_sync_status_syncing(self, msg=None):
         """Backend notifies of file sync status being syncing."""
         self._update_status(self.FILE_SYNC_SYNCING,
                             self.DISCONNECT, self.on_disconnect_clicked,
                             '⇅', ORANGE, self.DISCONNECT_TOOLTIP)
 
     @log_call(logger.info)
-    def on_file_sync_status_idle(self, msg):
+    def on_file_sync_status_idle(self, msg=None):
         """Backend notifies of file sync status being idle."""
         self._update_status(self.FILE_SYNC_IDLE,
                             self.DISCONNECT, self.on_disconnect_clicked,
@@ -1385,6 +1465,11 @@
         self.backend.stop_files(reply_handler=NO_OP,
                                 error_handler=error_handler)
 
+    def load(self):
+        """Load the information."""
+        self.backend.file_sync_status(reply_handler=NO_OP,
+                                      error_handler=error_handler)
+
 
 class ManagementPanel(gtk.VBox, ControlPanelMixin):
     """The management panel.
@@ -1396,6 +1481,7 @@
     __gsignals__ = {
         'local-device-removed': (gobject.SIGNAL_RUN_FIRST,
                                  gobject.TYPE_NONE, ()),
+        'unauthorized': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()),
     }
 
     QUOTA_LABEL = _('Using %(used)s of %(total)s (%(percentage).0f%%)')
@@ -1421,6 +1507,8 @@
                                        self.on_account_info_ready)
         self.backend.connect_to_signal('AccountInfoError',
                                        self.on_account_info_error)
+        self.backend.connect_to_signal('UnauthorizedError',
+                                       self.on_unauthorized_error)
 
         self.quota_progressbar.set_sensitive(False)
 
@@ -1461,7 +1549,11 @@
 
         self.services_button.set_name(self.SERVICES_BUTTON_NAME)
         self.services_button.set_tooltip_text(self.SERVICES_BUTTON_TOOLTIP)
-        self.services.load()
+
+        self.enable_volumes = lambda: self.volumes_button.set_sensitive(True)
+        self.disable_volumes = lambda: self.volumes_button.set_sensitive(False)
+        self.backend.connect_to_signal('FilesEnabled', self.enable_volumes)
+        self.backend.connect_to_signal('FilesDisabled', self.disable_volumes)
 
     def _update_quota(self, msg, data=None):
         """Update the quota info."""
@@ -1491,6 +1583,8 @@
         """Load the account info and file sync status list."""
         self.backend.account_info(reply_handler=NO_OP,
                                   error_handler=error_handler)
+        self.status_label.load()
+        self.services.load()
 
     @log_call(logger.debug)
     def on_account_info_ready(self, info):
@@ -1506,15 +1600,22 @@
         """Backend notifies of an error when fetching account info."""
         self._update_quota(msg='')
 
-
-class ControlPanel(gtk.Notebook):
+    @log_call(logger.error)
+    def on_unauthorized_error(self, error_dict=None):
+        """Backend notifies that credentials are not valid."""
+        self.emit('unauthorized')
+
+
+class ControlPanel(gtk.Notebook, ControlPanelMixin):
     """The control panel per se, can be added into any other widget."""
 
     # should not be any larger than 736x525
 
     def __init__(self, main_window):
         gtk.Notebook.__init__(self)
+        ControlPanelMixin.__init__(self)
         gtk.link_button_set_uri_hook(uri_hook)
+        self.connect('destroy', self.shutdown)
 
         self.main_window = main_window
 
@@ -1531,6 +1632,8 @@
                               self.on_show_management_panel)
         self.management.connect('local-device-removed',
                                 self.on_show_overview_panel)
+        self.management.connect('unauthorized',
+                                self.on_show_overview_panel)
 
         self.show()
         self.on_show_overview_panel()
@@ -1538,6 +1641,12 @@
         logger.debug('%s: started (window size %r).',
                      self.__class__.__name__, self.get_size_request())
 
+    def shutdown(self, *args, **kwargs):
+        """Shutdown backend."""
+        logger.info('Shutting down...')
+        self.backend.shutdown(reply_handler=NO_OP,
+                              error_handler=error_handler)
+
     def on_show_overview_panel(self, widget=None):
         """Show the overview panel."""
         self.set_current_page(0)
@@ -1550,18 +1659,42 @@
             if credentials_are_new:
                 # redirect user to services page to start using Ubuntu One
                 self.management.services_button.clicked()
+                # instruct syncdaemon to connect
+                self.backend.connect_files(reply_handler=NO_OP,
+                                           error_handler=error_handler)
 
             self.next_page()
 
 
+class ControlPanelService(dbus.service.Object):
+    """DBUS service that exposes some of the window's methods."""
+
+    def __init__(self, window):
+        self.window = window
+        bus_name = dbus.service.BusName(
+            DBUS_BUS_NAME_GUI, bus=dbus.SessionBus())
+        dbus.service.Object.__init__(
+            self, bus_name=bus_name, object_path=DBUS_PATH_GUI)
+
+    @log_call(logger.debug)
+    @dbus.service.method(dbus_interface=DBUS_IFACE_GUI, in_signature='sb')
+    def switch_to_alert(self, panel='', alert=False):
+        """Switch to named panel."""
+        if panel:
+            self.window.switch_to(panel)
+        if alert:
+            self.window.draw_attention()
+
+
 class ControlPanelWindow(gtk.Window):
     """The main window for the Ubuntu One control panel."""
 
     TITLE = _('%(app_name)s Control Panel')
 
-    def __init__(self, switch_to=None, alert=False):
+    def __init__(self, switch_to='', alert=False):
         super(ControlPanelWindow, self).__init__()
 
+        self.connect('focus-in-event', self.remove_urgency)
         self.set_title(self.TITLE % {'app_name': U1_APP_NAME})
         self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
         self.set_icon_name('ubuntuone')
@@ -1569,9 +1702,7 @@
 
         self.connect('delete-event', lambda w, e: gtk.main_quit())
         if alert:
-            # NOTE this should prevent focus stealing but it does not :(
-            self.present_with_time(1)
-            self.set_urgency_hint(True)
+            self.draw_attention()
         else:
             self.present()
 
@@ -1580,17 +1711,35 @@
 
         logger.info('Starting %s pointing at panel: %r.',
                      self.__class__.__name__, switch_to)
-        if switch_to is not None:
-            button = getattr(self.control_panel.management,
-                             '%s_button' % switch_to, None)
-            if button is not None:
-                button.clicked()
-            else:
-                logger.warning('Could not start at panel: %r.', switch_to)
+        if switch_to:
+            self.switch_to(switch_to)
 
         logger.debug('%s: started (window size %r).',
                      self.__class__.__name__, self.get_size_request())
 
+    def remove_urgency(self, *args, **kwargs):
+        """Remove urgency from the launcher entry."""
+        if not USE_LIBUNITY:
+            return
+        entry = Unity.LauncherEntry.get_for_desktop_id(U1_DOTDESKTOP)
+        if entry.props.urgent:
+            self.switch_to('volumes')
+            entry.props.urgent = False
+
+    def draw_attention(self):
+        """Draw attention to the control panel."""
+        self.present_with_time(1)
+        self.set_urgency_hint(True)
+
+    def switch_to(self, panel):
+        """Switch to named panel."""
+        button = getattr(
+            self.control_panel.management, '%s_button' % panel, None)
+        if button is not None:
+            button.clicked()
+        else:
+            logger.warning('Could not start at panel: %r.', panel)
+
     def main(self):
         """Run the main loop of the widget toolkit."""
         logger.debug('Starting GTK main loop.')
 
=== modified file 'ubuntuone/controlpanel/gtk/package_manager.py'
--- ubuntuone/controlpanel/gtk/package_manager.py	2011-02-23 13:57:42 +0000
+++ ubuntuone/controlpanel/gtk/package_manager.py	2011-04-08 19:43:13 +0000
@@ -20,13 +20,14 @@
 
 import apt
 import aptdaemon.client
+# pylint: disable=W0404
 import aptdaemon.enums
 
 try:
-    # Unable to import 'defer', pylint: disable=F0401,E0611
+    # Unable to import 'defer', pylint: disable=F0401,E0611,W0404
     from aptdaemon.defer import inline_callbacks, return_value
 except ImportError:
-    # Unable to import 'defer', pylint: disable=F0401,E0611
+    # Unable to import 'defer', pylint: disable=F0401,E0611,W0404
     from defer import inline_callbacks, return_value
 from aptdaemon.gtkwidgets import AptProgressBar
 
 
=== modified file 'ubuntuone/controlpanel/gtk/tests/__init__.py'
--- ubuntuone/controlpanel/gtk/tests/__init__.py	2011-03-10 02:59:44 +0000
+++ ubuntuone/controlpanel/gtk/tests/__init__.py	2011-04-08 19:43:13 +0000
@@ -180,10 +180,19 @@
         'replications_info', 'change_replication_settings',  # replications
         'file_sync_status', 'enable_files', 'disable_files',  # files
         'connect_files', 'disconnect_files',
-        'restart_files', 'start_files', 'stop_files',
+        'restart_files', 'start_files', 'stop_files', 'shutdown',
     ]
 
 
+class FakeControlPanelBackend(FakedDBusBackend):
+    """Fake a Control Panel Service, act as a dbus.Interface."""
+
+    bus_name = gui.DBUS_BUS_NAME_GUI
+    object_path = gui.DBUS_PATH_GUI
+    iface = gui.DBUS_IFACE_GUI
+    exposed_methods = ['draw_attention', 'switch_to']
+
+
 class FakedSessionBus(object):
     """Fake a session bus."""
 
@@ -202,6 +211,9 @@
                                             *args, **kwargs)
         if dbus_interface == gui.ubuntu_sso.DBUS_CREDENTIALS_IFACE:
             return FakedSSOBackend(obj, dbus_interface, *args, **kwargs)
+        if dbus_interface == gui.DBUS_IFACE_GUI:
+            return FakeControlPanelBackend(
+                obj, dbus_interface, *args, **kwargs)
 
 
 class FakedPackageManager(object):
 
=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-03-10 02:59:44 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-04-08 19:43:13 +0000
@@ -278,6 +278,7 @@
 
     def test_clicking_on_row_opens_folder(self):
         """The folder activated is opened."""
+        self.patch(gui.os.path, 'exists', lambda *a: True)
         self.patch(gui, 'uri_hook', self._set_called)
         self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
 
@@ -287,6 +288,33 @@
         self.assertEqual(self._called,
                          ((None, gui.FILE_URI_PREFIX + ROOT['path']), {}))
 
+    def test_clicking_on_row_handles_path_none(self):
+        """None paths are properly handled."""
+        self.patch(gui, 'uri_hook', self._set_called)
+        self.patch(self.ui.volumes_store, 'get_value', lambda *a: None)
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+
+        self.ui.volumes_view.row_activated('0:0',
+                                           self.ui.volumes_view.get_column(0))
+
+        self.assertTrue(self.memento.check_warning('tree_path (0, 0)',
+                                                   'volume_path', 'is None'))
+        self.assertEqual(self._called, False)
+
+    def test_clicking_on_row_handles_path_non_existent(self):
+        """Not-existent paths are properly handled."""
+        self.patch(gui.os.path, 'exists', lambda *a: False)
+        self.patch(gui, 'uri_hook', self._set_called)
+        path = 'not-in-disk'
+        self.patch(self.ui.volumes_store, 'get_value', lambda *a: path)
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+
+        self.ui.volumes_view.row_activated('0:0',
+                                           self.ui.volumes_view.get_column(0))
+
+        self.assertTrue(self.memento.check_warning(path, 'does not exist'))
+        self.assertEqual(self._called, False)
+
     def test_on_volumes_info_ready_with_music_folder(self):
         """The volumes info is processed when ready."""
         info = [(u'', u'147852369', [ROOT] + [MUSIC_FOLDER])]
@@ -1646,12 +1674,15 @@
             ('FileSyncStatusIdle', [self.ui.on_file_sync_status_idle]),
             ('FileSyncStatusError', [self.ui.on_file_sync_status_error]),
             ('FilesStartError', [self.ui.on_files_start_error]),
+            ('FilesDisabled', [self.ui.on_file_sync_status_disabled]),
+            ('FilesEnabled', [self.ui.on_file_sync_status_starting]),
         )
         for sig, handlers in matches:
             self.assertEqual(self.ui.backend._signals[sig], handlers)
 
-    def test_file_sync_status_is_requested(self):
+    def test_file_sync_status_is_requested_on_load(self):
         """The file sync status is requested to the backend."""
+        self.ui.load()
         self.assert_backend_called('file_sync_status', ())
 
     def test_on_file_sync_status_disabled(self):
@@ -1882,11 +1913,32 @@
         self.assertEqual(self.ui.backend._signals['AccountInfoError'],
                          [self.ui.on_account_info_error])
 
+    def test_backend_unauthorized_signal(self):
+        """The proper signals are connected to the backend."""
+        self.assertEqual(self.ui.backend._signals['UnauthorizedError'],
+                         [self.ui.on_unauthorized_error])
+
+    def test_no_backend_calls_before_load(self):
+        """No calls are made to the backend before load() is called."""
+        self.assertEqual(self.ui.backend._called, {})
+
     def test_account_info_is_requested_on_load(self):
         """The account info is requested to the backend."""
         self.ui.load()
         self.assert_backend_called('account_info', ())
 
+    def test_file_sync_status_info_is_requested_on_load(self):
+        """The file sync status info is requested to the backend."""
+        self.patch(self.ui.status_label, 'load', self._set_called)
+        self.ui.load()
+        self.assertEqual(self._called, ((), {}))
+
+    def test_replications_info_is_requested_on_load(self):
+        """The replications info is requested to the backend."""
+        self.patch(self.ui.services, 'load', self._set_called)
+        self.ui.load()
+        self.assertEqual(self._called, ((), {}))
+
     def test_dashboard_panel_is_packed(self):
         """The dashboard panel is packed."""
         self.assertIsInstance(self.ui.dashboard, gui.DashboardPanel)
@@ -1999,6 +2051,23 @@
         self.assertIsInstance(self.ui.status_label, gui.FileSyncStatus)
         self.assertIn(self.ui.status_label, self.ui.status_box.get_children())
 
+    def test_backend_file_sync_signals(self):
+        """The proper signals are connected to the backend."""
+        self.assertEqual(self.ui.backend._signals['FilesEnabled'],
+                         [self.ui.enable_volumes])
+        self.assertEqual(self.ui.backend._signals['FilesDisabled'],
+                         [self.ui.disable_volumes])
+
+    def test_enable_volumes(self):
+        """The volumes tab is properly enabled."""
+        self.ui.enable_volumes()
+        self.assertTrue(self.ui.volumes_button.get_sensitive())
+
+    def test_disable_volumes(self):
+        """The volumes tab is properly disabled."""
+        self.ui.disable_volumes()
+        self.assertFalse(self.ui.volumes_button.get_sensitive())
+
     def test_local_device_removed_is_emitted(self):
         """Signal local-device-removed is sent when DevicesPanel emits it."""
         self.ui.connect('local-device-removed', self._set_called)
@@ -2024,3 +2093,9 @@
             actual = getattr(self.ui, '%s_button' % tab).get_tooltip_text()
             expected = getattr(self.ui, '%s_BUTTON_TOOLTIP' % tab.upper())
             self.assertEqual(actual, expected)
+
+    def test_on_unauthorized_error(self):
+        """On invalid credentials, proper signal is sent."""
+        self.ui.connect('unauthorized', self._set_called)
+        self.ui.on_unauthorized_error()
+        self.assertEqual(self._called, ((self.ui,), {}))
 
=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui_basic.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui_basic.py	2011-03-23 16:06:41 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui_basic.py	2011-04-08 19:43:13 +0000
@@ -29,6 +29,43 @@
 # pylint: disable=W0201, W0212
 
 
+class FakeLauncherEntryProps(object):
+    """A fake Unity.LauncherEntry.props"""
+
+    urgent = True
+
+
+THE_FLEP = FakeLauncherEntryProps()
+
+
+class FakeLauncherEntry(object):
+    """A fake Unity.LauncherEntry"""
+
+    def __init__(self):
+        """Initialize this fake instance."""
+        self.props = THE_FLEP
+
+    @staticmethod
+    def get_for_desktop_id(dotdesktop):
+        """Find the LauncherEntry for a given dotdesktop."""
+        return FakeLauncherEntry()
+
+
+class FakeControlPanelService(object):
+    """Fake service."""
+    def __init__(self, window):
+        self.window = window
+        self.called = []
+
+    def draw_attention(self):
+        """Draw attention to the control panel."""
+        self.called.append('draw_attention')
+
+    def switch_to(self, panel):
+        """Switch to named panel."""
+        self.called.append(('switch_to', panel))
+
+
 class ControlPanelMixinTestCase(BaseTestCase):
     """The test suite for the control panel widget."""
 
@@ -49,25 +86,30 @@
 
     klass = gui.ControlPanelWindow
 
+    def setUp(self):
+        self.patch(gui, 'ControlPanelService', FakeControlPanelService)
+        super(ControlPanelWindowTestCase, self).setUp()
+
     def test_is_a_window(self):
         """Inherits from gtk.Window."""
         self.assertIsInstance(self.ui, gui.gtk.Window)
 
     def test_startup_visibility(self):
         """The widget is visible at startup."""
-        self.assertTrue(self.ui.get_visible(), 'must be visible at startup.')
+        self.assertTrue(self.ui.get_visible(), 'was not visible at startup.')
 
     def test_main_start_gtk_main_loop(self):
         """The GTK main loop is started when calling main()."""
         self.patch(gui.gtk, 'main', self._set_called)
         self.ui.main()
-        self.assertEqual(self._called, ((), {}), 'gtk.main was called.')
+        self.assertEqual(self._called, ((), {}), 'gtk.main was not called.')
 
     def test_closing_stops_the_main_lopp(self):
         """The GTK main loop is stopped when closing the window."""
         self.patch(gui.gtk, 'main_quit', self._set_called)
         self.ui.emit('delete-event', None)
-        self.assertEqual(self._called, ((), {}), 'gtk.main_quit was called.')
+        self.assertEqual(
+            self._called, ((), {}), 'gtk.main_quit was not called.')
 
     def test_title_is_correct(self):
         """The window title is correct."""
@@ -96,6 +138,32 @@
         """Max size is not bigger than 736x525 (LP: #645526, LP: #683164)."""
         self.assertTrue(self.ui.get_size_request() <= (736, 525))
 
+    def test_focus_handler(self):
+        """When the window receives focus, the handler is called."""
+        THE_FLEP.urgent = True
+        self.patch(gui.Unity, "LauncherEntry", FakeLauncherEntry)
+        cp = gui.ControlPanelWindow()
+        cp.emit('focus-in-event', None)
+        self.assertEqual(
+            False, THE_FLEP.urgent, 'remove_urgency should have been called.')
+
+
+class ControlPanelWindowAlertParamTestCase(BaseTestCase):
+    """The test suite for the control panel window when passing params."""
+
+    klass = gui.ControlPanelWindow
+    kwargs = {'alert': True}
+
+    def setUp(self):
+        self.patch(gui, 'ControlPanelService', FakeControlPanelService)
+        self.patch(gui.ControlPanelWindow, 'draw_attention', self._set_called)
+        super(ControlPanelWindowAlertParamTestCase, self).setUp()
+
+    def test_alert(self):
+        """Can pass a 'alert' parameter to draw attention to the window."""
+        self.assertEqual(
+            ((), {}), self._called, 'draw_attention should have been called.')
+
 
 class ControlPanelWindowParamsTestCase(ControlPanelWindowTestCase):
     """The test suite for the control panel window when passing params."""
@@ -169,8 +237,10 @@
 
     def test_on_show_management_panel(self):
         """A ManagementPanel is shown when the callback is executed."""
+        self.patch(self.ui.management, 'load', self._set_called)
         self.ui.on_show_management_panel()
         self.assert_current_tab_correct(self.ui.management)
+        self.assertEqual(self._called, ((), {}))
 
     def test_on_show_management_panel_is_idempotent(self):
         """Only one ManagementPanel is shown."""
@@ -179,7 +249,7 @@
 
         self.assert_current_tab_correct(self.ui.management)
 
-    def test_credentials_found_shows_dashboard_management_panel(self):
+    def test_credentials_found_shows_dashboard_panel(self):
         """On 'credentials-found' signal, the management panel is shown.
 
         If first signal parameter is False, visible tab should be dashboard.
@@ -193,7 +263,7 @@
                          self.ui.management.DASHBOARD_PAGE)
         self.assertEqual(self._called, ((), {}))
 
-    def test_credentials_found_shows_volumes_management_panel(self):
+    def test_credentials_found_shows_services_panel(self):
         """On 'credentials-found' signal, the management panel is shown.
 
         If first signal parameter is True, visible tab should be services.
@@ -206,6 +276,12 @@
         self.assertEqual(self.ui.management.notebook.get_current_page(),
                          self.ui.management.SERVICES_PAGE)
 
+    def test_credentials_found_connects_syncdaemon(self):
+        """On 'credentials-found' signal, ask syncdaemon to connect."""
+        # credentials are new
+        self.ui.overview.emit('credentials-found', True, object())
+        self.assert_backend_called('connect_files', ())
+
     def test_local_device_removed_shows_overview_panel(self):
         """On 'local-device-removed' signal, the overview panel is shown."""
         self.ui.overview.emit('credentials-found', True, object())
@@ -213,6 +289,18 @@
 
         self.assert_current_tab_correct(self.ui.overview)
 
+    def test_unauthorized_shows_overview_panel(self):
+        """On 'unauthorized' signal, the overview panel is shown."""
+        self.ui.overview.emit('credentials-found', True, object())
+        self.ui.management.emit('unauthorized')
+
+        self.assert_current_tab_correct(self.ui.overview)
+
+    def test_backend_is_shutdown_on_close(self):
+        """When the control panel is closed, the backend is shutdown."""
+        self.ui.emit('destroy')
+        self.assert_backend_called('shutdown', ())
+
 
 class UbuntuOneBinTestCase(BaseTestCase):
     """The test suite for a Ubuntu One panel."""
@@ -276,6 +364,42 @@
         self.assert_warning_correct(self.ui.message, msg)
         self.assertFalse(self.ui.message.active)
 
+    def test_on_error_with_error_dict(self):
+        """Callback to stop the Loading and show the error from error_dict."""
+        msg = u'Qué mala suerte! <i>this does not rock</i>'
+        error_dict = {gui.ERROR_TYPE: 'YaddaError', gui.ERROR_MESSAGE: msg}
+        self.ui.on_error(error_dict=error_dict)
+
+        expected_msg = "%s (%s: %s)" % (gui.VALUE_ERROR, 'YaddaError', msg)
+        self.assert_warning_correct(self.ui.message, expected_msg)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_error_with_error_dict_without_error_type(self):
+        """Callback to stop the Loading and show the error from error_dict."""
+        error_dict = {}
+        self.ui.on_error(error_dict=error_dict)
+
+        expected_msg = "%s (%s)" % (gui.VALUE_ERROR, gui.UNKNOWN_ERROR)
+        self.assert_warning_correct(self.ui.message, expected_msg)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_error_with_error_dict_without_error_message(self):
+        """Callback to stop the Loading and show the error from error_dict."""
+        error_dict = {gui.ERROR_TYPE: 'YaddaError'}
+        self.ui.on_error(error_dict=error_dict)
+
+        expected_msg = "%s (%s)" % (gui.VALUE_ERROR, 'YaddaError')
+        self.assert_warning_correct(self.ui.message, expected_msg)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_error_with_message_and_error_dict(self):
+        """Callback to stop the Loading and show a info message."""
+        error_dict = {gui.ERROR_TYPE: 'YaddaError', gui.ERROR_MESSAGE: 'test'}
+        msg = 'WOW! <i>this does not rock</i> :-/'
+        self.ui.on_error(message=msg, error_dict=error_dict)
+        self.assert_warning_correct(self.ui.message, msg)
+        self.assertFalse(self.ui.message.active)
+
     def test_is_processing(self):
         """The flag 'is_processing' is False on start."""
         self.assertFalse(self.ui.is_processing)
 
=== modified file 'ubuntuone/controlpanel/gtk/tests/test_package_manager.py'
--- ubuntuone/controlpanel/gtk/tests/test_package_manager.py	2011-01-07 20:07:39 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_package_manager.py	2011-04-08 19:43:13 +0000
@@ -21,10 +21,10 @@
 import collections
 
 try:
-    # Unable to import 'defer', pylint: disable=F0401,E0611
+    # Unable to import 'defer', pylint: disable=F0401,E0611,W0404
     from aptdaemon import defer
 except ImportError:
-    # Unable to import 'defer', pylint: disable=F0401,E0611
+    # Unable to import 'defer', pylint: disable=F0401,E0611,W0404
     import defer
 
 from ubuntuone.controlpanel.gtk import package_manager
 
=== modified file 'ubuntuone/controlpanel/integrationtests/__init__.py'
--- ubuntuone/controlpanel/integrationtests/__init__.py	2010-12-22 13:33:25 +0000
+++ ubuntuone/controlpanel/integrationtests/__init__.py	2011-04-08 19:43:13 +0000
@@ -20,7 +20,6 @@
 """Integration tests for the Ubuntu One Control Panel."""
 
 import dbus
-import dbus.service
 
 from ubuntuone.devtools.testcase import DBusTestCase as TestCase
 
@@ -31,7 +30,7 @@
     """A DBus exception to be used in tests."""
 
 
-class MockDBusNoMethods(dbus.service.Object):
+class MockDBusNoMethods(dbus_service.dbus.service.Object):
     """A mock that fails at the DBus layer (because it's got no methods!)."""
 
 
 
=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_service.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2011-02-23 13:57:42 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2011-04-08 19:43:13 +0000
@@ -84,12 +84,23 @@
         rs = self.mocker.replace(rs_name)
         rs()
         self.mocker.result(True)
+
+        mainloop = "ubuntuone.controlpanel.dbus_service.gobject.MainLoop"
+        mainloop = self.mocker.replace(mainloop)
+        mainloop()
+        loop = self.mocker.mock()
+        self.mocker.result(loop)
+
+        shutdown_func = self.mocker.mock()
+        loop.quit  # pylint: disable=W0104
+        self.mocker.result(shutdown_func)
+
         rml_name = "ubuntuone.controlpanel.dbus_service.run_mainloop"
         rml = self.mocker.replace(rml_name)
-        rml()
+        rml(loop=loop)
         pb_name = "ubuntuone.controlpanel.dbus_service.publish_backend"
         pb = self.mocker.replace(pb_name)
-        pb()
+        pb(shutdown_func=shutdown_func)
         self.mocker.replay()
         dbus_service.main()
 
@@ -112,6 +123,10 @@
         dbus_service.STATUS_KEY: dbus_service.FILE_SYNC_IDLE,
     }
     status_changed_handler = None
+    shutdown_func = None
+
+    def __init__(self, shutdown_func=None):
+        MockBackend.shutdown_func = shutdown_func
 
     def _process(self, result):
         """Process the request with the given result."""
@@ -197,6 +212,10 @@
         """Install the extension to sync bookmarks."""
         return self._process(None)
 
+    def shutdown(self):
+        """Stop this service."""
+        self.shutdown_func()
+
 
 class DBusServiceTestCase(TestCase):
     """Test for the DBus service."""
@@ -289,7 +308,8 @@
     def setUp(self):
         super(BaseTestCase, self).setUp()
         dbus_service.init_mainloop()
-        be = dbus_service.publish_backend(MockBackend())
+        self.patch(dbus_service, 'ControlBackend', MockBackend)
+        be = dbus_service.publish_backend()
         self.addCleanup(be.remove_from_connection)
         bus = dbus.SessionBus()
         obj = bus.get_object(bus_name=DBUS_BUS_NAME,
@@ -604,6 +624,35 @@
             error_sig, success_sig, got_error_signal, method, *args)
 
 
+class OperationsAuthErrorTestCase(OperationsTestCase):
+    """Test for the DBus service operations when UnauthorizedError happens."""
+
+    def setUp(self):
+        super(OperationsAuthErrorTestCase, self).setUp()
+        self.patch(MockBackend, 'exception',
+                   dbus_service.UnauthorizedError)
+
+    def assert_correct_method_call(self, success_sig, error_sig, success_cb,
+                                   method, *args):
+        """Call parent instance expecting UnauthorizedError signal."""
+
+        def inner_success_cb(*a):
+            """The success signal was received."""
+            if len(a) == 1:
+                error_dict = a[0]
+            else:
+                an_id, error_dict = a
+                self.assertEqual(an_id, args[0])
+
+            self.assertEqual(error_dict[dbus_service.ERROR_TYPE],
+                             'UnauthorizedError')
+            self.deferred.callback('success')
+
+        parent = super(OperationsAuthErrorTestCase, self)
+        return parent.assert_correct_method_call(
+            "UnauthorizedError", error_sig, inner_success_cb, method, *args)
+
+
 class FileSyncTestCase(BaseTestCase):
     """Test for the DBus service when requesting file sync status."""
 
@@ -691,3 +740,18 @@
         cpbe = dbus_service.ControlPanelBackend(backend=be)
 
         self.assertEqual(be.status_changed_handler, cpbe.process_status)
+
+
+class ShutdownTestCase(BaseTestCase):
+    """Test for the DBus service shurdown."""
+
+    @defer.inlineCallbacks
+    def test_shutdown(self):
+        """The service can be shutdown."""
+        called = []
+        MockBackend.shutdown_func = lambda *a: called.append('shutdown')
+        self.backend.shutdown(reply_handler=lambda: self.deferred.callback(1),
+                              error_handler=self.got_error)
+        yield self.deferred
+
+        self.assertEqual(called, ['shutdown'])
 
=== added file 'ubuntuone/controlpanel/integrationtests/test_gui_service.py'
--- ubuntuone/controlpanel/integrationtests/test_gui_service.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/integrationtests/test_gui_service.py	2011-04-08 19:43:13 +0000
@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+
+# Authors: Alejandro J. Cura <[e-mail]>
+#          Natalia B. Bidart <[e-mail]>
+#          Eric Casteleijn <[e-mail]>
+#
+# Copyright 2011 Canonical Ltd.
+#
+# 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 warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""Tests for the control panel backend DBus service."""
+
+import dbus
+import mocker
+
+from dbus.mainloop.glib import DBusGMainLoop
+
+from ubuntuone.controlpanel.gtk import gui
+from ubuntuone.devtools.testcase import DBusTestCase
+from twisted.trial.unittest import TestCase
+
+
+class MockWindow(object):
+    """A mock backend."""
+
+    exception = None
+
+    def __init__(self, switch_to=None, alert=False):
+        self.called = []
+
+    def draw_attention(self):
+        """Draw attention to the control panel."""
+        self.called.append('draw_attention')
+
+    def switch_to(self, panel):
+        """Switch to named panel."""
+        self.called.append(('switch_to', panel))
+
+
+class DBusServiceMockTestCase(TestCase):
+    """Tests for the main function."""
+
+    def setUp(self):
+        self.mocker = mocker.Mocker()
+
+    def tearDown(self):
+        self.mocker.restore()
+        self.mocker.verify()
+
+    def test_dbus_service_main(self):
+        """The main method starts the loop and hooks up to DBus."""
+        self.patch(gui, 'ControlPanelWindow', MockWindow)
+        dbus_gmain_loop = self.mocker.replace(
+            "dbus.mainloop.glib.DBusGMainLoop")
+        register_service = self.mocker.replace(
+            "ubuntuone.controlpanel.gtk.gui.register_service")
+        publish_service = self.mocker.replace(
+            "ubuntuone.controlpanel.gtk.gui.publish_service")
+        main = self.mocker.replace("gtk.main")
+        dbus_gmain_loop(set_as_default=True)
+        loop = self.mocker.mock()
+        self.mocker.result(loop)
+        register_service(mocker.ANY)
+        self.mocker.result(True)
+        publish_service(switch_to='', alert=False)
+        main()
+        self.mocker.replay()
+        gui.main()
+
+
+class DBusServiceTestCase(DBusTestCase):
+    """Test for the DBus service."""
+
+    def _set_called(self, *args, **kwargs):
+        """Keep track of function calls, useful for monkeypatching."""
+        self._called = (args, kwargs)
+
+    def setUp(self):
+        """Initialize each test run."""
+        super(DBusServiceTestCase, self).setUp()
+        DBusGMainLoop(set_as_default=True)
+        self._called = False
+
+    def test_register_service(self):
+        """The DBus service is successfully registered."""
+        bus = dbus.SessionBus()
+        ret = gui.register_service(bus)
+        self.assertTrue(ret)
 
=== modified file 'ubuntuone/controlpanel/integrationtests/test_webclient.py'
--- ubuntuone/controlpanel/integrationtests/test_webclient.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/integrationtests/test_webclient.py	2011-04-08 19:43:13 +0000
@@ -73,6 +73,10 @@
         devices_resource.contents = SAMPLE_RESOURCE
         root.putChild("devices", devices_resource)
         root.putChild("throwerror", resource.NoResource())
+        unauthorized = resource.ErrorPage(resource.http.UNAUTHORIZED,
+                                          "Unauthrorized", "Unauthrorized")
+        root.putChild("unauthorized", unauthorized)
+
         site = server.Site(root)
         application = service.Application('web')
         self.service_collection = service.IServiceCollection(application)
@@ -96,7 +100,7 @@
 class WebClientTestCase(TestCase):
     """Test for the webservice client."""
 
-    timeout = 5
+    timeout = 8
 
     def setUp(self):
         super(WebClientTestCase, self).setUp()
@@ -123,6 +127,12 @@
         yield self.assertFailure(self.wc.call_api("throwerror"),
                                  webclient.WebClientError)
 
+    @inlineCallbacks
+    def test_unauthorized(self):
+        """Detect when a request failed with UNAUTHORIZED."""
+        yield self.assertFailure(self.wc.call_api("unauthorized"),
+                                 webclient.UnauthorizedError)
+
 
 class OAuthTestCase(TestCase):
     """Test for the oauth signing code."""
 
=== modified file 'ubuntuone/controlpanel/replication_client.py'
--- ubuntuone/controlpanel/replication_client.py	2011-01-07 20:07:39 +0000
+++ ubuntuone/controlpanel/replication_client.py	2011-04-08 19:43:13 +0000
@@ -57,7 +57,7 @@
     if replication_module is None:
         # delay import in case DC is not installed at module import time
         # Unable to import 'desktopcouch.application.replication_services'
-        # pylint: disable=F0401
+        # pylint: disable=W0404
         from desktopcouch.application.replication_services \
             import ubuntuone as replication_module
     try:
 
=== modified file 'ubuntuone/controlpanel/tests/__init__.py'
--- ubuntuone/controlpanel/tests/__init__.py	2011-03-10 02:59:44 +0000
+++ ubuntuone/controlpanel/tests/__init__.py	2011-04-08 19:43:13 +0000
@@ -23,7 +23,7 @@
 
 TOKEN = {u'consumer_key': u'xQ7xDAz',
          u'consumer_secret': u'KzCJWCTNbbntwfyCKKjomJDzlgqxLy',
-         u'token_name': u'test',
+         u'name': u'Ubuntu One @ localhost',
          u'token': u'ABCDEF01234-localtoken',
          u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
 
@@ -110,19 +110,31 @@
 ]
 """
 
+EMPTY_DESCRIPTION_JSON = """
+[
+    {
+        "token": "ABCDEF01234token",
+        "description": null,
+        "kind": "Computer"
+    }
+]
+"""
+
+LOCAL_DEVICE = {
+    'is_local': 'True',
+    'configurable': 'True',
+    'device_id': 'ComputerABCDEF01234-localtoken',
+    'limit_bandwidth': '',
+    'show_all_notifications': 'True',
+    'max_download_speed': '-1',
+    'max_upload_speed': '-1',
+    'name': 'Ubuntu One @ localhost',
+    'type': 'Computer',
+}
+
 # note that local computer should be first, do not change!
 EXPECTED_DEVICES_INFO = [
-    {
-        'is_local': 'True',
-        'configurable': 'True',
-        'device_id': 'ComputerABCDEF01234-localtoken',
-        'limit_bandwidth': '',
-        'show_all_notifications': 'True',
-        'max_download_speed': '-1',
-        'max_upload_speed': '-1',
-        'name': 'Ubuntu One @ localhost',
-        'type': 'Computer',
-    },
+    LOCAL_DEVICE,
     {
         "device_id": "ComputerABCDEF01234token",
         "name": "Ubuntu One @ darkstar",
 
=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2011-03-10 02:59:44 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2011-04-08 19:43:13 +0000
@@ -30,6 +30,7 @@
 from ubuntuone.controlpanel import backend, replication_client
 from ubuntuone.controlpanel.backend import (bool_str,
     ACCOUNT_API, DEVICES_API, DEVICE_REMOVE_API, QUOTA_API,
+    DEVICE_TYPE_COMPUTER,
     FILE_SYNC_DISABLED,
     FILE_SYNC_DISCONNECTED,
     FILE_SYNC_ERROR,
@@ -41,9 +42,11 @@
     MSG_KEY, STATUS_KEY,
 )
 from ubuntuone.controlpanel.tests import (TestCase,
+    EMPTY_DESCRIPTION_JSON,
     EXPECTED_ACCOUNT_INFO,
     EXPECTED_ACCOUNT_INFO_WITH_CURRENT_PLAN,
     EXPECTED_DEVICES_INFO,
+    LOCAL_DEVICE,
     ROOT_PATH,
     SAMPLE_ACCOUNT_NO_CURRENT_PLAN,
     SAMPLE_ACCOUNT_WITH_CURRENT_PLAN,
@@ -56,7 +59,6 @@
     SHARES_PATH_LINK,
     TOKEN,
 )
-from ubuntuone.controlpanel.webclient import WebClientError
 
 
 class MockWebClient(object):
@@ -70,8 +72,10 @@
 
     def call_api(self, method):
         """Get a given url from the webservice."""
-        if self.failure:
-            return defer.fail(WebClientError(self.failure))
+        if self.failure == 401:
+            return defer.fail(backend.UnauthorizedError(self.failure))
+        elif self.failure:
+            return defer.fail(backend.WebClientError(self.failure))
         else:
             result = simplejson.loads(self.results[method])
             return defer.succeed(result)
@@ -250,7 +254,7 @@
         self.patch(backend, "WebClient", MockWebClient)
         self.patch(backend, "dbus_client", MockDBusClient())
         self.patch(backend, "replication_client", MockReplicationClient())
-        self.local_token = "Computer" + TOKEN["token"]
+        self.local_token = DEVICE_TYPE_COMPUTER + TOKEN["token"]
         self.be = backend.ControlBackend()
 
         self.memento = MementoHandler()
@@ -278,6 +282,24 @@
         result = yield self.be.device_is_local(did)
         self.assertFalse(result)
 
+    def test_shutdown_func(self):
+        """A shutdown_func can be passed as creation parameter."""
+        f = lambda: None
+        be = backend.ControlBackend(shutdown_func=f)
+        self.assertEqual(be.shutdown_func, f)
+
+    def test_shutdown_func_is_called_on_shutdown(self):
+        """The shutdown_func is called on shutdown."""
+        self.be.shutdown_func = self._set_called
+        self.be.shutdown()
+        self.assertEqual(self._called, ((), {}))
+
+    def test_shutdown_func_when_none(self):
+        """The shutdown_func can be None."""
+        self.be.shutdown_func = None
+        self.be.shutdown()
+        # nothing explodes
+
 
 class BackendAccountTestCase(BackendBasicTestCase):
     """Account tests for the backend."""
@@ -305,7 +327,20 @@
         """The account_info method exercises its errback."""
         # pylint: disable=E1101
         self.be.wc.failure = 404
-        yield self.assertFailure(self.be.account_info(), WebClientError)
+        yield self.assertFailure(self.be.account_info(),
+                                 backend.WebClientError)
+
+    @inlineCallbacks
+    def test_account_info_fails_with_unauthorized(self):
+        """The account_info clears the credentials on unauthorized."""
+        # pylint: disable=E1101
+        self.be.wc.failure = 401
+        d = defer.Deferred()
+        self.patch(backend.dbus_client, 'clear_credentials',
+                   lambda: d.callback('called'))
+        yield self.assertFailure(self.be.account_info(),
+                                 backend.UnauthorizedError)
+        yield d
 
 
 class BackendDevicesTestCase(BackendBasicTestCase):
@@ -322,14 +357,86 @@
     @inlineCallbacks
     def test_devices_info_fails(self):
         """The devices_info method exercises its errback."""
+        def fail(*args, **kwargs):
+            """Raise any error other than WebClientError."""
+            raise ValueError(args)
+
+        self.patch(self.be.wc, 'call_api', fail)
+        yield self.assertFailure(self.be.devices_info(), ValueError)
+
+    @inlineCallbacks
+    def test_devices_info_with_webclient_error(self):
+        """The devices_info returns local info if webclient error."""
         # pylint: disable=E1101
         self.be.wc.failure = 404
-        yield self.assertFailure(self.be.devices_info(), WebClientError)
+        result = yield self.be.devices_info()
+
+        self.assertEqual(result, [LOCAL_DEVICE])
+        self.assertTrue(self.memento.check_error('devices_info',
+                                                 'web client failure'))
+
+    @inlineCallbacks
+    def test_devices_info_fails_with_unauthorized(self):
+        """The devices_info clears the credentials on unauthorized."""
+        # pylint: disable=E1101
+        self.be.wc.failure = 401
+        d = defer.Deferred()
+        self.patch(backend.dbus_client, 'clear_credentials',
+                   lambda: d.callback('called'))
+        yield self.assertFailure(self.be.devices_info(),
+                                 backend.UnauthorizedError)
+        yield d
+
+    @inlineCallbacks
+    def test_devices_info_if_files_disable(self):
+        """The devices_info returns device only info if files is disabled."""
+        yield self.be.disable_files()
+        status = yield self.be.file_sync_status()
+        assert status['status'] == backend.FILE_SYNC_DISABLED, status
+
+        # pylint: disable=E1101
+        self.be.wc.results[DEVICES_API] = SAMPLE_DEVICES_JSON
+        result = yield self.be.devices_info()
+
+        expected = EXPECTED_DEVICES_INFO[:]
+        for device in expected:
+            device.pop('limit_bandwidth', None)
+            device.pop('max_download_speed', None)
+            device.pop('max_upload_speed', None)
+            device.pop('show_all_notifications', None)
+            device['configurable'] = ''
+        self.assertEqual(result, expected)
+
+    @inlineCallbacks
+    def test_devices_info_when_token_name_is_empty(self):
+        """The devices_info can handle empty token names."""
+        # pylint: disable=E1101
+        self.be.wc.results[DEVICES_API] = EMPTY_DESCRIPTION_JSON
+        result = yield self.be.devices_info()
+        expected = {'configurable': '',
+                    'device_id': 'ComputerABCDEF01234token',
+                    'is_local': '', 'name': 'None',
+                    'type': DEVICE_TYPE_COMPUTER}
+        self.assertEqual(result, [expected])
+        self.assertTrue(self.memento.check_warning('name', 'None'))
+
+    @inlineCallbacks
+    def test_devices_info_does_not_log_device_id(self):
+        """The devices_info does not log the device_id."""
+        # pylint: disable=E1101
+        self.be.wc.results[DEVICES_API] = SAMPLE_DEVICES_JSON
+        yield self.be.devices_info()
+
+        dids = (d['device_id'] for d in EXPECTED_DEVICES_INFO)
+        device_id_logged = all(all(did not in r.getMessage()
+                                   for r in self.memento.records)
+                               for did in dids)
+        self.assertTrue(device_id_logged)
 
     @inlineCallbacks
     def test_remove_device(self):
         """The remove_device method calls the right api."""
-        dtype, did = "Computer", "SAMPLE-TOKEN"
+        dtype, did = DEVICE_TYPE_COMPUTER, "SAMPLE-TOKEN"
         device_id = dtype + did
         apiurl = DEVICE_REMOVE_API % (dtype.lower(), did)
         # pylint: disable=E1101
@@ -354,7 +461,30 @@
         """The remove_device method fails as expected."""
         # pylint: disable=E1101
         self.be.wc.failure = 404
-        yield self.assertFailure(self.be.devices_info(), WebClientError)
+        yield self.assertFailure(self.be.remove_device(self.local_token),
+                                 backend.WebClientError)
+
+    @inlineCallbacks
+    def test_remove_device_fails_with_unauthorized(self):
+        """The remove_device clears the credentials on unauthorized."""
+        # pylint: disable=E1101
+        self.be.wc.failure = 401
+        d = defer.Deferred()
+        self.patch(backend.dbus_client, 'clear_credentials',
+                   lambda: d.callback('called'))
+        yield self.assertFailure(self.be.remove_device(self.local_token),
+                                 backend.UnauthorizedError)
+        yield d
+
+    @inlineCallbacks
+    def test_remove_device_does_not_log_device_id(self):
+        """The remove_device does not log the device_id."""
+        device_id = DEVICE_TYPE_COMPUTER + TOKEN['token']
+        yield self.be.remove_device(device_id)
+
+        device_id_logged = all(device_id not in r.getMessage()
+                               for r in self.memento.records)
+        self.assertTrue(device_id_logged)
 
     @inlineCallbacks
     def test_change_show_all_notifications(self):
@@ -411,6 +541,16 @@
         self.assertEqual(backend.dbus_client.limits["upload"], -1)
         self.assertEqual(backend.dbus_client.limits["download"], -1)
 
+    @inlineCallbacks
+    def test_changing_settings_does_not_log_device_id(self):
+        """The change_device_settings does not log the device_id."""
+        device_id = 'yadda-yadda'
+        yield self.be.change_device_settings(device_id, {})
+
+        device_id_logged = all(device_id not in r.getMessage()
+                               for r in self.memento.records)
+        self.assertTrue(device_id_logged)
+
 
 class BackendVolumesTestCase(BackendBasicTestCase):
     """Volumes tests for the backend."""
@@ -581,6 +721,12 @@
 class BackendSyncStatusTestCase(BackendBasicTestCase):
     """Syncdaemon state for the backend."""
 
+    was_disabled = False
+
+    def setUp(self):
+        super(BackendSyncStatusTestCase, self).setUp()
+        self.be.file_sync_disabled = self.was_disabled
+
     def _build_msg(self):
         """Build expected message regarding file sync status."""
         return '%s (%s)' % (MockDBusClient.status['description'],
@@ -599,6 +745,7 @@
         """The syncdaemon status is processed and emitted."""
         self.patch(MockDBusClient, 'file_sync', False)
         yield self.assert_correct_status(FILE_SYNC_DISABLED, msg='')
+        self.assertTrue(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_error(self):
@@ -610,6 +757,8 @@
             'description': 'auth failed',
         }
         yield self.assert_correct_status(FILE_SYNC_ERROR)
+        # self.be.file_sync_disabled does not change
+        self.assertEqual(self.was_disabled, self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_starting_when_init_not_user(self):
@@ -620,6 +769,7 @@
             'name': 'INIT', 'description': 'something new',
         }
         yield self.assert_correct_status(FILE_SYNC_STARTING)
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_starting_when_init_with_user(self):
@@ -630,6 +780,7 @@
             'name': 'INIT', 'description': 'something new',
         }
         yield self.assert_correct_status(FILE_SYNC_STARTING)
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_starting_when_local_rescan_not_user(self):
@@ -640,6 +791,7 @@
             'name': 'LOCAL_RESCAN', 'description': 'something new',
         }
         yield self.assert_correct_status(FILE_SYNC_STARTING)
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_starting_when_local_rescan_with_user(self):
@@ -650,6 +802,7 @@
             'name': 'LOCAL_RESCAN', 'description': 'something new',
         }
         yield self.assert_correct_status(FILE_SYNC_STARTING)
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_starting_when_ready_with_user(self):
@@ -660,6 +813,7 @@
             'name': 'READY', 'description': 'something nicer',
         }
         yield self.assert_correct_status(FILE_SYNC_STARTING)
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_disconnected(self):
@@ -672,6 +826,9 @@
         }
         yield self.assert_correct_status(FILE_SYNC_DISCONNECTED)
 
+        # self.be.file_sync_disabled does not change
+        self.assertEqual(self.was_disabled, self.be.file_sync_disabled)
+
     @inlineCallbacks
     def test_disconnected_when_waiting(self):
         """The syncdaemon status is processed and emitted."""
@@ -682,6 +839,9 @@
         }
         yield self.assert_correct_status(FILE_SYNC_DISCONNECTED)
 
+        # self.be.file_sync_disabled does not change
+        self.assertEqual(self.was_disabled, self.be.file_sync_disabled)
+
     @inlineCallbacks
     def test_syncing_if_online(self):
         """The syncdaemon status is processed and emitted."""
@@ -693,6 +853,9 @@
         }
         yield self.assert_correct_status(FILE_SYNC_SYNCING)
 
+        # self.be.file_sync_disabled does not change
+        self.assertEqual(self.was_disabled, self.be.file_sync_disabled)
+
     @inlineCallbacks
     def test_syncing_even_if_not_online(self):
         """The syncdaemon status is processed and emitted."""
@@ -704,6 +867,9 @@
         }
         yield self.assert_correct_status(FILE_SYNC_SYNCING)
 
+        # self.be.file_sync_disabled does not change
+        self.assertEqual(self.was_disabled, self.be.file_sync_disabled)
+
     @inlineCallbacks
     def test_idle(self):
         """The syncdaemon status is processed and emitted."""
@@ -715,6 +881,9 @@
         }
         yield self.assert_correct_status(FILE_SYNC_IDLE)
 
+        # self.be.file_sync_disabled does not change
+        self.assertEqual(self.was_disabled, self.be.file_sync_disabled)
+
     @inlineCallbacks
     def test_stopped(self):
         """The syncdaemon status is processed and emitted."""
@@ -726,6 +895,9 @@
         }
         yield self.assert_correct_status(FILE_SYNC_STOPPED)
 
+        # self.be.file_sync_disabled does not change
+        self.assertEqual(self.was_disabled, self.be.file_sync_disabled)
+
     @inlineCallbacks
     def test_unknown(self):
         """The syncdaemon status is processed and emitted."""
@@ -740,6 +912,9 @@
                                                  repr(MockDBusClient.status))
         self.assertTrue(has_warning)
 
+        # self.be.file_sync_disabled does not change
+        self.assertEqual(self.was_disabled, self.be.file_sync_disabled)
+
     def test_status_changed(self):
         """The file_sync_status is the status changed handler."""
         self.be.status_changed_handler = self._set_called
@@ -754,6 +929,21 @@
         self.assertEqual(self._called, ((expected_status,), {}))
 
 
+class BackendSyncStatusIfDisabledTestCase(BackendSyncStatusTestCase):
+    """Syncdaemon state for the backend when file sync is disabled."""
+
+    was_disabled = True
+
+    @inlineCallbacks
+    def assert_correct_status(self, status, msg=None):
+        """Check that the resulting status is correct."""
+        sup = super(BackendSyncStatusIfDisabledTestCase, self)
+        if status != FILE_SYNC_STARTING:
+            yield sup.assert_correct_status(FILE_SYNC_DISABLED, msg='')
+        else:
+            yield sup.assert_correct_status(status, msg=msg)
+
+
 class BackendFileSyncOpsTestCase(BackendBasicTestCase):
     """Syncdaemon operations for the backend."""
 
@@ -768,6 +958,7 @@
 
         yield self.be.enable_files()
         self.assertTrue(MockDBusClient.file_sync)
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_disable_files(self):
@@ -776,6 +967,7 @@
 
         yield self.be.disable_files()
         self.assertFalse(MockDBusClient.file_sync)
+        self.assertTrue(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_connect_files(self):
@@ -783,6 +975,7 @@
         yield self.be.connect_files()
 
         self.assertEqual(MockDBusClient.actions, ['connect'])
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_disconnect_files(self):
@@ -790,6 +983,7 @@
         yield self.be.disconnect_files()
 
         self.assertEqual(MockDBusClient.actions, ['disconnect'])
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_restart_files(self):
@@ -797,6 +991,7 @@
         yield self.be.restart_files()
 
         self.assertEqual(MockDBusClient.actions, ['stop', 'start'])
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_start_files(self):
@@ -804,6 +999,7 @@
         yield self.be.start_files()
 
         self.assertEqual(MockDBusClient.actions, ['start'])
+        self.assertFalse(self.be.file_sync_disabled)
 
     @inlineCallbacks
     def test_stop_files(self):
@@ -811,6 +1007,7 @@
         yield self.be.stop_files()
 
         self.assertEqual(MockDBusClient.actions, ['stop'])
+        self.assertFalse(self.be.file_sync_disabled)
 
 
 class BackendReplicationsTestCase(BackendBasicTestCase):
 
=== modified file 'ubuntuone/controlpanel/utils.py'
--- ubuntuone/controlpanel/utils.py	2010-12-22 13:33:25 +0000
+++ ubuntuone/controlpanel/utils.py	2011-04-08 19:43:13 +0000
@@ -52,7 +52,7 @@
 
     # otherwise, try to load PROJECT_DIR from installation path
     try:
-        # pylint: disable=F0401, E0611
+        # pylint: disable=F0401, E0611, W0404
         from ubuntuone.controlpanel.constants import PROJECT_DIR
         return PROJECT_DIR
     except ImportError:
 
=== modified file 'ubuntuone/controlpanel/webclient.py'
--- ubuntuone/controlpanel/webclient.py	2010-12-22 13:33:25 +0000
+++ ubuntuone/controlpanel/webclient.py	2011-04-08 19:43:13 +0000
@@ -32,10 +32,18 @@
 logger = setup_logging('webclient')
 
 
+# full list of status codes
+# http://library.gnome.org/devel/libsoup/stable/libsoup-2.4-soup-status.html
+
+
 class WebClientError(Exception):
     """An http error happened while calling the webservice."""
 
 
+class UnauthorizedError(WebClientError):
+    """The request ended with bad_request, unauthorized or forbidden."""
+
+
 class WebClient(object):
     """A client for the u1 webservice."""
 
@@ -48,21 +56,24 @@
 
     def _handler(self, session, msg, d):
         """Handle the result of an http message."""
-        logger.debug("WebClient: got http response %d for uri %r",
+        logger.debug("got http response %d for uri %r",
                      msg.status_code, msg.get_uri().to_string(False))
         data = msg.response_body.data
         if msg.status_code == 200:
             result = simplejson.loads(data)
             d.callback(result)
         else:
-            e = WebClientError(msg.status_code, data)
+            if msg.status_code in (401,):
+                e = UnauthorizedError(msg.status_code, data)
+            else:
+                e = WebClientError(msg.status_code, data)
             d.errback(e)
 
     def _call_api_with_creds(self, credentials, api_name):
         """Get a given url from the webservice with credentials."""
         url = (self.base_url + api_name).encode('utf-8')
         method = "GET"
-        logger.debug("WebClient: getting url: %s, %s", method, url)
+        logger.debug("getting url: %s, %s", method, url)
         msg = Soup.Message.new(method, url)
         add_oauth_headers(msg.request_headers.append, method, url, credentials)
         d = defer.Deferred()
@@ -71,7 +82,8 @@
 
     def call_api(self, api_name):
         """Get a given url from the webservice."""
-        logger.debug("WebClient: calling api: %s", api_name)
+        # this may log device ID's, but only for removals, which is OK
+        logger.debug("calling api: %s", api_name)
         d = self.get_credentials()
         d.addCallback(self._call_api_with_creds, api_name)
         return d