Merge lp:~nataliabidart/ubuntuone-client/autoconnect into lp:ubuntuone-client

[Natalia Bidart]

* Added new config option 'autoconnect' (LP: #688694).

To test, you should:

* quit syncdaemon (u1sdtool -q)

* edit ~/.config/ubuntuone/syncdaemon.conf and under the __main__ section add:
autoconnect = True

* ./autogen.sh && make

* start syncdaemon from this branch with:
PYTHONPATH=. ./bin/ubuntuone-syncdaemon

Monitor syncdaemon status either thru the logs or using u1sdtool and you'll see how it progresses further than READY, reaching QUEUE_MANAGER state.

[Chad Miller (cmiller)]

Works for me.

review: Approve

[Guillermo Gonzalez (verterok)]

looks good, tests pass.

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

=== modified file 'bin/ubuntuone-preferences'
--- bin/ubuntuone-preferences	2010-11-30 17:53:14 +0000
+++ bin/ubuntuone-preferences	2010-12-10 22:10:15 +0000
@@ -123,6 +123,7 @@
     except DBusException, e:
         error_handler(e)
 
+
 def really_do_rest_request(url, method, conn):
     """Second-order helper that does the REST request.
 
@@ -136,6 +137,7 @@
     conn.send(result)
     logger.debug("end really_do_rest_request (%s:%s)", method, url)
 
+
 def do_rest_request(proc, conn, callback):
     """Helper that handles the REST request."""
     pid = os.getpid()
@@ -149,6 +151,7 @@
             callback(result)
     logger.debug("end do_rest_request (%d)", pid)
 
+
 def make_rest_request(url=None, method='GET', callback=None):
     """Helper that makes an oauth-wrapped REST request."""
     logger.debug("make_rest_request (%s:%s)", method, url)
@@ -159,6 +162,7 @@
     Thread(target=do_rest_request, args=(p, conn1, callback)).start()
     logger.debug("end make_rest_request (%s:%s)", method, url)
 
+
 class DevicesWidget(gtk.Table):
     """
     the Devices tab.
@@ -471,9 +475,9 @@
                                              DBUS_CREDENTIALS_PATH,
                                              follow_name_owner_changes=True)
                 iface = dbus.Interface(client, DBUS_CREDENTIALS_IFACE)
-                iface.clear_token(clientdefs.APP_NAME,
-                                  reply_handler=local_removal_cb,
-                                  error_handler=self.error)
+                iface.clear_credentials(clientdefs.APP_NAME, {},
+                                        reply_handler=local_removal_cb,
+                                        error_handler=self.error)
             except DBusException, e:
                 self.error(e)
 
@@ -1054,8 +1058,10 @@
             self.present()
             logger.info("Got credentials for %s", app_name)
 
-    def got_credentialserror(self, app_name, message, detailed_error):
+    def got_credentialserror(self, app_name, error_dict):
         """Got an error during authentication."""
+        message = error_dict.get('error_msg', '')
+        detailed_error = error_dict.get('detailed_error', '')
         if app_name == clientdefs.APP_NAME:
             logger.error("Credentials error for %s: %s - %s" %
                          (app_name, message, detailed_error))
 
=== modified file 'data/syncdaemon.conf'
--- data/syncdaemon.conf	2010-11-12 21:39:37 +0000
+++ data/syncdaemon.conf	2010-12-10 22:10:15 +0000
@@ -64,6 +64,11 @@
 udf_autosubscribe.help = Autosubsribe to new User Defined Folders, 'off' by default. 
                          (accepted values: 1/0, on/off, true/false and yes/no)
 
+autoconnect.default = True
+autoconnect.parser = bool
+autoconnect.help = Autoconnect the syncdaemon when is ready to start file synchronization against the server, 'on' by default.
+                   (accepted values: 1/0, on/off, true/false and yes/no)
+
 ignore.parser = lines
 ignore.help = The list of (Python, not bash) regexes of the files that 
               SD should ignore.
 
=== modified file 'tests/platform/linux/test_dbus.py'
--- tests/platform/linux/test_dbus.py	2010-12-06 21:34:56 +0000
+++ tests/platform/linux/test_dbus.py	2010-12-10 22:10:15 +0000
@@ -2425,6 +2425,49 @@
                            error_handler=self.error_handler)
         return d
 
