Merge lp:~dobey/ubuntuone-client/services-enablement into lp:ubuntuone-client

[dobey]

Hook up the files/music sync toggle buttons to work
Add the "News" checkbox for toggling sync of gwibber messages
Store the file sync enabled config in the config file
Add dbus methods and SyncDaemonTool methods to query/set the files sync config
Add the necessary code to toggle syncing of dbs in desktopcouch

[Rick McBride (rmcbride)]

Go Go Gadget Service Tab!

review: Approve

[Tim Cole (tcole)]

review: Approve

[lp:~dobey/ubuntuone-client/services-enablement]

442. By dobey on 2010-03-24

Fix potential NameError when desktopcouch is not available/installed

=== modified file 'bin/ubuntuone-preferences'
--- bin/ubuntuone-preferences	2010-03-17 21:45:23 +0000
+++ bin/ubuntuone-preferences	2010-03-24 17:49:27 +0000
@@ -50,10 +50,17 @@
 handler.setLevel(logging.DEBUG)
 logger.addHandler(handler)
 
+_ = gettext.gettext
+
+dcouch = None
+# Try importing the Ubuntu One desktopcouch enablement api
+try:
+    from desktopcouch.replication_services import ubuntuone as dcouch
+except ImportError:
+    logger.error(_("DesktopCouch replication API not found"))
+
 DBusGMainLoop(set_as_default=True)
 
-_ = gettext.gettext
-
 DBUS_IFACE_NAME = "com.ubuntuone.SyncDaemon"
 DBUS_IFACE_CONFIG_NAME = DBUS_IFACE_NAME + ".Config"
 DBUS_IFACE_STATUS_NAME = DBUS_IFACE_NAME + ".Status"
@@ -61,6 +68,9 @@
 DBUS_IFACE_AUTH_NAME = "com.ubuntuone.Authentication"
 DBUS_IFACE_AUTH_PATH = "/"
 
