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

[Natalia Bidart]

Added a button to file sync status to manage the files service (LP: #693373).

To test, open 2 terminals pointing to this branch and run:

terminal 1: DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-backend
terminal 2: DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-gtk

And play with the top right corner, you'll get syncdaemon status and buttons to manage the service.

NOTE: if you stop syncdaemon from the "outside" (u1sdtool -q), you need to run this branch as syncdaemon to be able to grab the quiting state change from it: lp:~nataliabidart/ubuntuone-client/send-status-changed-when-quitting

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

57. By Natalia Bidart on 2011-01-18

WAITING is actually disconnected.

58. By Natalia Bidart on 2011-01-19

Added tests for file sync button sensitivity.

[Roman Yepishev (rye)]

<rye> nessita, i mean why an "Action" is tied to the "Link" presentation? It's like if we had a music player with Stop, Play, Pause underlined labels instead of buttons...
<nessita> rye: is a design thing, putting a raw button calls too much user attention and that button is not 'important', since the user should almost never require using them
<nessita> rye: also, a button there gets mixed (in the eye) with the buttons in the tab bar
<nessita> (Dashboard, Folders, etc)
<nessita> rye: all the sync actions are links
<rye> nessita, blank tooltips that causes - http://ubuntuone.com/p/Z3a/
<nessita> rye: that's the button uri :-/
<nessita> rye: maybe I can set the name of the button as uri... not sure how much that can break
<nessita> rye: let me investigate a bit

review: Needs Fixing (fieldtest)

[Roman Yepishev (rye)]

Ok, approving since we need to have these buttons, filed LP:704895

review: Approve (fieldtest)

[Roberto Alsina (ralsina)]

+1, looks good

review: Approve

=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2011-01-06 20:33:15 +0000
+++ ubuntuone/controlpanel/backend.py	2011-01-19 12:21:44 +0000
@@ -43,6 +43,7 @@
 FILE_SYNC_ERROR = 'file-sync-error'
 FILE_SYNC_IDLE = 'file-sync-idle'
 FILE_SYNC_STARTING = 'file-sync-starting'
+FILE_SYNC_STOPPED = 'file-sync-stopped'
 FILE_SYNC_SYNCING = 'file-sync-syncing'
 FILE_SYNC_UNKNOWN = 'file-sync-unknown'
 
@@ -88,9 +89,11 @@
         is_error = bool(status['is_error'])
         is_synching = bool(status['is_connected'])
         is_idle = bool(status['is_online']) and status['queues'] == 'IDLE'
-        is_disconnected = status['name'] == 'READY' and \
-                          'Not User' in status['connection']
+        is_disconnected = status['name'] == 'WAITING' or \
+                          (status['name'] == 'READY' and \
+                           'Not User' in status['connection'])
         is_starting = status['name'] in ('INIT', 'LOCAL_RESCAN', 'READY')
+        is_stopped = status['name'] == 'SHUTDOWN'
 
         if is_error:
             result[STATUS_KEY] = FILE_SYNC_ERROR
@@ -102,6 +105,8 @@
             result[STATUS_KEY] = FILE_SYNC_DISCONNECTED
         elif is_starting:
             result[STATUS_KEY] = FILE_SYNC_STARTING
+        elif is_stopped:
+            result[STATUS_KEY] = FILE_SYNC_STOPPED
         else:
             logger.warning('file_sync_status: unknown (got %r)', status)
             result[STATUS_KEY] = FILE_SYNC_UNKNOWN
@@ -289,6 +294,37 @@
 
     @log_call(logger.debug)
     @inlineCallbacks
+    def connect_files(self):
+        """Connect the files service."""
+        yield dbus_client.connect_file_sync()
+
+    @log_call(logger.debug)
+    @inlineCallbacks
+    def disconnect_files(self):
+        """Disconnect the files service."""
+        yield dbus_client.disconnect_file_sync()
+
+    @log_call(logger.debug)
+    @inlineCallbacks
+    def restart_files(self):
+        """restart the files service."""
+        yield dbus_client.stop_file_sync()
+        yield dbus_client.start_file_sync()
+
+    @log_call(logger.debug)
+    @inlineCallbacks
+    def start_files(self):
+        """start the files service."""
+        yield dbus_client.start_file_sync()
+
+    @log_call(logger.debug)
+    @inlineCallbacks
+    def stop_files(self):
+        """stop the files service."""
+        yield dbus_client.stop_file_sync()
+
+    @log_call(logger.debug)
+    @inlineCallbacks
     def volumes_info(self):
         """Get the volumes info."""
         result = yield dbus_client.get_folders()

=== modified file 'ubuntuone/controlpanel/dbus_client.py'
--- ubuntuone/controlpanel/dbus_client.py	2011-01-04 21:28:51 +0000
+++ ubuntuone/controlpanel/dbus_client.py	2011-01-19 12:21:44 +0000
@@ -309,3 +309,27 @@
 def set_files_sync_enabled(enabled):
     """Set the file sync service to be 'enabled'."""
     yield SyncDaemonTool(bus=dbus.SessionBus()).enable_files_sync(enabled)
+
+
[e-mail]
+def connect_file_sync():
+    """Connect the file sync service."""
+    yield SyncDaemonTool(bus=dbus.SessionBus()).connect()
+
+
[e-mail]
+def disconnect_file_sync():
+    """Disconnect the file sync service."""
+    yield SyncDaemonTool(bus=dbus.SessionBus()).disconnect()
+
+
[e-mail]
+def start_file_sync():
+    """Start the file sync service."""
+    yield SyncDaemonTool(bus=dbus.SessionBus()).start()
+
+
[e-mail]
+def stop_file_sync():
+    """Stop the file sync service."""
+    yield SyncDaemonTool(bus=dbus.SessionBus()).quit()

=== modified file 'ubuntuone/controlpanel/dbus_service.py'
--- ubuntuone/controlpanel/dbus_service.py	2011-01-06 20:33:15 +0000
+++ ubuntuone/controlpanel/dbus_service.py	2011-01-19 12:21:44 +0000
@@ -31,7 +31,8 @@
     DBUS_PREFERENCES_IFACE)
 from ubuntuone.controlpanel.backend import (
     ControlBackend, FILE_SYNC_DISABLED, FILE_SYNC_DISCONNECTED,
-    FILE_SYNC_ERROR, FILE_SYNC_IDLE, FILE_SYNC_STARTING, FILE_SYNC_SYNCING,
+    FILE_SYNC_ERROR, FILE_SYNC_IDLE, FILE_SYNC_STARTING, FILE_SYNC_STOPPED,
+    FILE_SYNC_SYNCING,
     MSG_KEY, STATUS_KEY,
 )
 from ubuntuone.controlpanel.logger import setup_logging, log_call
