Merge lp:~nataliabidart/ubuntuone-control-panel/start-dc-on-backend into lp:ubuntuone-control-panel

[Natalia Bidart]

Desktopcouch replication service is accessed through the backend using its DBus service (LP: #696782).

To test, first check that all the desktopcouch related packages are uninstalled, and that no desktopcouch nor couchdb process is running. This meaning:

sudo apt-cache search couch

should show no package installed, and:

ps aux | grep couch

should return no results. Then, from this branch, run:

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

And go to the third tab and install dc-u1 from there, and keep playing. You should get no hangs at all in the UI.

[lp:~nataliabidart/ubuntuone-control-panel/start-dc-on-backend]

55. By Natalia Bidart on 2011-01-06

Avoiding conflicts.

56. By Natalia Bidart on 2011-01-06

Merged dependency branch in.

[Eric Casteleijn (thisfred)]

Works as advertised, code looks good. I don't like the desktopcouch pairing functionality as it stands, but that's in the design, so we'll discuss elsewhere.

review: Approve

[Roberto Alsina (ralsina)]

Does what it says. +1

review: Approve

=== modified file 'data/install.ui'
--- data/install.ui	2010-12-24 14:53:03 +0000
+++ data/install.ui	2011-01-06 21:03:06 +0000
@@ -23,11 +23,12 @@
         <property name="visible">True</property>
         <child>
           <object class="GtkButton" id="install_button">
-            <property name="label">gtk-ok</property>
+            <property name="label" translatable="yes">_Install now</property>
             <property name="visible">True</property>
             <property name="can_focus">True</property>
             <property name="receives_default">True</property>
-            <property name="use_stock">True</property>
+            <property name="image">image1</property>
+            <property name="use_underline">True</property>
             <signal name="clicked" handler="on_install_button_clicked"/>
           </object>
           <packing>
@@ -43,4 +44,8 @@
       </packing>
     </child>
   </object>
+  <object class="GtkImage" id="image1">
+    <property name="visible">True</property>
+    <property name="stock">gtk-ok</property>
+  </object>
 </interface>

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2011-01-04 16:12:56 +0000
+++ po/POTFILES.in	2011-01-06 21:03:06 +0000
@@ -1,8 +1,9 @@
 ubuntuone-control-panel-gtk.desktop.in
 ubuntuone/controlpanel/gtk/gui.py
 [type: gettext/glade] data/dashboard.ui
-[type: gettext/glade] data/services.ui
 [type: gettext/glade] data/device.ui
 [type: gettext/glade] data/devices.ui
+[type: gettext/glade] data/install.ui
 [type: gettext/glade] data/management.ui
 [type: gettext/glade] data/overview.ui
+[type: gettext/glade] data/services.ui

=== modified file 'pylintrc'
--- pylintrc	2010-10-13 18:55:23 +0000
+++ pylintrc	2011-01-06 21:03:06 +0000
@@ -272,7 +272,7 @@
 max-line-length=79
 
 # Maximum number of lines in a module
-max-module-lines=2000
+max-module-lines=2500
 
 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
 # tab).

=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2010-12-26 15:02:52 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2011-01-06 21:03:06 +0000
@@ -78,6 +78,12 @@
 VALUE_ERROR = _('Value could not be retrieved.')
 WARNING_MARKUP = '<span foreground="%s"><b>%%s</b></span>' % ORANGE
 KILOBYTES = 1024
+NO_OP = lambda *a, **kw: None
+
+
+def error_handler(*args, **kwargs):
+    """Log errors when calling D-Bus methods in a async way."""
+    logger.error('Error handler received: %r, %r', args, kwargs)
 
 
 def filter_by_app_name(f):
@@ -352,7 +358,8 @@
         settings = {TC_URL_KEY: U1_TC_URL, HELP_TEXT_KEY: U1_DESCRIPTION,
                     WINDOW_ID_KEY: str(self._window_id),
                     PING_URL_KEY: U1_PING_URL}
-        self.sso_backend.register(U1_APP_NAME, settings)
+        self.sso_backend.register(U1_APP_NAME, settings,
+            reply_handler=NO_OP, error_handler=error_handler)
         self.set_property('greyed', True)
         self.warning_label.set_text('')
 
@@ -361,7 +368,8 @@
         settings = {TC_URL_KEY: U1_TC_URL, HELP_TEXT_KEY: U1_DESCRIPTION,
                     WINDOW_ID_KEY: str(self._window_id),
                     PING_URL_KEY: U1_PING_URL}
-        self.sso_backend.login(U1_APP_NAME, settings)
+        self.sso_backend.login(U1_APP_NAME, settings,
+            reply_handler=NO_OP, error_handler=error_handler)
         self.set_property('greyed', True)
         self.warning_label.set_text('')
 
@@ -408,7 +416,8 @@
         else:
             self.set_sensitive(True)
             self.warning_label.set_text('')
-            self.sso_backend.find_credentials(U1_APP_NAME, {})
+            self.sso_backend.find_credentials(U1_APP_NAME, {},
+                reply_handler=NO_OP, error_handler=error_handler)
 
 
 class DashboardPanel(UbuntuOneBin, ControlPanelMixin):
@@ -516,11 +525,13 @@
         volume_id = checkbutton.get_label()
         subscribed = bool_str(checkbutton.get_active())
         self.backend.change_volume_settings(volume_id,
-                                            {'subscribed': subscribed})
+            {'subscribed': subscribed},
+            reply_handler=NO_OP, error_handler=error_handler)
 
     def load(self):
         """Load the volume list."""