+# This is where thy music lies
+U1MSPATH = os.path.expanduser("~/.ubuntuone/Purchased from Ubuntu One")
+
 # Why thank you GTK+ for enforcing style-set and breaking API
 RCSTYLE = """
 style 'dialogs' {
@@ -443,6 +453,12 @@
         self.connect("close", self.__handle_response, gtk.RESPONSE_CLOSE)
         self.connect("response", self.__handle_response)
 
+        # desktopcouch ReplicationExclusion, or None
+        self.dcouch = None
+
+        # folder id for dealing with the Music folder
+        self.ums_id = None
+
         self.__bus = dbus.SessionBus()
         self.keyring = keyring
 
@@ -551,34 +567,113 @@
                           keyring=self.keyring,
                           callback=self.got_account_info)
 
+    def connect_desktopcouch_exclusion(self):
+        """Hook up to desktopcouch enablement API, or disable the UI."""
+        # Hook up to desktopcouch, or die trying
+        if dcouch:
+            self.dcouch = dcouch.ReplicationExclusion()
+            exclusions = self.dcouch.all_exclusions()
+            for check in [self.bookmarks_check,
+                          self.abook_check,
+                          self.gwib_check]:
+                if check.get_data('dbname') in exclusions:
+                    check.set_active(False)
+                else:
+                    check.set_active(True)
+        else:
+            self.bookmarks_check.set_sensitive(False)
+            self.abook_check.set_sensitive(False)
+            self.gwib_check.set_sensitive(False)
+
     def toggle_db_sync(self, dbname, disable=False):
         """
         Toggle whether a db in desktopcouch is synchronized to the
         Ubuntu One couchdb server.
         """
-        # FIXME: Actually enable/disable the dbs if desktopcouch exists
+        if self.dcouch:
+            if disable:
+                self.dcouch.exclude(dbname)
+            else:
+                self.dcouch.replicate(dbname)
+        else:
+            logger.error(_("Database enablement is unavailable."))
 
     def __db_check_toggled(self, checkbutton):
         """Handle toggling a desktopcouch service toggling."""
         dbname = checkbutton.get_data('dbname')
         self.toggle_db_sync(dbname, not checkbutton.get_active())
 
-    def __files_check_toggled(self, checkbutton):
+    def files_check_toggled(self, checkbutton):
         """Handle toggling the files service."""
-        enable = checkbutton.get_active()
-        if enable:
-            self.music_check.set_sensitive(True)
-            if self.music_check.get_active():
-                self.__music_check_toggled(self.music_check)
+        enabled = checkbutton.get_active()
+        self.sdtool.enable_files_sync(enabled).addCallbacks(
+            lambda _: dbus_async,
+            self.__sd_error)
+        def sd_error(error):
+            self.files_check.set_active(False)
+            self.files_check.set_sensitive(False)
+            self.music_check.set_sensitive(False)
+            self.__sd_error(error)
+
+        if enabled:
+            self.sdtool.start().addErrback(sd_error)
+            if self.ums_id:
+                self.music_check.set_sensitive(True)
+                if self.music_check.get_active():
+                    self.__music_check_toggled(self.music_check)
         else:
+            self.sdtool.quit()
             self.music_check.set_sensitive(False)
-        # FIXME: Actually stop or start ubuntuone-syncdaemon
 
-    def __music_check_toggled(self, checkbutton):
+    def music_check_toggled(self, checkbutton):
         """Handle toggling the music download service."""
-        if not self.files_check.get_active():
+        if not self.files_check.get_active() or not self.ums_id:
             return
-        # FIXME: Actually subscribe or unsubscribe to the UDF
+        enabled = checkbutton.get_active()
+        def got_error(error):
+            checkbutton.set_sensitive(False)
+            checkbutton.set_active(not enabled)
+            self.__sd_error(error)
+
+        if enabled:
+            d = self.sdtool.subscribe_folder(self.ums_id)
+        else:
+            d = self.sdtool.unsubscribe_folder(self.ums_id)
+        d.addErrback(got_error)
+
+    def get_syncdaemon_sync_config(self):
+        """Update the files/music sync config from syncdaemon."""
+        def got_fs_err(error):
+            self.files_check.set_sensitive(False)
+            self.music_check.set_sensitive(False)
+            self.__sd_error(error)
+
+        def got_ms_err(error):
+            self.music_check.set_sensitive(False)
+            self.__sd_error(error)
+
+        def got_info(info):
+            if not info:
+                self.music_check.set_active(False)
+                self.music_check.set_sensitive(False)
+            else:
+                self.ums_id = info['volume_id']
+                self.music_check.set_sensitive(True)
+                if info['subscribed'] == 'True':
+                    self.music_check.set_active(True)
+                else:
+                    self.music_check.set_active(False)
+
+        def got_fs(enabled):
+            self.files_check.set_active(enabled)
+
+        self.sdtool.get_folder_info(U1MSPATH).addCallbacks(got_info, got_ms_err)
+        self.sdtool.is_files_sync_enabled().addCallbacks(got_fs, got_fs_err)
+
+    def connect_file_sync_callbacks(self):
+        """Connect the file sync checkbox callbacks."""
+        self.files_check.connect('toggled', self.files_check_toggled)
+        self.music_check.connect('toggled', self.music_check_toggled)
 
     def __construct(self):
         """Construct the dialog's layout."""
@@ -679,8 +774,6 @@
         services.set_border_width(6)
         self.notebook.append_page(services)
         self.notebook.set_tab_label_text(services, _("Services"))
-        # FIXME: These are all disabled for the moment
-        services.set_sensitive(False)
         services.show()
 
         self.bookmarks_check = gtk.CheckButton(_("_Bookmarks"))
@@ -695,13 +788,18 @@
         services.pack_start(self.abook_check, False, False)
         self.abook_check.show()
 
+        self.gwib_check = gtk.CheckButton(_("_News"))
+        self.gwib_check.set_data('dbname', 'gwibber_messages')
+        self.gwib_check.connect('toggled', self.__db_check_toggled)
+        services.pack_start(self.gwib_check, False, False)
+        self.gwib_check.show()
+
         fbox = gtk.VBox(spacing=6)
         services.pack_start(fbox, False, False)
         fbox.show()
 
         self.files_check = gtk.CheckButton(_("_File Synchronization"))
         self.files_check.set_active(True)