@@ -196,6 +197,8 @@
             self.FileSyncStatusDisabled(msg)
         elif status == FILE_SYNC_STARTING:
             self.FileSyncStatusStarting(msg)
+        elif status == FILE_SYNC_STOPPED:
+            self.FileSyncStatusStopped(msg)
         elif status == FILE_SYNC_DISCONNECTED:
             self.FileSyncStatusDisconnected(msg)
         elif status == FILE_SYNC_SYNCING:
@@ -231,6 +234,11 @@
 
     @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusStopped(self, msg):
+        """The file sync service is stopped."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
     def FileSyncStatusDisconnected(self, msg):
         """The file sync service is waiting for user to request connection."""
 
@@ -298,6 +306,106 @@
 
     @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
+    def connect_files(self):
+        """Connect the files service."""
+        d = self.backend.connect_files()
+        d.addCallback(lambda _: self.FilesConnected())
+        d.addErrback(transform_failure(self.FilesConnectError))
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
+    def FilesConnected(self):
+        """The files service is connected."""
+
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
+    def FilesConnectError(self, error):
+        """Problem connecting the files service."""
+
+    #---
+
+    @log_call(logger.debug)
+    @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
+    def disconnect_files(self):
+        """Disconnect the files service."""
+        d = self.backend.disconnect_files()
+        d.addCallback(lambda _: self.FilesDisconnected())
+        d.addErrback(transform_failure(self.FilesDisconnectError))
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
+    def FilesDisconnected(self):
+        """The files service is disconnected."""
+
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
+    def FilesDisconnectError(self, error):
+        """Problem disconnecting the files service."""
+
+    #---
+
+    @log_call(logger.debug)
+    @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
+    def restart_files(self):
+        """Restart the files service."""
+        d = self.backend.restart_files()
+        d.addCallback(lambda _: self.FilesRestarted())
+        d.addErrback(transform_failure(self.FilesRestartError))
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
+    def FilesRestarted(self):
+        """The files service is restarted."""
+
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
+    def FilesRestartError(self, error):
+        """Problem restarting the files service."""
+
+    #---
+
+    @log_call(logger.debug)
+    @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
+    def start_files(self):
+        """Start the files service."""
+        d = self.backend.start_files()
+        d.addCallback(lambda _: self.FilesStarted())
+        d.addErrback(transform_failure(self.FilesStartError))
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
+    def FilesStarted(self):
+        """The files service is started."""
+
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
+    def FilesStartError(self, error):
+        """Problem starting the files service."""
+
+    #---
+
+    @log_call(logger.debug)
+    @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
+    def stop_files(self):
+        """Stop the files service."""
+        d = self.backend.stop_files()
+        d.addCallback(lambda _: self.FilesStopped())
+        d.addErrback(transform_failure(self.FilesStopError))
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
+    def FilesStopped(self):
+        """The files service is stopped."""
+
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
+    def FilesStopError(self, error):
+        """Problem stopping the files service."""
+
+    #---
+
+    @log_call(logger.debug)
+    @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def volumes_info(self):
         """Find out the volumes info for the logged in user."""
         d = self.backend.volumes_info()

=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2011-01-06 20:18:29 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2011-01-19 12:21:44 +0000
@@ -1048,40 +1048,41 @@
             self.on_error()
 
 
-class ManagementPanel(gtk.VBox, ControlPanelMixin):
-    """The management panel.
-
-    The user can manage dashboard, folders, devices and services.
-
-    """
-
-    QUOTA_LABEL = _('%(used)s used of %(total)s (%(percentage).1f%%)')
-    FILE_SYNC_DISABLED = _('File synchronization service is not enabled.')
-    FILE_SYNC_STARTING = _('File synchronization service is starting,\n'
-                           'please wait...')
-    FILE_SYNC_DISCONNECTED = _('File synchronization service is ready,\nplease'
-                               ' connect it to access your personal cloud. ')
-    FILE_SYNC_SYNCING = _('File synchronization service is fully functional,\n'
-                          'performing synchronization now...')
-    FILE_SYNC_IDLE = _('File synchronization service is idle,\n'
-                       'all the files are synchronized.')
-    FILE_SYNC_ERROR = _('File synchronization status can not be retrieved.')
+class FileSyncStatus(gtk.HBox, ControlPanelMixin):
+    """A file sync status widget."""
+
+    FILE_SYNC_DISABLED = _('File synchronization is disabled.')
+    FILE_SYNC_STARTING = _('File synchronization starting...')
+    FILE_SYNC_STOPPED = _('File synchronization is stopped.')
+    FILE_SYNC_DISCONNECTED = _('File synchronization is disconnected.')
+    FILE_SYNC_SYNCING = _('Synchronization in progress...')
+    FILE_SYNC_IDLE = _('All files up-to-date.')
+    FILE_SYNC_ERROR = _('File synchronization error.')
+
+    CONNECT = _('Connect')
+    DISCONNECT = _('Disconnect')
+    ENABLE = _('Enable')
+    RESTART = _('Restart')
+    START = _('Start')
+    STOP = _('Stop')
 
     def __init__(self):
-        gtk.VBox.__init__(self)
-        ControlPanelMixin.__init__(self, filename='management.ui')
-        self.add(self.itself)
-        self.show()
-
-        self.backend.connect_to_signal('AccountInfoReady',
-                                       self.on_account_info_ready)
-        self.backend.connect_to_signal('AccountInfoError',
-                                       self.on_account_info_error)
+        gtk.HBox.__init__(self)
+        ControlPanelMixin.__init__(self)
+
+        self.label = LabelLoading(LOADING, fg_color=DEFAULT_FG)
+        self.pack_start(self.label, expand=False)
+
+        self.button = gtk.LinkButton(uri='')
+        self.button.connect('clicked', self._on_button_clicked)
+        self.pack_start(self.button, expand=False)
 
         self.backend.connect_to_signal('FileSyncStatusDisabled',
                                        self.on_file_sync_status_disabled)
         self.backend.connect_to_signal('FileSyncStatusStarting',
                                        self.on_file_sync_status_starting)
+        self.backend.connect_to_signal('FileSyncStatusStopped',
+                                       self.on_file_sync_status_stopped)
         self.backend.connect_to_signal('FileSyncStatusDisconnected',
                                        self.on_file_sync_status_disconnected)
         self.backend.connect_to_signal('FileSyncStatusSyncing',
@@ -1090,13 +1091,144 @@
                                        self.on_file_sync_status_idle)
         self.backend.connect_to_signal('FileSyncStatusError',
                                        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()
+
+    def _update_status(self, msg, action, callback, icon=None, color=None):
+        """Update the status info."""
+        if icon is not None:
+            foreground = '' if color is None else 'foreground="%s"' % color
+            msg = '<span %s>%s</span> %s' % (foreground, icon, msg)
+        self.label.set_markup(msg)
+        self.label.stop()
+
+        self.button.set_label(action)
+        self.button.set_sensitive(True)
+        self.button.set_data('callback', callback)
+
+    def _on_button_clicked(self, button):
+        """Button was clicked, act accordingly the label."""
+        button.set_visited(False)
+        button.set_sensitive(False)
+        button.get_data('callback')(button)
+
+    @log_call(logger.info)
+    def on_file_sync_status_disabled(self, msg):
+        """Backend notifies of file sync status being disabled."""
+        self._update_status(self.FILE_SYNC_DISABLED,
+                            self.ENABLE, self.on_enable_clicked,
+                            '✘', 'red')
+
+    @log_call(logger.info)
+    def on_file_sync_status_starting(self, msg):
+        """Backend notifies of file sync status being starting."""
+        self._update_status(self.FILE_SYNC_STARTING,
+                            self.STOP, self.on_stop_clicked,
+                            '⇅', ORANGE)
+
+    @log_call(logger.info)
+    def on_file_sync_status_stopped(self, msg):
+        """Backend notifies of file sync being stopped."""
+        self._update_status(self.FILE_SYNC_STOPPED,
+                            self.START, self.on_start_clicked,
+                            '✘', 'red')
+
+    @log_call(logger.info)
+    def on_file_sync_status_disconnected(self, msg):
+        """Backend notifies of file sync status being ready."""
+        self._update_status(self.FILE_SYNC_DISCONNECTED,
+                            self.CONNECT, self.on_connect_clicked,
+                            '✘', 'red')
+
+    @log_call(logger.info)
+    def on_file_sync_status_syncing(self, msg):
+        """Backend notifies of file sync status being syncing."""
+        self._update_status(self.FILE_SYNC_SYNCING,
+                            self.DISCONNECT, self.on_disconnect_clicked,
+                            '⇅', ORANGE)
+
+    @log_call(logger.info)
+    def on_file_sync_status_idle(self, msg):
+        """Backend notifies of file sync status being idle."""
+        self._update_status(self.FILE_SYNC_IDLE,
+                            self.DISCONNECT, self.on_disconnect_clicked,
+                            '✔', 'green')
+
+    @log_call(logger.error)
+    def on_file_sync_status_error(self, error_dict=None):
+        """Backend notifies of an error when fetching file sync status."""
+        self._update_status(WARNING_MARKUP % self.FILE_SYNC_ERROR,
+                            self.RESTART, self.on_restart_clicked)
+
+    @log_call(logger.error)
+    def on_files_start_error(self, error_dict=None):
+        """Backend notifies of an error when starting the files service."""
+        # service is probably disabled, ask for status to backend
+        self.backend.file_sync_status(reply_handler=NO_OP,
+                                      error_handler=error_handler)
+
+    def on_connect_clicked(self, button=None):
+        """User requested connection."""
+        self.backend.connect_files(reply_handler=NO_OP,
+                                   error_handler=error_handler)
+
+    def on_disconnect_clicked(self, button=None):
+        """User requested disconnection."""
+        self.backend.disconnect_files(reply_handler=NO_OP,
+                                      error_handler=error_handler)
+
+    def on_enable_clicked(self, button=None):
+        """User requested enable the service."""
+        self.backend.enable_files(reply_handler=NO_OP,
+                                  error_handler=error_handler)
+
+    def on_restart_clicked(self, button=None):
+        """User requested restart the service."""
+        self.backend.restart_files(reply_handler=NO_OP,
+                                   error_handler=error_handler)
+
+    def on_start_clicked(self, button=None):
+        """User requested start the service."""
+        self.backend.start_files(reply_handler=NO_OP,
+                                 error_handler=error_handler)
+
+    def on_stop_clicked(self, button=None):
+        """User requested stop the service."""
+        self.backend.stop_files(reply_handler=NO_OP,
+                                error_handler=error_handler)
+
+
+class ManagementPanel(gtk.VBox, ControlPanelMixin):
+    """The management panel.
+
+    The user can manage dashboard, folders, devices and services.
+
+    """
+
+    QUOTA_LABEL = _('%(used)s used of %(total)s (%(percentage).1f%%)')
+
+    def __init__(self):
+        gtk.VBox.__init__(self)
+        ControlPanelMixin.__init__(self, filename='management.ui')
+        self.add(self.itself)
+        self.show()
+
+        self.backend.connect_to_signal('AccountInfoReady',
+                                       self.on_account_info_ready)
+        self.backend.connect_to_signal('AccountInfoError',
+                                       self.on_account_info_error)
 
         self.header.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(DEFAULT_BG))
 
+        self.quota_progressbar.set_sensitive(False)
         self.quota_label = LabelLoading(LOADING, fg_color=DEFAULT_FG)
         self.quota_box.pack_start(self.quota_label, expand=False)
 
-        self.status_label = LabelLoading(LOADING, fg_color=DEFAULT_FG)
+        self.status_label = FileSyncStatus()
         self.status_box.pack_end(self.status_label, expand=False)
 
         self.dashboard = DashboardPanel()
@@ -1131,17 +1263,10 @@
             fraction = data.get('percentage', 0.0) / 100
         self.quota_progressbar.set_fraction(fraction)
 
-    def _update_status(self, msg):
-        """Update the status info."""
-        self.status_label.set_markup(msg)
-        self.status_label.stop()
-
     def load(self):
         """Load the account info and file sync status list."""
         self.backend.account_info(reply_handler=NO_OP,
                                   error_handler=error_handler)
-        self.backend.file_sync_status(reply_handler=NO_OP,
-                                      error_handler=error_handler)
         self.dashboard_button.clicked()
 
     @log_call(logger.debug)
@@ -1158,36 +1283,6 @@
         """Backend notifies of an error when fetching account info."""
         self._update_quota(WARNING_MARKUP % VALUE_ERROR)
 
-    @log_call(logger.info)
-    def on_file_sync_status_disabled(self, msg):
-        """Backend notifies of file sync status being disabled."""
-        self._update_status(self.FILE_SYNC_DISABLED)
-
-    @log_call(logger.info)
-    def on_file_sync_status_starting(self, msg):
-        """Backend notifies of file sync status being starting."""
-        self._update_status(self.FILE_SYNC_STARTING)
-
-    @log_call(logger.info)
-    def on_file_sync_status_disconnected(self, msg):
-        """Backend notifies of file sync status being ready."""
-        self._update_status(self.FILE_SYNC_DISCONNECTED)
-
-    @log_call(logger.info)
-    def on_file_sync_status_syncing(self, msg):
-        """Backend notifies of file sync status being syncing."""
-        self._update_status(self.FILE_SYNC_SYNCING)
-
-    @log_call(logger.info)
-    def on_file_sync_status_idle(self, msg):
-        """Backend notifies of file sync status being idle."""
-        self._update_status(self.FILE_SYNC_IDLE)
-
-    @log_call(logger.error)
-    def on_file_sync_status_error(self, error_dict=None):
-        """Backend notifies of an error when fetching file sync status."""
-        self._update_status(WARNING_MARKUP % self.FILE_SYNC_ERROR)
-
 
 gobject.signal_new('credentials-found', OverviewPanel,
                     gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

=== modified file 'ubuntuone/controlpanel/gtk/tests/__init__.py'
--- ubuntuone/controlpanel/gtk/tests/__init__.py	2011-01-05 21:04:07 +0000
+++ ubuntuone/controlpanel/gtk/tests/__init__.py	2011-01-19 12:21:44 +0000
@@ -131,6 +131,8 @@
         'volumes_info', 'change_volume_settings',  # volumes
         'replications_info', 'change_replication_settings',  # replications
         'file_sync_status', 'enable_files', 'disable_files',  # files
+        'connect_files', 'disconnect_files',
+        'restart_files', 'start_files', 'stop_files',
     ]
 
 

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-01-06 20:18:29 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-01-19 12:21:44 +0000
@@ -1795,6 +1795,179 @@
         self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
 
 
+class FileSyncStatusTestCase(ControlPanelMixinTestCase):
+    """Test case for a file sync status widget."""
+
+    klass = gui.FileSyncStatus
+
+    def assert_status_correct(self, status, action=None, callback=None):
+        """The shown status is correct.
+
+        * The ui's label shows 'status'.
+        * If action is not None, the ui's button shows that 'action' as label
+        and when clicking it, 'self._set_called' gets executed.
+        * If action is None, the ui's button should be hidden.
+
+        """
+        self.assertTrue(self.ui.label.get_visible())
+        self.assertFalse(self.ui.label.active)
+        self.assertTrue(self.ui.label.get_label().endswith(status))
+
+        self.assertTrue(self.ui.button.is_sensitive())
+        self.assertFalse(self.ui.button.get_visited())
+
+        if action is not None:
+            self.assertTrue(self.ui.button.get_visible())
+            self.assertTrue(self.ui.button.get_sensitive())
+            self.assertEqual(self.ui.button.get_label(), action)
+
+            self.ui.button.clicked()
+            self.assertFalse(self.ui.button.get_visited())
+            self.assertFalse(self.ui.button.get_sensitive())
+            self.assertEqual(self._called, ((self.ui.button,), {}))
+        else:
+            self.assertFalse(self.ui.button.get_visible())
+
+    def test_is_a_box(self):
+        """Inherits from gtk.Box."""
+        self.assertIsInstance(self.ui, gui.gtk.Box)
+
+    def test_startup_visibility(self):
+        """The widget is visible at startup."""
+        self.assertTrue(self.ui.get_visible(),
+                        'must be visible at startup.')
+
+    def test_label(self):
+        """The label is packed."""
+        self.assertIsInstance(self.ui.label, gui.LabelLoading)
+        self.assertTrue(self.ui.label.active)
+        self.assertIn(self.ui.label, self.ui.get_children())
+
+    def test_button(self):
+        """The button is packed."""
+        self.assertIn(self.ui.button, self.ui.get_children())
+
+    def test_backend_file_sync_signals(self):
+        """The proper signals are connected to the backend."""
+        matches = (
+            # status
+            ('FileSyncStatusDisabled', [self.ui.on_file_sync_status_disabled]),
+            ('FileSyncStatusStarting', [self.ui.on_file_sync_status_starting]),
+            ('FileSyncStatusStopped', [self.ui.on_file_sync_status_stopped]),
+            ('FileSyncStatusDisconnected',
+             [self.ui.on_file_sync_status_disconnected]),
+            ('FileSyncStatusSyncing', [self.ui.on_file_sync_status_syncing]),
+            ('FileSyncStatusIdle', [self.ui.on_file_sync_status_idle]),
+            ('FileSyncStatusError', [self.ui.on_file_sync_status_error]),
+            ('FilesStartError', [self.ui.on_files_start_error]),
+        )
+        for sig, handlers in matches:
+            self.assertEqual(self.ui.backend._signals[sig], handlers)
+
+    def test_file_sync_status_is_requested(self):
+        """The file sync status is requested to the backend."""
+        self.assert_backend_called('file_sync_status', ())
+
+    def test_on_file_sync_status_disabled(self):
+        """The file sync is disabled."""
+        self.patch(self.ui, 'on_enable_clicked', self._set_called)
+        self.ui.on_file_sync_status_disabled('msg')
+
+        self.assert_status_correct(self.ui.FILE_SYNC_DISABLED,
+                                   action=self.ui.ENABLE)
+
+    def test_on_file_sync_status_starting(self):
+        """The file sync status is starting."""
+        self.patch(self.ui, 'on_stop_clicked', self._set_called)
+        self.ui.on_file_sync_status_starting('msg')
+
+        self.assert_status_correct(self.ui.FILE_SYNC_STARTING,
+                                   action=self.ui.STOP)
+
+    def test_on_file_sync_status_stopped(self):
+        """The file sync is stopped."""
+        self.patch(self.ui, 'on_start_clicked', self._set_called)
+        self.ui.on_file_sync_status_stopped('msg')
+
+        self.assert_status_correct(self.ui.FILE_SYNC_STOPPED,
+                                   action=self.ui.START)
+
+    def test_on_file_sync_status_disconnected(self):
+        """The file sync status is disconnected."""
+        self.patch(self.ui, 'on_connect_clicked', self._set_called)
+        self.ui.on_file_sync_status_disconnected('msg')
+
+        self.assert_status_correct(self.ui.FILE_SYNC_DISCONNECTED,
+                                   action=self.ui.CONNECT)
+
+    def test_on_file_sync_status_syncing(self):
+        """The file sync status is syncing."""
+        self.patch(self.ui, 'on_disconnect_clicked', self._set_called)
+        self.ui.on_file_sync_status_syncing('msg')
+
+        self.assert_status_correct(self.ui.FILE_SYNC_SYNCING,
+                                   action=self.ui.DISCONNECT)
+
+    def test_on_file_sync_status_idle(self):
+        """The file sync status is idle."""
+        self.patch(self.ui, 'on_disconnect_clicked', self._set_called)
+        self.ui.on_file_sync_status_idle('msg')
+
+        self.assert_status_correct(self.ui.FILE_SYNC_IDLE,
+                                   action=self.ui.DISCONNECT)
+
+    def test_on_file_sync_status_error(self):
+        """The file sync status couldn't be retrieved."""
+        self.patch(self.ui, 'on_restart_clicked', self._set_called)
+        self.ui.on_file_sync_status_error({'error_msg': 'error msg'})
+
+        msg = gui.WARNING_MARKUP % self.ui.FILE_SYNC_ERROR
+        self.assert_status_correct(msg, action=self.ui.RESTART)
+
+    def test_on_files_start_error(self):
+        """The files service could not be started."""
+        self.ui.backend._called.clear()
+        self.ui.on_files_start_error({'error_msg': 'error msg'})
+
+        self.assert_backend_called('file_sync_status', ())
+
+    def test_on_connect_clicked(self):
+        """User requested connection."""
+        self.ui.on_connect_clicked(self.ui.button)
+
+        self.assert_backend_called('connect_files', ())
+
+    def test_on_disconnect_clicked(self):
+        """User requested disconnection."""
+        self.ui.on_disconnect_clicked(self.ui.button)
+
+        self.assert_backend_called('disconnect_files', ())
+
+    def test_on_enable_clicked(self):
+        """User requested enable the service."""
+        self.ui.on_enable_clicked(self.ui.button)
+
+        self.assert_backend_called('enable_files', ())
+
+    def test_on_restart_clicked(self):
+        """User requested restart the service."""
+        self.ui.on_restart_clicked(self.ui.button)
+
+        self.assert_backend_called('restart_files', ())
+
+    def test_on_start_clicked(self):
+        """User requested start the service."""
+        self.ui.on_start_clicked(self.ui.button)
+
+        self.assert_backend_called('start_files', ())
+
+    def test_on_stop_clicked(self):
+        """User requested stop the service."""
+        self.ui.on_stop_clicked(self.ui.button)
+
+        self.assert_backend_called('stop_files', ())
+
+
 class ManagementPanelTestCase(ControlPanelMixinTestCase):
     """The test suite for the management panel."""
 