-        self.backend.volumes_info()
+        self.backend.volumes_info(reply_handler=NO_OP,
+                                  error_handler=error_handler)
         self.message.start()
 
 
@@ -565,7 +576,8 @@
         # Not disabling the GUI to avoid annyong twitchings
         #self.set_sensitive(False)
         self.warning_label.set_text('')
-        self.backend.change_device_settings(self.id, self.__dict__)
+        self.backend.change_device_settings(self.id, self.__dict__,
+            reply_handler=NO_OP, error_handler=error_handler)
 
     def _block_signals(f):
         """Execute 'f' while having the _updating flag set."""
@@ -591,7 +603,8 @@
 
     def on_remove_clicked(self, widget):
         """Remove button was clicked or activated."""
-        self.backend.remove_device(self.id)
+        self.backend.remove_device(self.id,
+            reply_handler=NO_OP, error_handler=error_handler)
         self.set_sensitive(False)
 
     @_block_signals
@@ -747,7 +760,8 @@
 
     def load(self):
         """Load the device list."""
-        self.backend.devices_info()
+        self.backend.devices_info(reply_handler=NO_OP,
+                                  error_handler=error_handler)
         self.message.start()
 
 
@@ -818,12 +832,18 @@
 class Service(gtk.VBox, ControlPanelMixin):
     """A service."""
 
-    def __init__(self, name, localized_name, *args, **kwargs):
+    CHANGE_ERROR = _('The settings could not be changed,\n'
+                     'previous values were restored.')
+
+    def __init__(self, service_id, name, *args, **kwargs):
         gtk.VBox.__init__(self)
         ControlPanelMixin.__init__(self)
-        self.service_name = name
-
-        self.button = gtk.CheckButton(label=localized_name)
+        self.id = service_id
+
+        self.warning_label = gtk.Label()
+        self.pack_start(self.warning_label, expand=False)
+
+        self.button = gtk.CheckButton(label=name)
         self.pack_start(self.button, expand=False)
 
         self.show_all()
@@ -835,15 +855,18 @@
     FILES_SERVICE_NAME = _('Files')
 
     def __init__(self):
-        Service.__init__(self, name='files',
-                         localized_name=self.FILES_SERVICE_NAME)
+        Service.__init__(self, service_id='files',
+                         name=self.FILES_SERVICE_NAME)
 
         self.set_sensitive(False)
+
         self.backend.connect_to_signal('FileSyncStatusChanged',
                                        self.on_file_sync_status_changed)
         self.backend.connect_to_signal('FilesEnabled', self.on_files_enabled)
         self.backend.connect_to_signal('FilesDisabled', self.on_files_disabled)
-        self.backend.file_sync_status()
+
+        self.backend.file_sync_status(reply_handler=NO_OP,
+                                      error_handler=error_handler)
 
     @log_call(logger.debug)
     def on_file_sync_status_changed(self, status):
@@ -869,19 +892,24 @@
         """Button was toggled, exclude/replicate the service properly."""
         logger.info('File sync enabled? %r', self.button.get_active())
         if self.button.get_active():
-            self.backend.enable_files()
+            self.backend.enable_files(reply_handler=NO_OP,
+                                      error_handler=error_handler)
         else:
-            self.backend.disable_files()
+            self.backend.disable_files(reply_handler=NO_OP,
+                                       error_handler=error_handler)
 
 
 class DesktopcouchService(Service):
     """A desktopcouch service."""
 
-    def __init__(self, name, localized_name,
-                 replication_service, dependency=None):
-        Service.__init__(self, name, localized_name)
-        self.replication_service = replication_service
-        enabled = name not in self.replication_service.all_exclusions()
+    def __init__(self, service_id, name, enabled, dependency=None):
+        Service.__init__(self, service_id, name)
+
+        self.backend.connect_to_signal('ReplicationSettingsChanged',
+            self.on_replication_settings_changed)
+        self.backend.connect_to_signal('ReplicationSettingsChangeError',
+            self.on_replication_settings_change_error)
+
         self.button.set_active(enabled)
 
         self.dependency = None