-        self.files_check.connect('toggled', self.__files_check_toggled)
         fbox.pack_start(self.files_check, False, False)
         self.files_check.show()
 
@@ -712,7 +810,6 @@
 
         self.music_check = gtk.CheckButton(_("_Music Download"))
         self.music_check.set_active(True)
-        self.music_check.connect('toggled', self.__music_check_toggled)
         alignment.add(self.music_check)
         self.music_check.show()
 
@@ -731,6 +828,9 @@
         """Show our dialog, since we can do stuff now."""
         self.disconnect_signal_handlers()
         dialog = UbuntuOneDialog()
+        dialog.connect_desktopcouch_exclusion()
+        dialog.get_syncdaemon_sync_config()
+        dialog.connect_file_sync_callbacks()
         dialog.show()
         dialog.request_quota_info()
         dialog.request_account_info()

=== modified file 'bin/ubuntuone-syncdaemon'
--- bin/ubuntuone-syncdaemon	2010-03-19 14:28:40 +0000
+++ bin/ubuntuone-syncdaemon	2010-03-24 17:49:27 +0000
@@ -89,6 +89,10 @@
     if is_already_running():
         die('Another instance is running')
 
+    # check if the user disabled files sync
+    if not config.get_user_config().get_files_sync_enabled():
+        die('Files synchronization is disabled.')
+
     # check if we are using xdg_data_home and it doesn't exists
     if xdg_data_home in options.data_dir and \
        not os.path.exists(options.data_dir):

=== modified file 'data/syncdaemon.conf'
--- data/syncdaemon.conf	2010-03-19 14:47:36 +0000
+++ data/syncdaemon.conf	2010-03-24 17:49:27 +0000
@@ -14,6 +14,11 @@
 port.parser = int
 port.help = The port on which to connect to the server
 
+files_sync_enabled.default = True
+files_sync_enabled.action = store_true
+files_sync_enabled.parser = bool
+files_sync_enabled.help = Toggles synchronization of files (False disables syncdaemon entirely)
+
 root_dir.default = ~/Ubuntu One
 root_dir.parser = home_dir
 root_dir.help = Use the specified directory as the root

=== modified file 'tests/syncdaemon/test_config.py'
--- tests/syncdaemon/test_config.py	2010-03-18 21:41:02 +0000
+++ tests/syncdaemon/test_config.py	2010-03-24 17:49:27 +0000
@@ -395,6 +395,21 @@
         conf.read(config.get_user_config().config_file)
         self.assertEquals(conf.get(config.THROTTLING, 'on'), 'False')
 
+    def test_files_sync_enabled(self):
+        """Test for toggling files sync."""
+        dbus_config = self.main.dbus_iface.config
+        enabled = dbus_config.files_sync_enabled()
+        self.assertTrue(enabled)
+        dbus_config.set_files_sync_enabled(False)
+        enabled = dbus_config.files_sync_enabled()
+        self.assertFalse(enabled)
+        dbus_config.set_files_sync_enabled(True)
+        enabled = dbus_config.files_sync_enabled()
+        self.assertTrue(enabled)
+        conf = ConfigParser()
+        conf.read(config.get_user_config().config_file)
+        self.assertEquals(conf.get(config.MAIN, 'files_sync_enabled'), 'True')
+
 
 class SyncDaemonConfigParserTests(BaseTwistedTestCase):
     """Tests for SyncDaemonConfigParser"""

=== modified file 'tests/test_preferences.py'
--- tests/test_preferences.py	2010-03-12 16:07:24 +0000
+++ tests/test_preferences.py	2010-03-24 17:49:27 +0000
@@ -289,6 +289,20 @@
         self.mocker.replay()
         dialog = self.u1prefs.UbuntuOneDialog(keyring=self.keyring)
         self.assertTrue(dialog is not None)
+        def files_toggled(checkbutton):
+            enabled = checkbutton.get_active()
+            if enabled:
+                dialog.music_check.set_sensitive(True)
+            else:
+                dialog.music_check.set_sensitive(False)
+
+        def music_toggled(checkbutton):
+            pass
+
+        dialog.files_check_toggled = files_toggled
+        dialog.music_check_toggled = music_toggled
+        dialog.connect_file_sync_callbacks()
+
         dialog.files_check.set_active(False)
         self.assertFalse(dialog.files_check.get_active())
         self.assertFalse(dialog.music_check.props.sensitive)