+    def test_autoconnect_enabled(self):
+        """Test for Config.autoconnect_enabled."""
+        client = self.get_client()
+        d = defer.Deferred()
+
+        def reply_handler_disabled(result):
+            """Handle the reply."""
+            self.assertFalse(result)
+            config.get_user_config().set_autoconnect(not result)
+            d.callback(True)
+
+        def reply_handler_enabled(result):
+            """Handle the reply."""
+            self.assertTrue(result)
+            config.get_user_config().set_autoconnect(not result)
+            client.call_method('autoconnect_enabled',
+                               reply_handler=reply_handler_disabled,
+                               error_handler=self.error_handler)
+
+        client.call_method('autoconnect_enabled',
+                           reply_handler=reply_handler_enabled,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_set_autoconnect_enabled(self):
+        """Test for Config.set_autoconnect_enabled."""
+        client = self.get_client()
+        d = defer.Deferred()
+        orig = config.get_user_config().get_autoconnect()
+        # restore autoconnect to original value
+        self.addCleanup(lambda: config.get_user_config().set_autoconnect(orig))
+
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertEqual(config.get_user_config().get_autoconnect(),
+                             not orig)
+            d.callback(True)
+
+        client.call_method('set_autoconnect_enabled', not orig,
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
 
 class DBusOAuthTestCase(BaseTwistedTestCase):
     """Tests the interaction between dbus_interface and ubuntu-sso-client."""
 
=== modified file 'tests/syncdaemon/test_config.py'
--- tests/syncdaemon/test_config.py	2010-11-30 17:53:14 +0000
+++ tests/syncdaemon/test_config.py	2010-12-10 22:10:15 +0000
@@ -235,7 +235,8 @@
 
     def test_load_udf_autosubscribe(self):
         """Test load/set/override of udf_autosubscribe config value."""
-        conf_file = os.path.join(self.test_root, 'test_udf_autosubscribe_config.conf')
+        conf_file = os.path.join(self.test_root,
+                                 'test_udf_autosubscribe_config.conf')
         # write some throttling values to the config file
         with open(conf_file, 'w') as fp:
             fp.write('[__main__]\n')
@@ -275,11 +276,60 @@
         overridden_opts = [('__main__', 'udf_autosubscribe', False)]
         conf.override_options(overridden_opts)
         self.assertFalse(conf.get_udf_autosubscribe())
-        self.assertFalse(conf.get_udf_autosubscribe() == conf_orig.get_udf_autosubscribe())
+        self.assertNotEqual(conf.get_udf_autosubscribe(),
+                            conf_orig.get_udf_autosubscribe())
         conf.save()
         conf_1 = config._Config(conf_file)
         self.assertEquals(True, conf_1.get_udf_autosubscribe())
 
+    def test_load_autoconnect(self):
+        """Test load/set/override of autoconnect config value."""
+        conf_file = os.path.join(self.test_root,
+                                 'test_autoconnect_config.conf')
+        # ensure that autoconnect is True
+        with open(conf_file, 'w') as fp:
+            fp.write('[__main__]\n')
+            fp.write('autoconnect = True\n')
+
+        # keep a original around
+        conf_orig = config._Config(conf_file)
+
+        # assert default is correct
+        self.assertTrue(conf_orig.get_autoconnect(),
+                        'autoconnect is True by default.')
+
+        # load the config
+        conf = config._Config(conf_file)
+        self.assertTrue(conf.get_autoconnect())
+
+        # change it to False
+        conf.set_autoconnect(False)
+        self.assertFalse(conf.get_autoconnect())
+
+        # save, load and check
+        conf.save()
+        conf_1 = config._Config(conf_file)
+        self.assertFalse(conf_1.get_autoconnect())
+        # change it to True
+        conf.set_autoconnect(True)
+        self.assertTrue(conf.get_autoconnect())
+        # save, load and check
+        conf.save()
+        conf_1 = config._Config(conf_file)
+        self.assertTrue(conf_1.get_autoconnect())
+
+        # load the config, check the override of the value
+        conf = config._Config(conf_file)
+        self.assertTrue(conf.get_autoconnect())
+        overridden_opts = [('__main__', 'autoconnect', False)]
+        conf.override_options(overridden_opts)
+        self.assertFalse(conf.get_autoconnect())
+        self.assertNotEqual(conf.get_autoconnect(),
+                            conf_orig.get_autoconnect())
+        conf.save()
+        conf_1 = config._Config(conf_file)
+        self.assertEquals(True, conf_1.get_autoconnect())
+
 
 class ConfigglueParsersTests(BaseTwistedTestCase):
     """Tests for our custom configglue parsers"""
 
=== modified file 'tests/syncdaemon/test_main.py'
--- tests/syncdaemon/test_main.py	2010-11-30 17:53:14 +0000
+++ tests/syncdaemon/test_main.py	2010-12-10 22:10:15 +0000
@@ -23,9 +23,9 @@
 
 from twisted.internet import defer, reactor
 
-from ubuntuone.syncdaemon.main import Main
+from ubuntuone.syncdaemon import main as main_mod
 from contrib.testing.testcase import (
-    BaseTwistedTestCase,
+    BaseTwistedTestCase, FAKED_CREDENTIALS,
 )
 
 
@@ -56,9 +56,10 @@
                       dns_srv=False, ssl=False,
                       mark_interval=60,
                       handshake_timeout=2,
+                      oauth_credentials=FAKED_CREDENTIALS,
                       glib_loop=DBusGMainLoop(set_as_default=True))
         params.update(kwargs)
-        m = Main(**params)
+        m = main_mod.Main(**params)
         m.local_rescan = lambda *_: m.event_q.push('SYS_LOCAL_RESCAN_DONE')
         return m
 
@@ -172,3 +173,35 @@
         self.assertTrue(os.path.exists(self.shares))
         self.assertTrue(os.path.exists(self.root))
         main.shutdown()
+
+    def test_connect_if_autoconnect_is_enabled(self):
+        """If autoconnect option is enabled, connect the syncdaemon."""
+        user_config = main_mod.config.get_user_config()
+        orig = user_config.get_autoconnect()
+        user_config.set_autoconnect(True)
+        self.addCleanup(lambda: user_config.set_autoconnect(orig))
+
+        self.connect_called = False
+        self.patch(main_mod.ubuntuone.platform.ExternalInterface, 'connect',
+                   lambda *a: setattr(self, 'connect_called', True))
+
+        main = self.build_main()
+        self.addCleanup(lambda: main.shutdown())
+
+        self.assertTrue(self.connect_called)
+
+    def test_dont_connect_if_autoconnect_is_disabled(self):
+        """If autoconnect option is disabled, do not connect the syncdaemon."""
+        user_config = main_mod.config.get_user_config()
+        orig = user_config.get_autoconnect()
+        user_config.set_autoconnect(False)
+        self.addCleanup(lambda: user_config.set_autoconnect(orig))
+
+        self.connect_called = False
+        self.patch(main_mod.ubuntuone.platform.ExternalInterface, 'connect',
+                   lambda *a: setattr(self, 'connect_called', True))
+
+        main = self.build_main()
+        self.addCleanup(lambda: main.shutdown())
+
+        self.assertFalse(self.connect_called)
 
=== modified file 'tests/test_preferences.py'
--- tests/test_preferences.py	2010-11-30 17:53:14 +0000
+++ tests/test_preferences.py	2010-12-10 22:10:15 +0000
@@ -561,8 +561,11 @@
 
     def test_got_credentialserror(self):
         """Test CredentialsError signal."""
-        self.login_handler.got_credentialserror(clientdefs.APP_NAME, "Error", "Detailed error")
-        self.assertTrue(self.memento.check_error(clientdefs.APP_NAME, "Error", "Detailed error"))
+        error_dict = {'error_msg': 'Test', 'detailed_error': 'My bad'}
+        self.login_handler.got_credentialserror(clientdefs.APP_NAME,
+                                                error_dict)
+        self.assertTrue(self.memento.check_error(clientdefs.APP_NAME,
+                                                 *error_dict.values()))
 
     def test_got_authdenied(self):
         """Test AuthorizationDenied signal."""
 
=== modified file 'ubuntuone/platform/linux/__init__.py'
--- ubuntuone/platform/linux/__init__.py	2010-12-06 21:34:56 +0000
+++ ubuntuone/platform/linux/__init__.py	2010-12-10 22:10:15 +0000
@@ -38,12 +38,15 @@
     open_file,
     rename,
 )