@@ -1925,93 +2098,26 @@
         self.assertIsInstance(self.ui.quota_label, gui.LabelLoading)
         self.assertIn(self.ui.quota_label, self.ui.quota_box.get_children())
 
-    def test_file_sync_status_placeholder_is_loading(self):
-        """Placeholders for file sync label is a Loading widget."""
-        self.assertIsInstance(self.ui.status_label, gui.LabelLoading)
+    def test_on_account_info_ready(self):
+        """The account info is processed when ready."""
+        self.ui.on_account_info_ready(FAKE_ACCOUNT_INFO)
+        self.assert_account_info_correct(FAKE_ACCOUNT_INFO)
+
+        for widget in (self.ui.quota_label,):
+            self.assertFalse(widget.active)
+
+    def test_on_account_info_error(self):
+        """The account info couldn't be retrieved."""
+        self.ui.on_account_info_error()
+        for widget in (self.ui.quota_label,):
+            self.assert_warning_correct(widget, gui.VALUE_ERROR)
+            self.assertFalse(widget.active)
+
+    def test_file_sync_status(self):
+        """The file sync status is shown correctly."""
+        self.assertIsInstance(self.ui.status_label, gui.FileSyncStatus)
         self.assertIn(self.ui.status_label, self.ui.status_box.get_children())
 