=== modified file 'ubuntuone/syncdaemon/config.py'
--- ubuntuone/syncdaemon/config.py	2010-02-24 13:20:25 +0000
+++ ubuntuone/syncdaemon/config.py	2010-03-24 17:49:27 +0000
@@ -311,6 +311,15 @@
     def get_udf_autosubscribe(self):
         return self.get_parsed(MAIN, 'udf_autosubscribe')
 
+    # files sync enablement get/set
+    @requires_section(MAIN)
+    def set_files_sync_enabled(self, enabled):
+        self.set(MAIN, 'files_sync_enabled', str(enabled))
+
+    @requires_section(MAIN)
+    def get_files_sync_enabled(self):
+        return self.get_parsed(MAIN, 'files_sync_enabled')
+
 
 def configglue(fileobj, *filenames, **kwargs):
     """Populate an OptionParser with options and defaults taken from a

=== modified file 'ubuntuone/syncdaemon/dbus_interface.py'
--- ubuntuone/syncdaemon/dbus_interface.py	2010-03-10 22:12:06 +0000
+++ ubuntuone/syncdaemon/dbus_interface.py	2010-03-24 17:49:27 +0000
@@ -1183,6 +1183,22 @@
         user_config.set_udf_autosubscribe(False)
         user_config.save()
 
+    @dbus.service.method(DBUS_IFACE_CONFIG_NAME,
+                         in_signature='b', out_signature='')
+    def set_files_sync_enabled(self, enabled):
+        """Enable UDF autosubscribe."""
+        logger.debug('called set_files_sync_enabled %d', enabled)
+        user_config = config.get_user_config()
+        user_config.set_files_sync_enabled(enabled)
+        user_config.save()
+
+    @dbus.service.method(DBUS_IFACE_CONFIG_NAME,
+                         in_signature='', out_signature='b')
+    def files_sync_enabled(self):
+        logger.debug('called files_sync_enabled')
+        """Return the udf_autosubscribe config value."""
+        return config.get_user_config().get_files_sync_enabled()
+
 
 class Folders(DBusExposedObject):
     """A dbus interface to interact with User Defined Folders"""

=== modified file 'ubuntuone/syncdaemon/tools.py'
--- ubuntuone/syncdaemon/tools.py	2010-03-09 22:13:42 +0000
+++ ubuntuone/syncdaemon/tools.py	2010-03-24 17:49:27 +0000
@@ -470,6 +470,16 @@
                                   error_handler=d.errback)
         return d
 
+    def get_folder_info(self, path):
+        """Call the get_info method for a UDF path."""
+        self.log.debug('get_info')
+        client = DBusClient(self.bus, '/folders', DBUS_IFACE_FOLDERS_NAME)
+        d = defer.Deferred()
+        client.call_method('get_info', path,
+                           reply_handler=d.callback,
+                           error_handler=d.errback)
+        return d
+
     def query_by_path(self, path):
         """requesting a query of the node idetifiend by 'path' to the server."""
         self.log.debug('query_by_path(%s)', path)
@@ -691,6 +701,28 @@
                                   error_handler=d.errback)
         return d
 
+    def is_files_sync_enabled(self):
+        """Check if files sync is enabled."""
+        self.log.debug('is_files_sync_enabled')
+        d = defer.Deferred()
+        config_client = DBusClient(self.bus, '/config',
+                                   DBUS_IFACE_CONFIG_NAME)
+        config_client.call_method('files_sync_enabled',
+                                  reply_handler=d.callback,
+                                  error_handler=d.errback)
+        return d
+
+    def enable_files_sync(self, enabled):
+        """Enable/disable files sync."""
+        self.log.debug('enable_files_sync %d', enabled)
+        d = defer.Deferred()
+        config_client = DBusClient(self.bus, '/config',
+                                   DBUS_IFACE_CONFIG_NAME)
+        config_client.call_method('set_files_sync_enabled',
+                                  reply_handler=d.callback,
+                                  error_handler=d.errback)
+        return d
+
 
 # callbacks used by u1sdtool script