@@ -903,11 +931,27 @@
     def on_button_toggled(self, button):
         """Button was toggled, exclude/replicate the service properly."""
         logger.info('Starting replication for %r? %r',
-                    self.service_name, self.button.get_active())
-        if self.button.get_active():
-            self.replication_service.replicate(self.service_name)
-        else:
-            self.replication_service.exclude(self.service_name)
+                    self.id, self.button.get_active())
+
+        args = {'enabled': bool_str(self.button.get_active())}
+        self.backend.change_replication_settings(self.id, args,
+            reply_handler=NO_OP, error_handler=error_handler)
+
+    @log_call(logger.info)
+    def on_replication_settings_changed(self, replication_id):
+        """The change of settings for this replication succeded."""
+        if replication_id != self.id:
+            return
+        self.warning_label.set_text('')
+
+    @log_call(logger.error)
+    def on_replication_settings_change_error(self, replication_id,
+                                             error_dict=None):
+        """The change of settings for this replication failed."""
+        if replication_id != self.id:
+            return
+        self.button.set_active(not self.button.get_active())
+        self._set_warning(self.CHANGE_ERROR, self.warning_label)
 
 
 class ServicesPanel(UbuntuOneBin, ControlPanelMixin):
@@ -916,32 +960,33 @@
     TITLE = _('Ubuntu One services including data sync are enabled for the '
               'data types and services listed below.')
     CHOOSE_SERVICES = _('Choose services to synchronize with this computer:')
-    DESKTOPCOUCH_PKG = 'desktopcouch'
-    BINDWOOD_PKG = 'xul-ext-bindwood'
-    EVOCOUCH_PKG = 'evolution-couchdb'
+    DESKTOPCOUCH_PKG = 'desktopcouch-ubuntuone'
     BOOKMARKS = _('Bookmarks (Firefox)')
     CONTACTS = _('Contacts (Evolution)')
     NO_PAIRING_RECORD = _('There is no Ubuntu One pairing record.')
 
-    def __init__(self, replication_exclusion_class=None):
+    def __init__(self):
         UbuntuOneBin.__init__(self)
         ControlPanelMixin.__init__(self, filename='services.ui')
         self.add(self.itself)
 
-        self.replication_exclusion_class = replication_exclusion_class
-        self.replication_service = None
-        self.has_desktopcouch = False
-        self.has_bindwood = False
-        self.has_evocouch = False
         self.package_manager = package_manager.PackageManager()
         self.install_box = None
-        self.bookmarks = None
-        self.contacts = None
+
+        self.backend.connect_to_signal('ReplicationsInfoReady',
+                                       self.on_replications_info_ready)
+        self.backend.connect_to_signal('ReplicationsInfoError',
+                                       self.on_replications_info_error)
 
         self.files.pack_start(FilesService(), expand=False)
 
         self.show()
 
+    @property
+    def has_desktopcouch(self):
+        """Is desktopcouch installed?"""
+        return self.package_manager.is_installed(self.DESKTOPCOUCH_PKG)
+
     @log_call(logger.debug)
     def load(self):
         """Load info."""
@@ -949,16 +994,7 @@
             self.itself.remove(self.install_box)
             self.install_box = None
 
-        self.has_desktopcouch = \
-            self.package_manager.is_installed(self.DESKTOPCOUCH_PKG)
-        self.has_bindwood = \
-            self.package_manager.is_installed(self.BINDWOOD_PKG)
-        self.has_evocouch = \
-            self.package_manager.is_installed(self.EVOCOUCH_PKG)
-
-        logger.info('load: has_desktopcouch? %r has_bindwood? %s '
-                    'has_evocouch? %s', self.has_desktopcouch,
-                    self.has_bindwood, self.has_evocouch)
+        logger.info('load: has_desktopcouch? %r', self.has_desktopcouch)
         if not self.has_desktopcouch:
             self.message.set_text('')
             self.replications.hide()
@@ -975,46 +1011,41 @@
     @log_call(logger.debug)
     def load_replications(self, *args):
         """Load replications info."""
+        # ask replications to the backend
+        self.message.start()
+        self.backend.replications_info(reply_handler=NO_OP,
+                                       error_handler=error_handler)
+
+    @log_call(logger.debug)
+    def on_replications_info_ready(self, info):
+        """The replication info is ready."""
+        self.on_success(self.CHOOSE_SERVICES)
+
         self.replications.show()
 
         if self.install_box is not None:
             self.itself.remove(self.install_box)
             self.install_box = None
 