-    def test_on_account_info_ready(self):
-        """The account info is processed when ready."""
-        self.ui.on_account_info_ready(FAKE_ACCOUNT_INFO)
-        self.assert_account_info_correct(FAKE_ACCOUNT_INFO)
-
-        for widget in (self.ui.quota_label,):
-            self.assertFalse(widget.active)
-
-    def test_on_account_info_error(self):
-        """The account info couldn't be retrieved."""
-        self.ui.on_account_info_error()
-        for widget in (self.ui.quota_label,):
-            self.assert_warning_correct(widget, gui.VALUE_ERROR)
-            self.assertFalse(widget.active)
-
-    def test_backend_file_sync_signals(self):
-        """The proper signals are connected to the backend."""
-        matches = (
-            ('FileSyncStatusDisabled', [self.ui.on_file_sync_status_disabled]),
-            ('FileSyncStatusStarting', [self.ui.on_file_sync_status_starting]),
-            ('FileSyncStatusDisconnected',
-             [self.ui.on_file_sync_status_disconnected]),
-            ('FileSyncStatusSyncing', [self.ui.on_file_sync_status_syncing]),
-            ('FileSyncStatusIdle', [self.ui.on_file_sync_status_idle]),
-            ('FileSyncStatusError', [self.ui.on_file_sync_status_error]),
-        )
-        for sig, handlers in matches:
-            self.assertEqual(self.ui.backend._signals[sig], handlers)
-
-    def test_file_sync_status_is_requested_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):
-        """The file sync is disabled."""
-        self.ui.on_file_sync_status_disabled('msg')
-
-        self.assertFalse(self.ui.status_label.active)
-        self.assertEqual(self.ui.status_label.get_text(),
-                         self.ui.FILE_SYNC_DISABLED)
-
-    def test_on_file_sync_status_starting(self):
-        """The file sync status is starting."""
-        self.ui.on_file_sync_status_starting('msg')
-
-        self.assertFalse(self.ui.status_label.active)
-        self.assertEqual(self.ui.status_label.get_text(),
-                         self.ui.FILE_SYNC_STARTING)
-
-    def test_on_file_sync_status_disconnected(self):
-        """The file sync status is disconnected."""
-        self.ui.on_file_sync_status_disconnected('msg')
-
-        self.assertFalse(self.ui.status_label.active)
-        self.assertEqual(self.ui.status_label.get_text(),
-                         self.ui.FILE_SYNC_DISCONNECTED)
-
-    def test_on_file_sync_status_syncing(self):
-        """The file sync status is syncing."""
-        self.ui.on_file_sync_status_syncing('msg')
-
-        self.assertFalse(self.ui.status_label.active)
-        self.assertEqual(self.ui.status_label.get_text(),
-                         self.ui.FILE_SYNC_SYNCING)
-
-    def test_on_file_sync_status_idle(self):
-        """The file sync status is idle."""
-        self.ui.on_file_sync_status_idle('msg')
-
-        self.assertFalse(self.ui.status_label.active)
-        self.assertEqual(self.ui.status_label.get_text(),
-                         self.ui.FILE_SYNC_IDLE)
-
-    def test_on_file_sync_status_error(self):
-        """The file sync status couldn't be retrieved."""
-        self.ui.on_file_sync_status_error({'error_msg': 'error msg'})
-
-        self.assert_warning_correct(self.ui.status_label,
-                                    self.ui.FILE_SYNC_ERROR)
-        self.assertFalse(self.ui.status_label.active)
-
     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)

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py	2010-12-13 22:13:05 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py	2011-01-19 12:21:44 +0000
@@ -507,7 +507,39 @@
         self.patch(dbus_client.SyncDaemonTool, 'enable_files_sync',
                    self._set_called)
         expected = object()