-from ubuntuone.platform.linux.vm_helper import create_shares_link, get_udf_path_name, get_udf_path, get_share_path, VMMetadataUpgraderMixIn
+from ubuntuone.platform.linux.vm_helper import (create_shares_link,
+    get_udf_path_name, get_udf_path, get_share_path, VMMetadataUpgraderMixIn)
 from ubuntuone.platform.linux import tools
 from filesystem_notifications import FilesystemMonitor
 
 
 class ExternalInterface(object):
+    """An ExternalInterface implemented with a DBus interface."""
+
     def __init__(self, main, glib_loop=False, broadcast_events=False,
                  dbus_iface=None):
         # avoid circular dependencies
@@ -63,8 +66,19 @@
             self.dbus_iface = dbus_iface
             self.bus = None
 
+    def _get_credentials(self):
+        return self.dbus_iface.oauth_credentials
+
+    def _set_credentials(self, credentials):
+        self.dbus_iface.oauth_credentials = credentials
+
+    oauth_credentials = property(fget=_get_credentials, fset=_set_credentials)
+
     def change_notification(self):
         self.dbus_iface.status.emit_content_queue_changed()
 
     def shutdown(self, with_restart):
         self.dbus_iface.shutdown(with_restart)
+
+    def connect(self):
+        self.dbus_iface.connect()
 