-        self.message.set_text(self.CHOOSE_SERVICES)
         for child in self.replications.get_children():
             self.replications.remove(child)
 
-        # Unable to import 'desktopcouch.application.replication_services'
-        # pylint: disable=F0401
-        if self.replication_exclusion_class is None:
-            from desktopcouch.application.replication_services import \
-                ubuntuone as u1rep
-            self.replication_exclusion_class = u1rep.ReplicationExclusion
-
-        if self.replication_service is None:
-            try:
-                self.replication_service = self.replication_exclusion_class()
-            except ValueError:
-                logger.exception('Can not load replications:')
-                self._set_warning(self.NO_PAIRING_RECORD, self.message)
-                return
-
-        pkg = None
-        if not self.has_bindwood:
-            pkg = self.BINDWOOD_PKG
-        self.bookmarks = DesktopcouchService('bookmarks', self.BOOKMARKS,
-                                             self.replication_service,
-                                             dependency=pkg)
-        self.replications.pack_start(self.bookmarks, expand=False)
-
-        pkg = None
-        if not self.has_evocouch:
-            pkg = self.EVOCOUCH_PKG
-        self.contacts = DesktopcouchService('contacts', self.CONTACTS,
-                                            self.replication_service,
-                                            dependency=pkg)
-        self.replications.pack_start(self.contacts, expand=False)
+        for item in info:
+            pkg = item['dependency']
+            child = DesktopcouchService(service_id=item['replication_id'],
+                                        name=item['name'],  # self.BOOKMARKS,
+                                        enabled=bool(item['enabled']),
+                                        dependency=pkg if pkg else None)
+            self.replications.pack_start(child, expand=False)
+
+    @log_call(logger.error)
+    def on_replications_info_error(self, error_dict=None):
+        """The replication info can not be retrieved."""
+        if error_dict is not None and \
+           error_dict.get('error_type', None) == 'NoPairingRecord':
+            self.on_error(self.NO_PAIRING_RECORD)
+        else:
+            self.on_error()
 
 
 class ManagementPanel(gtk.VBox, ControlPanelMixin):
@@ -1107,8 +1138,10 @@
 
     def load(self):
         """Load the account info and file sync status list."""
-        self.backend.account_info()
-        self.backend.file_sync_status()
+        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)

=== modified file 'ubuntuone/controlpanel/gtk/tests/__init__.py'
--- ubuntuone/controlpanel/gtk/tests/__init__.py	2010-12-23 19:17:53 +0000
+++ ubuntuone/controlpanel/gtk/tests/__init__.py	2011-01-06 21:03:06 +0000
@@ -53,6 +53,15 @@
      'max_upload_speed': '1000', 'max_download_speed': '72548'},  # local
 ]
 
+FAKE_REPLICATIONS_INFO = [
+    {'replication_id': 'foo', 'name': 'Bar',
+     'enabled': 'True', 'dependency': ''},
+    {'replication_id': 'yadda', 'name': 'Foo',
+     'enabled': '', 'dependency': 'a very weird one'},
+    {'replication_id': 'yoda', 'name': 'Figthers',
+     'enabled': 'True', 'dependency': 'other dep'},
+]
+
 
 class FakedObject(object):
     """Fake an object, record every call."""
@@ -117,9 +126,11 @@
     object_path = gui.DBUS_PREFERENCES_PATH
     iface = gui.DBUS_PREFERENCES_IFACE
     exposed_methods = [
-        'account_info', 'devices_info', 'change_device_settings',
-        'volumes_info', 'change_volume_settings', 'file_sync_status',
-        'remove_device', 'enable_files', 'disable_files',
+        'account_info',  # account
+        'devices_info', 'change_device_settings', 'remove_device',  # devices
+        'volumes_info', 'change_volume_settings',  # volumes
+        'replications_info', 'change_replication_settings',  # replications
+        'file_sync_status', 'enable_files', 'disable_files',  # files
     ]
 
 
@@ -157,13 +168,3 @@
         yield
         self._installed[package_name] = True
         gui.package_manager.return_value(FakedTransaction([package_name]))