-        # set the opposite value
+        # set some unique value
         yield dbus_client.set_files_sync_enabled(expected)
 
         self.assertEqual(self._called, ((expected,), {}))
+
+    @inlineCallbacks
+    def test_connect_file_sync(self):
+        """Set if file sync is enabled or not."""
+        self.patch(dbus_client.SyncDaemonTool, 'connect', self._set_called)
+        yield dbus_client.connect_file_sync()
+
+        self.assertEqual(self._called, ((), {}))
+
+    @inlineCallbacks
+    def test_disconnect_file_sync(self):
+        """Set if file sync is enabled or not."""
+        self.patch(dbus_client.SyncDaemonTool, 'disconnect', self._set_called)
+        yield dbus_client.disconnect_file_sync()
+
+        self.assertEqual(self._called, ((), {}))
+
+    @inlineCallbacks
+    def test_start_file_sync(self):
+        """Set if file sync is enabled or not."""
+        self.patch(dbus_client.SyncDaemonTool, 'start', self._set_called)
+        yield dbus_client.start_file_sync()
+
+        self.assertEqual(self._called, ((), {}))
+
+    @inlineCallbacks
+    def test_stop_file_sync(self):
+        """Set if file sync is enabled or not."""
+        self.patch(dbus_client.SyncDaemonTool, 'quit', self._set_called)
+        yield dbus_client.stop_file_sync()
+
+        self.assertEqual(self._called, ((), {}))

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_service.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2011-01-06 20:33:15 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2011-01-19 12:21:44 +0000
@@ -163,6 +163,26 @@
         """Disable files service."""
         return self._process(None)
 