=== modified file 'ubuntuone/platform/linux/dbus_interface.py'
--- ubuntuone/platform/linux/dbus_interface.py	2010-12-09 13:38:46 +0000
+++ ubuntuone/platform/linux/dbus_interface.py	2010-12-10 22:10:15 +0000
@@ -1474,6 +1474,20 @@
         logger.debug('called files_sync_enabled')
         return config.get_user_config().get_files_sync_enabled()
 
+    @dbus.service.method(DBUS_IFACE_CONFIG_NAME,
+                         in_signature='', out_signature='b')
+    def autoconnect_enabled(self):
+        """Return the autoconnect config value."""
+        return config.get_user_config().get_autoconnect()
+
+    @dbus.service.method(DBUS_IFACE_CONFIG_NAME,
+                         in_signature='b', out_signature='')
+    def set_autoconnect_enabled(self, enabled):
+        """Enable syncdaemon autoconnect."""
+        user_config = config.get_user_config()
+        user_config.set_autoconnect(enabled)
+        user_config.save()
+
 
 class Folders(DBusExposedObject):
     """A dbus interface to interact with User Defined Folders"""
 
=== modified file 'ubuntuone/syncdaemon/config.py'
--- ubuntuone/syncdaemon/config.py	2010-08-11 14:05:23 +0000
+++ ubuntuone/syncdaemon/config.py	2010-12-10 22:10:15 +0000
@@ -343,6 +343,15 @@
     def get_files_sync_enabled(self):
         return self.get_parsed(MAIN, 'files_sync_enabled')
 
+    @requires_section(MAIN)
+    def set_autoconnect(self, enabled):
+        self.set(MAIN, 'autoconnect', str(enabled))
+
+    @requires_section(MAIN)
+    def get_autoconnect(self):
+        return self.get_parsed(MAIN, 'autoconnect')
+
+
 
 def configglue(fileobj, *filenames, **kwargs):
     """Populate an OptionParser with options and defaults taken from a
 
=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2010-12-06 23:47:32 +0000
+++ ubuntuone/syncdaemon/main.py	2010-12-10 22:10:15 +0000
@@ -78,7 +78,7 @@
                  mark_interval=120, broadcast_events=False, handshake_timeout=30,
                  shares_symlink_name='Shared With Me',
                  read_limit=None, write_limit=None, throttling_enabled=False,
-                 ignore_files=None):
+                 ignore_files=None, oauth_credentials=None):
         self.root_dir = root_dir
         self.shares_dir = shares_dir
         self.shares_dir_link = os.path.join(self.root_dir, shares_symlink_name)
@@ -122,6 +122,10 @@
 
         self.external = ubuntuone.platform.ExternalInterface(
             self, glib_loop, broadcast_events)
+        self.external.oauth_credentials = oauth_credentials
+        if user_config.get_autoconnect():
+            self.external.connect()
+
         self.action_q.content_queue.set_change_notification_cb(
             self.external.change_notification)
         self.zg_listener = event_logging.ZeitgeistListener(self.fs, self.vm)