-
-
-class FakedReplication(object):
-    """Faked a DC replication exclusion."""
-
-    def __init__(self):
-        self._exclusions = set()
-        self.all_exclusions = lambda: self._exclusions
-        self.replicate = self._exclusions.remove
-        self.exclude = self._exclusions.add

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-26 15:02:52 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-01-06 21:03:06 +0000
@@ -26,9 +26,10 @@
 
 from ubuntuone.controlpanel.gtk import gui
 from ubuntuone.controlpanel.gtk.tests import (FAKE_ACCOUNT_INFO,
-    FAKE_VOLUMES_INFO, FAKE_DEVICE_INFO, FAKE_DEVICES_INFO,
+    FAKE_DEVICE_INFO, FAKE_DEVICES_INFO,
+    FAKE_VOLUMES_INFO, FAKE_REPLICATIONS_INFO,
     FakedNMState, FakedSSOBackend, FakedSessionBus, FakedInterface,
-    FakedPackageManager, FakedReplication,
+    FakedPackageManager,
 )
 from ubuntuone.controlpanel.tests import TOKEN, TestCase
 from ubuntuone.controlpanel.gtk.tests.test_package_manager import (
@@ -37,6 +38,8 @@
 
 # Attribute 'yyy' defined outside __init__, access to a protected member
 # pylint: disable=W0201, W0212
+# Too many lines in module
+# pylint: disable=C0302
 
 
 class BaseTestCase(TestCase):
@@ -96,7 +99,9 @@
         if backend is None:
             backend = self.ui.backend
         self.assertIn(method_name, backend._called)
-        self.assertEqual(backend._called[method_name], (args, {}))
+        kwargs = {'reply_handler': gui.NO_OP,
+                  'error_handler': gui.error_handler}
+        self.assertEqual(backend._called[method_name], (args, kwargs))
 
     def assert_warning_correct(self, warning, text):
         """Check that 'warning' is visible, showing 'text'."""
@@ -1361,9 +1366,9 @@
     """The test suite for a service."""
 
     klass = gui.Service
-    name = 'dc_test'
-    localized_name = u'Qué lindo test!'
-    kwargs = {'name': 'dc_test', 'localized_name': u'Qué lindo test!'}
+    service_id = 'dc_test'
+    name = u'Qué lindo test!'
+    kwargs = {'service_id': service_id, 'name': name}
 
     def test_is_an_box(self):
         """Inherits from gtk.VBox."""
@@ -1373,30 +1378,35 @@
         """Is visible."""
         self.assertTrue(self.ui.get_visible())
 
+    def test_warning_label_is_cleared(self):
+        """The warning label is cleared."""
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def test_warning_label_packed(self):
+        """The warning label is packed as child."""
+        self.assertIn(self.ui.warning_label, self.ui.get_children())
+
     def test_check_button_packed(self):
-        """A check button is packed as only child."""
+        """A check button is packed as child."""
         self.assertIn(self.ui.button, self.ui.get_children())
 
     def test_label(self):
         """The label is set."""
-        self.assertEqual(self.localized_name, self.ui.button.get_label())
+        self.assertEqual(self.name, self.ui.button.get_label())
 
-    def test_service_name(self):
-        """The service_name is set."""
-        self.assertEqual(self.name, self.ui.service_name)
+    def test_service_id(self):
+        """The service id is set."""
+        self.assertEqual(self.service_id, self.ui.id)
 
 
 class FilesServiceTestCase(ServiceTestCase):
     """The test suite for the file sync service."""
 
     klass = gui.FilesService
+    service_id = 'files'
+    name = gui.FilesService.FILES_SERVICE_NAME
     kwargs = {}
 
-    def setUp(self):
-        self.name = 'files'
-        self.localized_name = gui.FilesService.FILES_SERVICE_NAME
-        super(FilesServiceTestCase, self).setUp()
-
     def test_backend_account_signals(self):
         """The proper signals are connected to the backend."""
         self.assertEqual(self.ui.backend._signals['FileSyncStatusChanged'],
@@ -1461,35 +1471,36 @@
     """The test suite for a desktopcouch service."""
 
     klass = gui.DesktopcouchService
+    enabled = True
 
     def setUp(self):
-        self.replication = FakedReplication()
-        self.name = self.kwargs['name']
-        self.kwargs['replication_service'] = self.replication
+        self.kwargs['enabled'] = self.enabled
         super(DesktopcouchServiceTestCase, self).setUp()
 
+    def modify_settings(self):
+        """Modify settings so values actually change."""
+        self.ui.button.set_active(not self.ui.button.get_active())
+
+    def test_backend_account_signals(self):
+        """The proper signals are connected to the backend."""
+        self.assertEqual(
+            self.ui.backend._signals['ReplicationSettingsChanged'],
+            [self.ui.on_replication_settings_changed])
+        self.assertEqual(
+            self.ui.backend._signals['ReplicationSettingsChangeError'],
+            [self.ui.on_replication_settings_change_error])
+
     def test_active(self):
-        """Is active since replication has an empty database."""
-        self.assertTrue(self.ui.button.get_active())
-
-    def test_not_active(self):
-        """Is not active since 'name' is excluded on replication database."""
-        self.replication.exclude(self.name)
-        self.ui = self.klass(**self.kwargs)
-        self.assertFalse(self.ui.button.get_active())
+        """Is active if enabled."""
+        self.assertEqual(self.enabled, self.ui.button.get_active())
 
     def test_on_button_toggled(self):
         """When toggling the button, the DC exclude list is updated."""
-        assert self.ui.button.get_active()
         self.ui.button.set_active(not self.ui.button.get_active())
-        self.assertEqual(set([self.name]), self.replication.all_exclusions())
 
-    def test_on_button_toggled_twice(self):
-        """When toggling the button twice, the DC exclude list is updated."""
-        assert self.ui.button.get_active()
-        self.ui.button.set_active(not self.ui.button.get_active())
-        self.ui.button.set_active(not self.ui.button.get_active())
-        self.assertEqual(set(), self.replication.all_exclusions())
+        args = (self.service_id,
+                {'enabled': gui.bool_str(self.ui.button.get_active())})
+        self.assert_backend_called('change_replication_settings', args)
 
     def test_dependency(self):
         """The dependency box is None."""
@@ -1499,6 +1510,72 @@
         """The check button is sensitive."""
         self.assertTrue(self.ui.button.get_sensitive())
 
+    def test_on_replication_settings_changed(self):
+        """When settings were changed for this replication, enable it."""
+        new_val = not self.ui.button.get_active()
+        self.ui.button.set_active(new_val)
+
+        self.ui.on_replication_settings_changed(replication_id=self.ui.id)
+
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+        self.assertEqual(new_val, self.ui.button.get_active())
+
+    def test_on_replication_settings_changed_after_error(self):
+        """Change success after error."""
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.ui.on_replication_settings_change_error(replication_id=self.ui.id)
+
+        self.test_on_replication_settings_changed()
+
+    def test_on_replication_settings_changed_different_id(self):
+        """When settings were changed for other rep, nothing changes."""
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.ui.on_replication_settings_changed(replication_id='yadda')
+
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def test_on_replication_settings_changed_different_id_after_error(self):
+        """When settings were changed for other + error, nothing changes."""
+        self.ui.on_replication_settings_change_error(replication_id=self.ui.id)
+        self.ui.on_replication_settings_changed(replication_id='yadda')
+
+        self.assert_warning_correct(self.ui.warning_label,
+                                    self.ui.CHANGE_ERROR)
+
+    def test_on_replication_settings_change_error(self):
+        """When settings were not changed, notify the user.
+
+        Also, confirm that old value was restored.
+
+        """
+        old_val = self.ui.button.get_active()
+        self.ui.button.set_active(not old_val)
+        self.ui.on_replication_settings_change_error(replication_id=self.ui.id)
+
+        self.assert_warning_correct(self.ui.warning_label,
+                                    self.ui.CHANGE_ERROR)
+        self.assertEqual(old_val, self.ui.button.get_active())
+
+    def test_on_replication_settings_change_error_after_success(self):
+        """Change error after success."""
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.ui.on_replication_settings_changed(replication_id=self.ui.id)
+
+        self.test_on_replication_settings_change_error()
+
+    def test_on_replication_settings_change_error_different_id(self):
+        """When settings were not changed for other replication, do nothing."""
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.ui.on_replication_settings_change_error(replication_id='yudo')
+
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+
+class DesktopcouchServiceDisabledAtStartupTestCase(ServiceTestCase):
+    """The test suite for a desktopcouch service when enabled=False."""
+
+    enabled = False
+
 
 class DesktopcouchServiceWithDependencyTestCase(DesktopcouchServiceTestCase):
     """The test suite for a desktopcouch service when it needs a dependency."""
@@ -1532,7 +1609,8 @@
         self.ui.dependency.emit('finished')
 
         self.assertTrue(self.ui.dependency is None)
-        self.assertEqual(self.ui.get_children(), [self.ui.button])
+        self.assertEqual(sorted(self.ui.get_children()),
+                         sorted([self.ui.button, self.ui.warning_label]))
 
 
 class ServicesTestCase(ControlPanelMixinTestCase):
@@ -1562,6 +1640,13 @@
         """The install box is None."""
         self.assertTrue(self.ui.install_box is None)
 
+    def test_backend_signals(self):
+        """The proper signals are connected to the backend."""
+        self.assertEqual(self.ui.backend._signals['ReplicationsInfoReady'],
+                         [self.ui.on_replications_info_ready])
+        self.assertEqual(self.ui.backend._signals['ReplicationsInfoError'],
+                         [self.ui.on_replications_info_error])
+
 
 class ServicesFilesTestCase(ServicesTestCase):
     """The test suite for the services panel (files section)."""
@@ -1589,22 +1674,10 @@
         self.assertFalse(self.ui.message.active)
         self.assertEqual(self.ui.message.get_text(), '')
 
-    def test_replication_service(self):
-        """Has a replication service."""
-        self.assertEqual(self.ui.replication_service, None)
-
     def test_has_desktopcouch(self):
         """Has desktopcouch installed?"""
         self.assertFalse(self.ui.has_desktopcouch)
 
-    def test_has_bindwood(self):
-        """Has bindwood installed?"""
-        self.assertFalse(self.ui.has_bindwood)
-
-    def test_has_evocouch(self):
-        """Has evocouch installed?"""
-        self.assertFalse(self.ui.has_evocouch)
-
     def test_install_box_is_hidden(self):
         """The install box is not hidden."""
         self.assertTrue(self.ui.install_box.get_visible())
@@ -1629,41 +1702,27 @@
 
         self.assertEqual(self._called, ((self.ui.install_box,), {}))
 
+    def test_load_replications(self):
+        """The load_replications starts the spinner and calls the backend."""
+        self.ui.load_replications()
+
+        self.assertTrue(self.ui.message.active)
+        self.assert_backend_called('replications_info', ())
+
 
 class ServicesWithDesktopcouchTestCase(ServicesTestCase):
     """The test suite for the services panel."""
 
-    kwargs = {'replication_exclusion_class': FakedReplication}
-
     def setUp(self):
         super(ServicesWithDesktopcouchTestCase, self).setUp()
         self.ui.package_manager._installed[self.ui.DESKTOPCOUCH_PKG] = True
-        self.ui.load()
+        self.ui.on_replications_info_ready(info=FAKE_REPLICATIONS_INFO)
 
     def test_message(self):
         """Global load message is stopped and proper test is shown."""
         self.assertFalse(self.ui.message.active)
         self.assertEqual(self.ui.message.get_text(), self.ui.CHOOSE_SERVICES)
 
-    def test_replication_service(self):
-        """Has a replication service."""
-        self.assertIsInstance(self.ui.replication_service, FakedReplication)
-
-    def test_no_pairing_record(self):
-        """The pairing record is not in place."""
-
-        def no_pairing_record(*a):
-            """Fake a ReplicationExclusion with no pairing record."""
-            raise ValueError("No pairing record for ubuntuone.")
-
-        self.ui.replication_exclusion_class = no_pairing_record
-        self.ui.replication_service = None
-        self.ui.load()
-
-        self.assertEqual(self.ui.replications.get_children(), [])
-        self.assertFalse(self.ui.message.active)
-        self.assert_warning_correct(self.ui.message, self.ui.NO_PAIRING_RECORD)
-
     def test_has_desktopcouch(self):
         """Has desktopcouch installed?"""
         self.assertTrue(self.ui.has_desktopcouch)
@@ -1673,79 +1732,67 @@
         self.assertTrue(self.ui.replications.get_visible())
 
         children = self.ui.replications.get_children()
-        self.assertEqual(len(children), 2)
-        for child in children:
+        self.assertEqual(len(children), len(FAKE_REPLICATIONS_INFO))
+        for expected, child in zip(FAKE_REPLICATIONS_INFO, children):
             self.assertIsInstance(child, gui.DesktopcouchService)
-
-        self.assertTrue(self.ui.bookmarks is children[0])
-        self.assertTrue(self.ui.contacts is children[1])
-
-    def test_replications_after_loading_twice(self):
-        """Has proper child after loading twice."""
-        self.ui.load()
+            self.assertEqual(expected['replication_id'], child.id)
+            self.assertEqual(expected['name'], child.button.get_label())
+            self.assertEqual(bool(expected['enabled']),
+                             child.button.get_active())
+
+            if expected['dependency']:
+                self.assertTrue(child.dependency is not None)
+                self.assertEqual(expected['dependency'],
+                                 child.dependency.package_name)
+            else:
+                self.assertTrue(child.dependency is None)
+
+    def test_replications_after_getting_info_twice(self):
+        """Has proper child after getting backend info twice."""
+        self.ui.on_replications_info_ready(info=FAKE_REPLICATIONS_INFO)
         self.test_replications()
 
-    def test_bookmarks(self):
-        """The bookmarks is correct."""
-        self.assertEqual(self.ui.bookmarks.service_name, 'bookmarks')
-        self.assertEqual(self.ui.bookmarks.button.get_label(),
-                         self.ui.BOOKMARKS)
-        self.assertTrue(self.ui.bookmarks.replication_service is
-                        self.ui.replication_service)
-
-    def test_bookmarks_dependency(self):
-        """The bookmarks dependency is correct."""
-        self.assertTrue(self.ui.bookmarks.dependency is not None)
-        self.assertEqual(self.ui.bookmarks.dependency.package_name,
-                         self.ui.BINDWOOD_PKG)
-
-    def test_contacts(self):
-        """The contacts is correct."""
-        self.assertEqual(self.ui.contacts.service_name, 'contacts')
-        self.assertEqual(self.ui.contacts.button.get_label(),
-                         self.ui.CONTACTS)
-        self.assertTrue(self.ui.contacts.replication_service is
-                        self.ui.replication_service)
-
-    def test_contacts_dependency(self):
-        """The contacts dependency is correct."""
-        self.assertTrue(self.ui.contacts.dependency is not None)
-        self.assertEqual(self.ui.contacts.dependency.package_name,
-                         self.ui.EVOCOUCH_PKG)
-
-
-class ServicesWithDCAndBindwoodTestCase(ServicesWithDesktopcouchTestCase):
-    """The test suite for the services panel."""
-
-    def setUp(self):
-        super(ServicesWithDCAndBindwoodTestCase, self).setUp()
-        self.ui.package_manager._installed[self.ui.BINDWOOD_PKG] = True
-        self.ui.load()
-
-    def test_has_bindwood(self):
-        """Has bindwood installed?"""
-        self.assertTrue(self.ui.has_bindwood)
-
-    def test_bookmarks_dependency(self):
-        """The bookmarks dependency is correct."""
-        self.assertTrue(self.ui.bookmarks.dependency is None)
-
-
-class ServicesWithDCAndEvocouchTestCase(ServicesWithDesktopcouchTestCase):
-    """The test suite for the services panel."""
-
-    def setUp(self):
-        super(ServicesWithDCAndEvocouchTestCase, self).setUp()
-        self.ui.package_manager._installed[self.ui.EVOCOUCH_PKG] = True
-        self.ui.load()
-
-    def test_has_evocouch(self):
-        """Has evocoucg installed?"""
-        self.assertTrue(self.ui.has_evocouch)
-
-    def test_contacts_dependency(self):
-        """The bookmarks dependency is correct."""
-        self.assertTrue(self.ui.contacts.dependency is None)
+
+class ServicesWithDesktopcouchErrorTestCase(ServicesTestCase):
+    """The test suite for the services panel."""
+
+    def setUp(self):
+        super(ServicesWithDesktopcouchErrorTestCase, self).setUp()
+        self.ui.package_manager._installed[self.ui.DESKTOPCOUCH_PKG] = True
+
+    def test_no_pairing_record(self):
+        """The pairing record is not in place."""
+        error_dict = {'error_type': 'NoPairingRecord'}
+        self.ui.on_replications_info_error(error_dict)
+
+        self.assertEqual(self.ui.replications.get_children(), [])
+        self.assertFalse(self.ui.message.active)
+        self.assert_warning_correct(self.ui.message, self.ui.NO_PAIRING_RECORD)
+
+    def test_other_error(self):
+        """There was an error other than no pairing record."""
+        error_dict = {'error_type': 'OtherError'}
+        self.ui.on_replications_info_error(error_dict)
+
+        self.assertEqual(self.ui.replications.get_children(), [])
+        self.assertFalse(self.ui.message.active)
+        self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
+
+    def test_empty_dict(self):
+        """Handle empty dicts errors."""
+        self.ui.on_replications_info_error(error_dict={})
+
+        self.assertEqual(self.ui.replications.get_children(), [])
+        self.assertFalse(self.ui.message.active)
+        self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
+
+    def test_error_dict_none(self):
+        """HGandle empty dicts errors."""
+        self.ui.on_replications_info_error(error_dict=None)
+
+        self.assertEqual(self.ui.replications.get_children(), [])
+        self.assertFalse(self.ui.message.active)
+        self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
 
 
 class ManagementPanelTestCase(ControlPanelMixinTestCase):

=== modified file 'ubuntuone/controlpanel/logger.py'
--- ubuntuone/controlpanel/logger.py	2010-12-23 18:20:56 +0000
+++ ubuntuone/controlpanel/logger.py	2011-01-06 21:03:06 +0000
@@ -53,10 +53,7 @@
     logger.addHandler(MAIN_HANDLER)
     if os.environ.get('DEBUG'):
         debug_handler = logging.StreamHandler(sys.stderr)
-        if prefix is not None:
-            fmt = prefix + "%(name)s - %(levelname)s\n%(message)s\n"
-            formatter = logging.Formatter(fmt)
-            debug_handler.setFormatter(formatter)
+        debug_handler.setFormatter(basic_formatter)
         logger.addHandler(debug_handler)
 
     return logger