+    def connect_files(self):
+        """Connect files service."""
+        return self._process(None)
+
+    def disconnect_files(self):
+        """Disconnect files service."""
+        return self._process(None)
+
+    def restart_files(self):
+        """Restart the files service."""
+        return self._process(None)
+
+    def start_files(self):
+        """Start the files service."""
+        return self._process(None)
+
+    def stop_files(self):
+        """Stop the files service."""
+        return self._process(None)
+
     def volumes_info(self):
         """Get the user volumes info."""
         return self._process(SAMPLE_VOLUMES_INFO)
@@ -435,6 +455,61 @@
                 self.backend.disable_files)
         return self.assert_correct_method_call(*args)
 
+    def test_connect_files(self):
+        """Connect files service."""
+
+        def got_signal():
+            """The correct signal was received."""
+            self.deferred.callback("success")
+
+        args = ("FilesConnected", "FilesConnectError", got_signal,
+                self.backend.connect_files)
+        return self.assert_correct_method_call(*args)
+
+    def test_disconnect_files(self):
+        """Disconnect files service."""
+
+        def got_signal():
+            """The correct signal was received."""
+            self.deferred.callback("success")
+
+        args = ("FilesDisconnected", "FilesDisconnectError", got_signal,
+                self.backend.disconnect_files)
+        return self.assert_correct_method_call(*args)
+
+    def test_restart_files(self):
+        """Restart files service."""
+
+        def got_signal():
+            """The correct signal was received."""
+            self.deferred.callback("success")
+
+        args = ("FilesRestarted", "FilesRestartError", got_signal,
+                self.backend.restart_files)
+        return self.assert_correct_method_call(*args)
+
+    def test_start_files(self):
+        """Start files service."""
+
+        def got_signal():
+            """The correct signal was received."""
+            self.deferred.callback("success")
+
+        args = ("FilesStarted", "FilesStartError", got_signal,
+                self.backend.start_files)
+        return self.assert_correct_method_call(*args)
+
+    def test_stop_files(self):
+        """Stop files service."""
+
+        def got_signal():
+            """The correct signal was received."""
+            self.deferred.callback("success")
+
+        args = ("FilesStopped", "FilesStopError", got_signal,
+                self.backend.stop_files)
+        return self.assert_correct_method_call(*args)
+
     def test_volumes_info(self):
         """The volumes info is reported."""
 
@@ -589,6 +664,11 @@
         args = (dbus_service.FILE_SYNC_STARTING, "FileSyncStatusStarting")
         return self.assert_correct_status_signal(*args)
 
+    def test_file_sync_status_stopped(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_STOPPED, "FileSyncStatusStopped")
+        return self.assert_correct_status_signal(*args)
+
     def test_file_sync_status_disconnected(self):
         """The file sync status is reported properly."""
         args = (dbus_service.FILE_SYNC_DISCONNECTED,

=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2011-01-06 20:33:15 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2011-01-19 12:21:44 +0000
@@ -33,6 +33,7 @@
     FILE_SYNC_ERROR,
     FILE_SYNC_IDLE,
     FILE_SYNC_STARTING,
+    FILE_SYNC_STOPPED,
     FILE_SYNC_SYNCING,
     FILE_SYNC_UNKNOWN,
     MSG_KEY, STATUS_KEY,
@@ -85,6 +86,7 @@
     }
     status_changed_handler = None
     subscribed_folders = []
+    actions = []
 
     def get_credentials(self):
         """Return the mock credentials."""
@@ -124,6 +126,22 @@
         """Set the file sync service to be 'enabled'."""
         MockDBusClient.file_sync = enabled
 
+    def connect_file_sync(self):
+        """Connect files service."""
+        MockDBusClient.actions.append('connect')
+
+    def disconnect_file_sync(self):
+        """Disconnect file_sync service."""
+        MockDBusClient.actions.append('disconnect')
+
+    def start_file_sync(self):
+        """Start the file_sync service."""
+        MockDBusClient.actions.append('start')
+
+    def stop_file_sync(self):
+        """Stop the file_sync service."""
+        MockDBusClient.actions.append('stop')
+
     def get_folders(self):
         """Grab list of folders."""
         return SAMPLE_FOLDERS
@@ -487,6 +505,16 @@
         yield self.assert_correct_status(FILE_SYNC_DISCONNECTED)
 
     @inlineCallbacks
+    def test_disconnected_when_waiting(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'With User With Network', 'queues': '',
+            'name': 'WAITING', 'description': 'what a long wait!',
+        }
+        yield self.assert_correct_status(FILE_SYNC_DISCONNECTED)
+
+    @inlineCallbacks
     def test_syncing_if_online(self):
         """The syncdaemon status is processed and emitted."""
         MockDBusClient.status = {
@@ -520,6 +548,17 @@
         yield self.assert_correct_status(FILE_SYNC_IDLE)
 
     @inlineCallbacks
+    def test_stopped(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'name': 'SHUTDOWN', 'connection': '',
+            'queues': 'IDLE',
+            'description': 'something nice',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STOPPED)
+
+    @inlineCallbacks
     def test_unknown(self):
         """The syncdaemon status is processed and emitted."""
         MockDBusClient.status = {
@@ -547,23 +586,64 @@
         self.assertEqual(self._called, ((expected_status,), {}))
 
 
-class BackendSyncEnabledTestCase(BackendBasicTestCase):
-    """Syncdaemon enable/disable for the backend."""
-
+class BackendFileSyncOpsTestCase(BackendBasicTestCase):
+    """Syncdaemon operations for the backend."""
+
+    def setUp(self):
+        super(BackendFileSyncOpsTestCase, self).setUp()
+        MockDBusClient.actions = []
+
+    @inlineCallbacks
     def test_enable_files(self):
         """Files service is enabled."""
-        self.be.disable_files()
+        yield self.be.disable_files()
 
-        self.be.enable_files()
+        yield self.be.enable_files()
         self.assertTrue(MockDBusClient.file_sync)
 
+    @inlineCallbacks
     def test_disable_files(self):
         """Files service is disabled."""
-        self.be.enable_files()
+        yield self.be.enable_files()
 
-        self.be.disable_files()
+        yield self.be.disable_files()
         self.assertFalse(MockDBusClient.file_sync)
 
+    @inlineCallbacks
+    def test_connect_files(self):
+        """Connect files service."""
+        yield self.be.connect_files()
+
+        self.assertEqual(MockDBusClient.actions, ['connect'])
+
+    @inlineCallbacks
+    def test_disconnect_files(self):
+        """Disconnect files service."""
+        yield self.be.disconnect_files()
+
+        self.assertEqual(MockDBusClient.actions, ['disconnect'])
+
+    @inlineCallbacks
+    def test_restart_files(self):
+        """Restart the files service."""
+        yield self.be.restart_files()
+
+        self.assertEqual(MockDBusClient.actions, ['stop', 'start'])
+
+    @inlineCallbacks
+    def test_start_files(self):
+        """Start the files service."""
+        yield self.be.start_files()
+
+        self.assertEqual(MockDBusClient.actions, ['start'])
+
+    @inlineCallbacks
+    def test_stop_files(self):
+        """Stop the files service."""
+        yield self.be.stop_files()
+
+        self.assertEqual(MockDBusClient.actions, ['stop'])
+
 
 class BackendReplicationsTestCase(BackendBasicTestCase):
     """Replications tests for the backend."""