Merge lp:~facundo/ubuntuone-client/simple-auth into lp:ubuntuone-client

[Facundo Batista]

Simple authentication.

Simple authentication.

[Roberto Alsina (ralsina)]

review: Approve

Unmerged revisions

1406. By Facundo Batista on 2015-05-18

Simple authentication.

=== modified file 'bin/ubuntuone-syncdaemon'
--- bin/ubuntuone-syncdaemon	2013-01-28 17:43:24 +0000
+++ bin/ubuntuone-syncdaemon	2015-05-18 21:26:35 +0000
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 #
-# Copyright 2009-2013 Canonical Ltd.
+# Copyright 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -88,7 +88,7 @@
 
 
 def main(argv):
-    """ client entry point. """
+    """Client entry point."""
     args = argv[1:]
     usage = "Usage: %prog [config file] [extra config files] [options] "
     configs = []
@@ -97,7 +97,7 @@
     if len(configs) == 0:
         configs.extend(get_config_files())
     (parser, options, argv) = config.configglue(file(configs[0]), *configs[1:],
-                               args=args, usage=usage)
+                                                args=args, usage=usage)
     d = async_main(parser, options, argv)
     d.addErrback(check_death)
     d.addErrback(logger.root_logger.exception)
@@ -202,16 +202,17 @@
     assert isinstance(options.shares_dir, str)
     assert isinstance(options.data_dir, str)
 
-    # check if we have oauth credentials 
-    oauth_credentials = None
-    if options.oauth:
-        values = options.oauth.split(':')
-        if len(values) == 4 or len(values) == 2:
-            oauth_credentials = values
+    # check if we have auth credentials
+    auth_credentials = None
+    if options.auth:
+        values = options.auth.split(':')
+        if len(values) == 2:
+            auth_credentials = dict(zip(('username', 'password'), values))
         else:
-            msg = "--oauth requires a key and secret together in the form " \
-                  "[CONSUMER_KEY:CONSUMER_SECRET:]KEY:SECRET"
-            parser.error(msg)
+            parser.error(
+                "--auth requires a username and password together "
+                "in the form USERNAME:PASSWORD"
+            )
 
     # check which file monitor to use
     monitor_class = yield get_filemonitor_class(options.fs_monitor)
@@ -228,12 +229,13 @@
                 write_limit=options.bandwidth_throttling_write_limit,
                 throttling_enabled=options.bandwidth_throttling_on,
                 ignore_files=options.ignore,
-                oauth_credentials=oauth_credentials,
+                auth_credentials=auth_credentials,
                 monitor_class=monitor_class)
 
     # override the reactor default signal handlers in order to
     # shutdown properly
     atexit.register(reactor.callFromThread, main.quit)
+
     def install_handlers():
         """ install our custom signal handler. """
         def handler(signum, frame):
 
=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2013-02-20 22:41:12 +0000
+++ contrib/testing/testcase.py	2015-05-18 21:26:35 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -73,11 +73,8 @@
 
 logger.init()
 
-FAKED_CREDENTIALS = {'consumer_key': 'faked_consumer_key',
-                     'consumer_secret': 'faked_consumer_secret',
-                     'token': 'faked_token',
-                     'token_secret': 'faked_token_secret',
-                     'token_name': 'Test me please'}
+FAKED_CREDENTIALS = {'username': 'test_username',
+                     'password': 'test_password'}
 
 
 @contextlib.contextmanager
@@ -425,7 +422,7 @@
 
         # use the config from the branch
         new_get_config_files = lambda: [os.path.join(os.environ['ROOTDIR'],
-                                                   'data', 'syncdaemon.conf')]
+                                                     'data', 'syncdaemon.conf')]
         self.patch(config, 'get_config_files', new_get_config_files)
 
         # fake a very basic config file with sane defaults for the tests
@@ -724,4 +721,4 @@
 
 skip_if_darwin_missing_fs_event = \
     skipIfOS('darwin', 'Fails due to missing/out of order FS events, '
-                      'see bug #820598.')
+                       'see bug #820598.')
 
=== modified file 'data/syncdaemon.conf'
--- data/syncdaemon.conf	2012-10-23 20:54:03 +0000
+++ data/syncdaemon.conf	2015-05-18 21:26:35 +0000
@@ -31,8 +31,8 @@
 data_dir.parser = xdg_data
 data_dir.help = Use the specified directory to store the metadata
 
-oauth.help = Explicitly provide OAuth credentials. You can either provide the 4 values (consumer key and secret, plus the key and secret), or just the last two (key and secret).
-oauth.metavar = [CONSUMER_KEY:CONSUMER_SECRET:]KEY:SECRET
+auth.help = Explicitly provide Auth credentials (username and password)
+auth.metavar = USERNAME:PASSWORD
 
 debug.default = False
 debug.action = store_true
 
=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2013-02-04 21:33:35 +0000
+++ tests/syncdaemon/test_action_queue.py	2015-05-18 21:26:35 +0000
@@ -1,6 +1,6 @@
 #-*- coding: utf-8 -*-
 #
-# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -45,7 +45,6 @@
 import OpenSSL.SSL
 
 from mocker import Mocker, MockerTestCase, ANY, expect
-from oauthlib.oauth1 import Client
 from twisted.internet import defer, reactor
 from twisted.internet import error as twisted_error
 from twisted.python.failure import DefaultException, Failure
@@ -263,7 +262,7 @@
         events = [x[0] for x in self.factory.event_queue.events]
         assert 'SYS_CONNECTION_MADE' in events
 
-        self.factory.event_queue.events = [] # reset events
+        self.factory.event_queue.events = []  # reset events
         if hasattr(self, 'testing_deferred'):
             self.testing_deferred.callback(True)
 
@@ -324,10 +323,8 @@
 
     def user_connect(self):
         """User requested to connect to server."""
-        token = {'token': 'bla', 'token_secret': 'ble',
-                 'consumer_key': 'foo', 'consumer_secret': 'bar'}
-        self.action_queue.event_queue.push('SYS_USER_CONNECT',
-                                           access_token=token)
+        auth_info = dict(username='test_username', password='test_password')
+        self.action_queue.event_queue.push('SYS_USER_CONNECT', access_token=auth_info)
 
 
 class BasicTests(BasicTestCase):
@@ -1228,6 +1225,7 @@
             orig = self.action_queue.client.connectionLost
 
             d = defer.Deferred()
+
             def faked_connectionLost(reason):
                 """Receive connection lost and fire tearDown."""
                 orig(reason)
@@ -1262,7 +1260,8 @@
         yield self._connect_factory()
 
         assert self.action_queue.connector is not None
-        assert self.action_queue.connect_in_progress == True
+        assert self.action_queue.connect_in_progress
+
         # double connect, it returns None instead of a Deferred
         result = self.action_queue.connect()
         self.assertTrue(result is None, 'not connecting again')
@@ -1274,7 +1273,7 @@
         """self.action_queue.connector.disconnect was called."""
         yield self._connect_factory()
 
-        self.action_queue.event_queue.events = [] # cleanup events
+        self.action_queue.event_queue.events = []  # cleanup events
         assert self.action_queue.connector.state == 'connected'
         self.action_queue.disconnect()
 
@@ -1297,6 +1296,7 @@
         orig = self.action_queue.clientConnectionFailed
 
         d = defer.Deferred()
+
         def faked_clientConnectionFailed(connector, reason):
             """Receive connection failed and check."""
             orig(connector, reason)
@@ -1331,6 +1331,7 @@
         orig = self.action_queue.clientConnectionLost
 
         d = defer.Deferred()
+
         def faked_clientConnectionLost(connector, reason):
             """Receive connection lost and check."""
             orig(connector, reason)
@@ -1502,14 +1503,14 @@
         volume = FakedVolume()
         self.action_queue._volume_created_callback(volume)
         self.assertEqual([('SV_VOLUME_CREATED', {'volume': volume})],
-                          self.action_queue.event_queue.events)
+                         self.action_queue.event_queue.events)
 
     def test_volume_deleted_push_event(self):
         """Volume deleted callback push proper event."""
         volume_id = VOLUME
         self.action_queue._volume_deleted_callback(volume_id)
         self.assertEqual([('SV_VOLUME_DELETED', {'volume_id': volume_id})],
-                          self.action_queue.event_queue.events)
+                         self.action_queue.event_queue.events)
 
     def test_volume_new_generation_push_event_root(self):
         """Volume New Generation callback push proper event with root."""
@@ -1540,7 +1541,7 @@
         self.assertEqual(('volume',), EVENTS['SV_VOLUME_CREATED'])
         self.assertEqual(('volume_id',), EVENTS['SV_VOLUME_DELETED'])
         self.assertEqual(('volume_id', 'node_id', 'marker'),
-                          EVENTS['AQ_CREATE_UDF_OK'])
+                         EVENTS['AQ_CREATE_UDF_OK'])
         self.assertEqual(('error', 'marker'), EVENTS['AQ_CREATE_UDF_ERROR'])
         self.assertEqual(('volumes',), EVENTS['AQ_LIST_VOLUMES'])
         self.assertEqual(('error',), EVENTS['AQ_LIST_VOLUMES_ERROR'])
@@ -1845,7 +1846,7 @@
         called = []
         self.cmd.run = lambda: defer.succeed(True)
         self.cmd._acquire_pathlock = lambda: defer.succeed(
-                                                lambda: called.append(True))
+            lambda: called.append(True))
 
         self.cmd.go()
         self.assertTrue(called)
@@ -1856,7 +1857,7 @@
         called = []
         self.cmd.run = lambda: defer.fail(ValueError("error message"))
         self.cmd._acquire_pathlock = lambda: defer.succeed(
-                                                lambda: called.append(True))
+            lambda: called.append(True))
 
         yield self.cmd.go()
         self.assertTrue(called)
@@ -2146,7 +2147,7 @@
     def test_finish_running(self):
         """Set running to False when finish."""
         self.cmd.running = True
-        self.rq.unqueue = lambda c: None # don't do anything
+        self.rq.unqueue = lambda c: None  # don't do anything
         self.cmd.finish()
         self.assertFalse(self.cmd.running)
 
@@ -2192,7 +2193,7 @@
 
     def test_cancel_releases_conditions(self):
         """Cancel calls the conditions locker for the command."""
-        self.cmd.finish = lambda: None # don't try to unqueue!
+        self.cmd.finish = lambda: None  # don't try to unqueue!
         d = self.action_queue.conditions_locker.get_lock(self.cmd)
         self.cmd.cancel()
         self.assertTrue(d.called)
@@ -2300,7 +2301,7 @@
         failure = Failure(DefaultException(msg))
         self.command.handle_failure(failure=failure)
         events = [('AQ_CREATE_UDF_ERROR',
-                    {'error': msg, 'marker': self.marker})]
+                  {'error': msg, 'marker': self.marker})]
         self.assertEqual(events, self.command.action_queue.event_queue.events)
 
     def test_path_locking(self):
@@ -2714,8 +2715,8 @@
         node_id = uuid.uuid4()
         nodekey = '%s' % (base64.urlsafe_b64encode(node_id.bytes).strip("="))
         node_id_2 = uuid.uuid4()
-        nodekey_2 = '%s' % (base64.urlsafe_b64encode(
-                                                node_id_2.bytes).strip("="))
+        nodekey_2 = '%s' % (
+            base64.urlsafe_b64encode(node_id_2.bytes).strip("="))
         volume_id = uuid.uuid4()
 
         def check_webcall(request_iri, method=None):
@@ -2743,10 +2744,10 @@
 
     def test_handle_success_push_event(self):
         """Test AQ_PUBLIC_FILES_LIST_OK is pushed on success."""
-        response = [{'node_id': uuid.uuid4(), 'volume_id':None,
+        response = [{'node_id': uuid.uuid4(), 'volume_id': None,
                     'public_url': 'http://example.com'}]
         self.command.handle_success(success=response)
-        event = ('AQ_PUBLIC_FILES_LIST_OK', {'public_files': response,})
+        event = ('AQ_PUBLIC_FILES_LIST_OK', {'public_files': response})
         self.assertIn(event, self.command.action_queue.event_queue.events)
 
     def test_handle_failure_push_event(self):
@@ -2789,8 +2790,8 @@
         self.test_path = os.path.join(self.root, 'file')
         self.mdid = self.main.fs.create(self.test_path, '')
         self.command = Download(request_queue, share_id='a_share_id',
-                               node_id='a_node_id', server_hash='server_hash',
-                               mdid=self.mdid)
+                                node_id='a_node_id', server_hash='server_hash',
+                                mdid=self.mdid)
         self.command.make_logger()
 
     def test_progress_information_setup(self):
@@ -2861,7 +2862,7 @@
         self.assertEqual(self.command.n_bytes_read, 0)
         self.assertEqual(self.command.n_bytes_read_last, 0)
         self.command.node_attr_cb(
-                            deflated_size = TRANSFER_PROGRESS_THRESHOLD * 2)
+            deflated_size=TRANSFER_PROGRESS_THRESHOLD * 2)
 
         self.command.downloaded_cb('x' * 5)
         events = self.command.action_queue.event_queue.events
@@ -3085,7 +3086,7 @@
                    lambda n, s: FakeFileObj())
         test_path = os.path.join(self.root, 'foo', 'bar')
         mdid = self.main.fs.create(test_path, '')
-        cmd = Download(self.rq, 'a_share_id','a_node_id', 'server_hash',
+        cmd = Download(self.rq, 'a_share_id', 'a_node_id', 'server_hash',
                        mdid)
 
         # first run, it is just instantiated
@@ -3178,7 +3179,7 @@
 
     def test_reset(self):
         """Reset the values at start."""
-        f = StringIO("x" * 10  + "y" * 5)
+        f = StringIO("x" * 10 + "y" * 5)
         cmd = FakeCommand()
 
         # first time
@@ -3206,7 +3207,7 @@
                 """Count how many times it was called."""
                 innerself._progress_hook_called += 1
 
-        f = StringIO("x" * 10  + "y" * 5)
+        f = StringIO("x" * 10 + "y" * 5)
         cmd = FakeCommand()
         upw = UploadProgressWrapper(f, cmd)
 
@@ -3416,7 +3417,7 @@
         self.command.progress_hook()
         kwargs = {'share_id': self.command.share_id, 'node_id': 'a_node_id',
                   'deflated_size': 2*TRANSFER_PROGRESS_THRESHOLD,
-                  'n_bytes_written': 5+TRANSFER_PROGRESS_THRESHOLD }
+                  'n_bytes_written': 5+TRANSFER_PROGRESS_THRESHOLD}
         events = [('AQ_UPLOAD_FILE_PROGRESS', kwargs)]
         self.assertEqual(events, self.command.action_queue.event_queue.events)
         self.assertEqual(self.command.n_bytes_written_last,
@@ -3747,8 +3748,8 @@
 
         self.patch(CreateShare, "_create_share_http", check_create_http)
         command = CreateShare(self.request_queue, 'node_id',
-                                   '[e-mail]', 'share_name',
-                                   ACCESS_LEVEL_RW, 'marker', 'path')
+                              '[e-mail]', 'share_name',
+                              ACCESS_LEVEL_RW, 'marker', 'path')
         self.assertTrue(command.use_http, 'CreateShare should be in http mode')
 
         command._run()
@@ -3770,8 +3771,8 @@
 
         self.patch(CreateShare, "_create_share_http", check_create_http)
         command = CreateShare(self.request_queue, 'node_id',
-                                   '[e-mail]', 'share_name',
-                                   ACCESS_LEVEL_RO, 'marker', 'path')
+                              '[e-mail]', 'share_name',
+                              ACCESS_LEVEL_RO, 'marker', 'path')
         self.assertTrue(command.use_http, 'CreateShare should be in http mode')
         command._run()
         node_id, user, name, read_only = yield d
@@ -3804,7 +3805,7 @@
         cmd.use_http = True
         cmd.handle_success(mock_success)
 
-        event_params = { 'marker': marker_id }
+        event_params = {'marker': marker_id}
         events = [('AQ_SHARE_INVITATION_SENT', event_params)]
         self.assertEqual(events, cmd.action_queue.event_queue.events)
 
@@ -3856,6 +3857,7 @@
     def test_run_calls_protocol(self):
         """Test protocol's delete_volume is called."""
         self.called = False
+
         def check(share_id):
             """Take control over client's feature."""
             self.called = True
@@ -3888,6 +3890,7 @@
         """Check the API of AQ.query_volumes."""
         self.main.start()
         d = defer.Deferred()
+
         def list_volumes():
             """Fake list_volumes."""
             result = DummyClass()
@@ -3897,6 +3900,7 @@
         self.action_queue.client = DummyClass()
         self.action_queue.client.list_volumes = list_volumes
         d = self.action_queue.query_volumes()
+
         def check(result):
             self.assertIn('foo', result)
             self.assertIn('bar', result)
@@ -3923,7 +3927,7 @@
     def test_have_sufficient_space_for_upload_if_no_free_space(self):
         """Check have_sufficient_space_for_upload pushes SYS_QUOTA_EXCEEDED."""
         self.patch(self.action_queue.main.vm, 'get_free_space',
-                   lambda share_id: 0) # no free space, always
+                   lambda share_id: 0)  # no free space, always
         volume_id = 'test share'
         res = self.action_queue.have_sufficient_space_for_upload(volume_id,
                                                                  upload_size=1)
@@ -3936,7 +3940,7 @@
     def test_have_sufficient_space_for_upload_if_free_space(self):
         """Check have_sufficient_space_for_upload doesn't push any event."""
         self.patch(self.action_queue.main.vm, 'get_free_space',
-                   lambda share_id: 1) # free space, always
+                   lambda share_id: 1)  # free space, always
         res = self.action_queue.have_sufficient_space_for_upload(share_id=None,
                                                                  upload_size=0)
         self.assertEqual(res, True, "Must have enough space to upload.")
@@ -3957,20 +3961,10 @@
 
     def test_handle_SYS_USER_CONNECT(self):
         """handle_SYS_USER_CONNECT stores credentials."""
-        self.assertEqual(self.action_queue.token, None)
-        self.assertEqual(self.action_queue.consumer, None)
-
+        self.assertEqual(self.action_queue.credentials, {})
         self.user_connect()
-
-        expected = Client('bla', 'ble', 'foo', 'bar')
-
-        self.assertEqual(self.action_queue.token.key, expected.client_key)
-        self.assertEqual(self.action_queue.token.secret, 
-                         expected.client_secret)
-        self.assertEqual(self.action_queue.consumer.key, 
-                         expected.resource_owner_key)
-        self.assertEqual(self.action_queue.consumer.secret, 
-                         expected.resource_owner_secret)
+        self.assertEqual(self.action_queue.credentials,
+                         {'password': 'test_password', 'username': 'test_username'})
 
 
 class SpecificException(Exception):
@@ -4036,7 +4030,7 @@
         """_send_request_and_handle_errors is correct when no error."""
 
         event = 'SYS_SPECIFIC_OK'
-        EVENTS[event] = () # add event to the global valid events list
+        EVENTS[event] = ()  # add event to the global valid events list
         self.addCleanup(EVENTS.pop, event)
 
         result = object()
@@ -4080,7 +4074,7 @@
         """_send_request_and_handle_errors is correct when expected error."""
 
         event = 'SYS_SPECIFIC_ERROR'
-        EVENTS[event] = ('error',) # add event to the global valid events list
+        EVENTS[event] = ('error',)  # add event to the global valid events list
         self.addCleanup(EVENTS.pop, event)
 
         exc = SpecificException('The request failed! please be happy.')
@@ -4268,7 +4262,7 @@
 
         request = self.fail_please(exc)
         kwargs = dict(request=request, request_error=SpecificException,
-                  event_error='BAR', event_ok='FOO')
+                      event_error='BAR', event_ok='FOO')
         d = self.action_queue._send_request_and_handle_errors(**kwargs)
         yield d
 
@@ -4306,7 +4300,7 @@
             """Change AQ's client while doing the request."""
             self.action_queue.client = object()
 
-        self.action_queue.event_queue.events = [] # event cleanup
+        self.action_queue.event_queue.events = []  # event cleanup
         kwargs = dict(request=change_client, request_error=SpecificException,
                       event_error='BAR', event_ok='FOO')
         d = self.action_queue._send_request_and_handle_errors(**kwargs)
@@ -4345,7 +4339,7 @@
         event = ('SYS_SET_CAPABILITIES_ERROR', {'error': msg})
         self.assertEqual(event, self.action_queue.event_queue.events[-1])
         self.assertNotIn(('SYS_SET_CAPABILITIES_OK', {}),
-                          self.action_queue.event_queue.events)
+                         self.action_queue.event_queue.events)
 
     @defer.inlineCallbacks
     def test_set_capabilities_when_set_caps_not_accepted(self):
@@ -4361,7 +4355,7 @@
         event = ('SYS_SET_CAPABILITIES_ERROR', {'error': msg})
         self.assertEqual(event, self.action_queue.event_queue.events[-1])
         self.assertNotIn(('SYS_SET_CAPABILITIES_OK', {}),
-                          self.action_queue.event_queue.events)
+                         self.action_queue.event_queue.events)
 
     @defer.inlineCallbacks
     def test_set_capabilities_when_client_is_none(self):
@@ -4374,7 +4368,7 @@
         event = ('SYS_SET_CAPABILITIES_ERROR', {'error': msg})
         self.assertEqual(event, self.action_queue.event_queue.events[-1])
         self.assertNotIn(('SYS_SET_CAPABILITIES_OK', {}),
-                          self.action_queue.event_queue.events)
+                         self.action_queue.event_queue.events)
 
     @defer.inlineCallbacks
     def test_set_capabilities_when_set_caps_is_accepted(self):
@@ -4394,7 +4388,7 @@
         request = client.Authenticate(self.action_queue.client,
                                       {'dummy_token': 'credentials'})
         request.session_id = str(uuid.uuid4())
-        self.action_queue.client.oauth_authenticate = \
+        self.action_queue.client.simple_authenticate = \
             self.succeed_please(result=request)
         yield self.action_queue.authenticate()
         event = ('SYS_AUTH_OK', {})
@@ -4410,7 +4404,7 @@
         msg.error.comment = 'This is a funny comment.'
         exc = errors.AuthenticationFailedError(request=None, message=msg)
 
-        self.action_queue.client.oauth_authenticate = self.fail_please(exc)
+        self.action_queue.client.simple_authenticate = self.fail_please(exc)
         yield self.action_queue.authenticate()
         event = ('SYS_AUTH_ERROR', {'error': str(exc)})
         self.assertEqual(event, self.action_queue.event_queue.events[-1])
@@ -4773,7 +4767,7 @@
         self.patch(PathLockingTree, 'acquire',
                    lambda s, *a, **k: t.extend((a, k)))
         cmd = Unlink(self.rq, VOLUME, 'parent_id', 'node_id',
-                     os.path.join('foo','bar'), False)
+                     os.path.join('foo', 'bar'), False)
         cmd._acquire_pathlock()
         self.assertEqual(t, [('foo', 'bar'), {'on_parent': True,
                                               'on_children': True,
@@ -4799,7 +4793,7 @@
         """Test AQ_MOVE_OK is pushed on success."""
         # create a request and fill it with succesful information
         request = client.Move(self.action_queue.client, VOLUME, 'node',
-                                'new_parent', 'new_name')
+                              'new_parent', 'new_name')
         request.new_generation = 13
 
         # create a command and trigger it success
@@ -4835,8 +4829,8 @@
                    os.path.join(os.path.sep, 'path', 'to'))
         cmd._acquire_pathlock()
         should = [
-            ("", "path", "from"), {'on_parent': True, 'on_children': True,
-                                                            'logger': None},
+            ("", "path", "from"), {'on_parent': True,
+                                   'on_children': True, 'logger': None},
             ("", "path", "to"), {'on_parent': True, 'logger': None},
         ]
         self.assertEqual(t, should)
@@ -4930,7 +4924,7 @@
         """Test that it returns the correct values."""
         cmd = MakeFile(self.rq, VOLUME, 'parent', 'name', 'marker', self.mdid)
         res = [getattr(cmd, x) for x in cmd.possible_markers]
-        self.assertEqual(res, [ 'parent'])
+        self.assertEqual(res, ['parent'])
 
     def test_path_locking(self):
         """Test that it acquires correctly the path lock."""
@@ -5068,8 +5062,7 @@
         request = client.Authenticate(self.action_queue.client,
                                       {'dummy_token': 'credentials'})
         request.session_id = str(uuid.uuid4())
-        self.action_queue.client.oauth_authenticate = \
-                lambda *args: defer.succeed(request)
+        self.action_queue.client.simple_authenticate = lambda *args: defer.succeed(request)
 
         yield self.action_queue.authenticate()
 
@@ -5080,17 +5073,19 @@
     def test_send_platform_and_version(self):
         """Test that platform and version is sent to the server."""
         called = []
-        def fake_oauth_authenticate(*args, **kwargs):
+
+        def fake_authenticate(*args, **kwargs):
             called.append((args, kwargs))
             request = client.Authenticate(self.action_queue.client,
                                           {'dummy_token': 'credentials'})
             request.session_id = str(uuid.uuid4())
             return defer.succeed(request)
-        self.action_queue.client.oauth_authenticate = fake_oauth_authenticate
+
+        self.action_queue.client.simple_authenticate = fake_authenticate
         yield self.action_queue.authenticate()
         self.assertEqual(len(called), 1)
         metadata = called[0][0][2]
-        expected_metadata = {'platform':platform, 'version':clientdefs.VERSION}
+        expected_metadata = {'platform': platform, 'version': clientdefs.VERSION}
         self.assertEqual(metadata, expected_metadata)
 
 
@@ -5396,7 +5391,7 @@
         """Retry the command immediately."""
         finished = defer.Deferred()
         called = []
-        exc = twisted_error.ConnectionDone() # retryable!
+        exc = twisted_error.ConnectionDone()  # retryable!
         run_deferreds = [defer.fail(Failure(exc)), defer.succeed('finish')]
         self.cmd._run = lambda: called.append('run') or run_deferreds.pop(0)
         self.cmd.handle_retryable = lambda f: called.append(f.value)
@@ -5429,7 +5424,7 @@
         def f1():
             """Fail and make conditions not ok to run."""
             self.cmd.is_runnable = False
-            failure = Failure(twisted_error.ConnectionDone()) # retryable!
+            failure = Failure(twisted_error.ConnectionDone())  # retryable!
             return defer.fail(failure)
 
         def f2():
@@ -5473,6 +5468,7 @@
 
         # check cleanup
         self.cmd.cleanup = lambda: called.append(2)
+
         def fake_finish():
             """Flag and call the real one."""
             called.append(3)
@@ -5515,7 +5511,7 @@
         self.cmd.is_runnable = False
         released = []
         self.cmd._acquire_pathlock = lambda: defer.succeed(
-                                                lambda: released.append(True))
+            lambda: released.append(True))
 
         # let the command go (will stuck because not runnable), and
         # cancel in the middle
@@ -5532,7 +5528,7 @@
         self.queue.stop()
         released = []
         self.cmd._acquire_pathlock = lambda: defer.succeed(
-                                                lambda: released.append(True))
+            lambda: released.append(True))
 
         # let the command go (will stuck because not runnable), and
         # cancel in the middle
@@ -5675,7 +5671,6 @@
         intrdef.interrupt()
         self.assertFalse(intrdef.interrupted)
 
-
     def test_interrupt_except(self):
         """Interrupt!"""
         intrdef = InterruptibleDeferred(defer.Deferred())
@@ -5890,7 +5885,7 @@
         # call and check all is started when the ping is done
         self.pm._do_ping()
         self.assertTrue(self.pm._timeout_call.active())
-        self.handler.debug  = True
+        self.handler.debug = True
         self.assertTrue(self.handler.check(logger.TRACE, 'Sending ping'))
 
         # answer the ping, and check
 
=== modified file 'tests/syncdaemon/test_interaction_interfaces.py'
--- tests/syncdaemon/test_interaction_interfaces.py	2013-01-17 21:20:29 +0000
+++ tests/syncdaemon/test_interaction_interfaces.py	2015-05-18 21:26:35 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2011-2012 Canonical Ltd.
+# Copyright 2011-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -381,7 +381,7 @@
                   other='', running='True')
         self.assertEqual(result[2], ('FakeCommand', pl))
 
-        self.handler.debug=True
+        self.handler.debug = True
         self.assertTrue(self.handler.check_warning('deprecated'))
 
     def test_waiting_content(self):
@@ -579,7 +579,7 @@
         result = self.sd_obj.get_metadata_and_quick_tree_synced(expected_path)
 
         self.assertEqual(expected_path.decode('utf-8'),
-                          unicode(result['path']))
+                         unicode(result['path']))
         self.assertEqual(share.volume_id, result['share_id'])
         self.assertEqual(share.node_id, result['node_id'])
         self.assertEqual('synced', result['quick_tree_synced'])
@@ -610,7 +610,7 @@
         self.assertNotIn(mdid3, dirty_mdids)
         # check that path de/encoding is done correctly
         self.assertEqual(repr(self.main.fs.get_by_mdid(mdid2).path),
-                          repr(dirty_mdids[mdid2]['path'].encode('utf-8')))
+                         repr(dirty_mdids[mdid2]['path'].encode('utf-8')))
 
 
 class SyncdaemonSharesTestCase(BaseTestCase):
@@ -758,7 +758,7 @@
                                   ACCESS_LEVEL_RO)
 
         expected = [(a_dir, u, 'share_a_dir', ACCESS_LEVEL_RO)
-                     for u in usernames]
+                    for u in usernames]
         self.assertEqual(called, expected)
 
     def test_refresh_shares(self):
@@ -828,8 +828,8 @@
         self.main.fs.create(a_dir, "", is_dir=True)
         self.main.fs.set_node_id(a_dir, "node_id")
         share = Shared(path=a_dir, volume_id='shared_id', name=u'ñoño_shared',
-                      access_level=ACCESS_LEVEL_RO,
-                      other_username=u'test_username', node_id='node_id')
+                       access_level=ACCESS_LEVEL_RO,
+                       other_username=u'test_username', node_id='node_id')
         yield self.main.vm.add_shared(share)
 
         result = self.sd_obj.get_shared()
@@ -1210,7 +1210,7 @@
         self.addCleanup(self.event_q.unsubscribe, listener)
 
         event_name = 'FS_FILE_CREATE'
-        args = {'path':'bar'}
+        args = {'path': 'bar'}
         self.sd_obj.push_event(event_name, args)
 
         return d
@@ -1563,7 +1563,7 @@
     def test_handle_AQ_ANSWER_SHARE_ERROR(self):
         """Test the handle_AQ_ANSWER_SHARE_ERROR method."""
         share_id = 'share_id'
-        answer='foo'
+        answer = 'foo'
         error_msg = 'an error message'
         d = defer.Deferred()
         self.patch(self.sd_obj.interface.shares,
@@ -2204,7 +2204,7 @@
         yield super(SyncdaemonServiceTestCase, self).setUp()
         self.events = []
         self.sd_obj.main.event_q.push = lambda name, **kw: \
-                                        self.events.append((name, kw))
+            self.events.append((name, kw))
 
     def test_disconnect(self):
         """Test the disconnect method."""
@@ -2263,7 +2263,7 @@
         """Test for rescan_from_scratch with a non-existing volume."""
         volume_id = object()
         self.assertRaises(ValueError,
-            self.sd_obj.rescan_from_scratch, volume_id)
+                          self.sd_obj.rescan_from_scratch, volume_id)
 
     def test_network_state_changed_with_connection(self):
         """Test the network_state changed method with a connection."""
@@ -2348,7 +2348,7 @@
 
         self.events = []
         self.sd_obj.main.event_q.push = lambda name, **kw: \
-                                        self.events.append((name, kw))
+            self.events.append((name, kw))
 
         self.memento = MementoHandler()
         logger.addHandler(self.memento)
@@ -2383,48 +2383,19 @@
         d = self.sd_obj.connect(autoconnecting=self.autoconnecting)
         yield self.assertFailure(d, Exception)
 
-    def test_oauth_credentials_are_none_at_startup(self):
-        """If the oauth_credentials are not passed as param, they are None."""
-        self.assertTrue(self.sd_obj.oauth_credentials is None)
-
-    @defer.inlineCallbacks
-    def test_oauth_credentials_are_used_to_connect(self):
-        """If present, the oauth_credentials are used to connect."""
-        expected = {'consumer_key': 'ubuntuone',
-                    'consumer_secret': 'hammertime',
-                    'token': 'faked_token',
-                    'token_secret': 'faked_token_secret'}
-        self.sd_obj.oauth_credentials = (expected['token'],
-                                      expected['token_secret'])
-        yield self.sd_obj.connect(autoconnecting=self.autoconnecting)
-        self.assertEqual(self.events, [('SYS_USER_CONNECT',
-                                       {'access_token': expected})])
-
-    @defer.inlineCallbacks
-    def test_oauth_credentials_can_be_a_four_uple(self):
-        """If present, the oauth_credentials are used to connect."""
-        expected = {'consumer_key': 'faked_consumer_key',
-                    'consumer_secret': 'faked_consumer_secret',
-                    'token': 'faked_token',
-                    'token_secret': 'faked_token_secret'}
-        self.sd_obj.oauth_credentials = (expected['consumer_key'],
-                                      expected['consumer_secret'],
-                                      expected['token'],
-                                      expected['token_secret'])
-        yield self.sd_obj.connect(autoconnecting=self.autoconnecting)
-        self.assertEqual(self.events, [('SYS_USER_CONNECT',
-                                       {'access_token': expected})])
-
-    @defer.inlineCallbacks
-    def test_log_warning_if_oauth_credentials_len_is_useless(self):
-        """Log a warning and return if the oauth_credentials are useless."""
-        self.sd_obj.oauth_credentials = ('consumer_key',
-                                      'consumer_secret',
-                                      'token_secret')
-        yield self.sd_obj.connect(autoconnecting=self.autoconnecting)
-        self.assertEqual(self.events, [])
-        msgs = (str(self.sd_obj.oauth_credentials), 'useless')
-        self.assertTrue(self.memento.check_warning(*msgs))
+    def test_auth_credentials_are_none_at_startup(self):
+        """If the auth_credentials are not passed as param, they are None."""
+        self.assertTrue(self.sd_obj.auth_credentials is None)
+
+    @defer.inlineCallbacks
+    def test_auth_credentials_are_used_to_connect(self):
+        """If present, the auth_credentials are used to connect."""
+        expected = {'username': 'test_username',
+                    'password': 'test_password'}
+        self.sd_obj.auth_credentials = expected
+        yield self.sd_obj.connect(autoconnecting=self.autoconnecting)
+        self.assertEqual(self.events, [('SYS_USER_CONNECT',
+                                       {'access_token': expected})])
 
 
 class AutoconnectingTestCase(SyncdaemonServiceConnectTestCase):
 
=== modified file 'tests/syncdaemon/test_main.py'
--- tests/syncdaemon/test_main.py	2013-02-04 16:04:19 +0000
+++ tests/syncdaemon/test_main.py	2015-05-18 21:26:35 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -102,7 +102,7 @@
                     dns_srv=False, ssl=False,
                     mark_interval=60,
                     handshake_timeout=2,
-                    oauth_credentials=FAKED_CREDENTIALS,
+                    auth_credentials=FAKED_CREDENTIALS,
                     monitor_class=FakeMonitor)
 
     def build_main(self, **kwargs):
 
=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2013-02-04 21:33:35 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2015-05-18 21:26:35 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -53,7 +53,6 @@
 from twisted.names import client as dns_client
 from twisted.python.failure import Failure, DefaultException
 
-from oauthlib.oauth1 import Client
 from ubuntu_sso.utils.webclient import txweb
 from ubuntuone import clientdefs
 from ubuntuone.platform import platform, remove_file
@@ -234,8 +233,8 @@
             del node['children_nodes'][element]
 
         # finally, log and release the deferred
-        logger.debug("pathlock releasing %s; remaining: %d", elements,
-                                                             self.count)
+        logger.debug("pathlock releasing %s; remaining: %d",
+                     elements, self.count)
         deferred.callback(True)
 
     def fix_path(self, from_elements, to_elements):
@@ -308,7 +307,7 @@
 
         # fix the children deferreds after the movement
         all_children_deferreds = (node_to_move['node_deferreds'] |
-                                        node_to_move['children_deferreds'])
+                                  node_to_move['children_deferreds'])
         for node in branch[::-1]:
             node['children_deferreds'] = set(all_children_deferreds)
             all_children_deferreds.update(node['node_deferreds'])
@@ -771,9 +770,9 @@
                  use_ssl=False, disable_ssl_verify=False,
                  read_limit=None, write_limit=None, throttling_enabled=False,
                  connection_timeout=30):
-        ThrottlingStorageClientFactory.__init__(self, read_limit=read_limit,
-                                      write_limit=write_limit,
-                                      throttling_enabled=throttling_enabled)
+        ThrottlingStorageClientFactory.__init__(
+            self, read_limit=read_limit, write_limit=write_limit,
+            throttling_enabled=throttling_enabled)
         self.event_queue = event_queue
         self.main = main
         self.host = host
@@ -782,10 +781,7 @@
         self.use_ssl = use_ssl
         self.disable_ssl_verify = disable_ssl_verify
         self.connection_timeout = connection_timeout
-
-        # credentials
-        self.oauth_client = None
-        self.credentials = None
+        self.credentials = {}
 
         self.client = None  # an instance of self.protocol
 
@@ -809,9 +805,9 @@
         # data for the offloaded queue
         user_config = config.get_user_config()
         self.memory_pool_limit = user_config.get_memory_pool_limit()
-        self.commands = dict((x, y) for x, y in globals().iteritems()
-                             if inspect.isclass(y) and
-                                            issubclass(y, ActionQueueCommand))
+        self.commands = dict(
+            (x, y) for x, y in globals().iteritems()
+            if inspect.isclass(y) and issubclass(y, ActionQueueCommand))
 
     def check_conditions(self):
         """Check conditions in the locker, to release all the waiting ops."""
@@ -830,31 +826,9 @@
         return enough
 
     def handle_SYS_USER_CONNECT(self, access_token):
-        """Stow the access token away for later use."""
-        self.credentials = access_token
-        self.oauth_client = Client(access_token['token'],
-                                   access_token['token_secret'],
-                                   access_token['consumer_key'],
-                                   access_token['consumer_secret'])
-
-    # For API backward compatibility.
-    @property
-    def token(self):
-        if self.oauth_client is None:
-            return None
-        class _Token:
-            key = self.oauth_client.client_key
-            secret = self.oauth_client.client_secret
-        return _Token()
-
-    @property
-    def consumer(self):
-        if self.oauth_client is None:
-            return None
-        class _Consumer:
-            key = self.oauth_client.resource_owner_key
-            secret = self.oauth_client.resource_owner_secret
-        return _Consumer()
+        """Stow the credentials for later use."""
+        self.credentials = dict(username=access_token['username'],
+                                password=access_token['password'])
 
     def _cleanup_connection_state(self, *args):
         """Reset connection state."""
@@ -939,13 +913,13 @@
         else:
             return defer.succeed((self.host, self.port))
 
-
     @defer.inlineCallbacks
     def webcall(self, iri, **kwargs):
         """Perform a web call to the api servers."""
         webclient = yield self.get_webclient(iri)
-        response = yield webclient.request(iri,
-                             oauth_credentials=self.credentials, **kwargs)
+        # FIXME: we need to review these requests after credentials change
+        response = yield webclient.request(
+            iri, oauth_credentials=self.credentials, **kwargs)
         defer.returnValue(response)
 
     @defer.inlineCallbacks
@@ -967,12 +941,12 @@
         ssl_context = get_ssl_context(self.disable_ssl_verify, host)
         client = yield self.tunnel_runner.get_client()
         if self.use_ssl:
-            self.connector = client.connectSSL(host, port, factory=self,
-                                            contextFactory=ssl_context,
-                                            timeout=self.connection_timeout)
+            self.connector = client.connectSSL(
+                host, port, factory=self, contextFactory=ssl_context,
+                timeout=self.connection_timeout)
         else:
-            self.connector = client.connectTCP(host, port, self,
-                                            timeout=self.connection_timeout)
+            self.connector = client.connectTCP(
+                host, port, self, timeout=self.connection_timeout)
 
     def connect(self):
         """Start the circus going."""
@@ -1004,7 +978,7 @@
         self.client.set_volume_created_callback(self._volume_created_callback)
         self.client.set_volume_deleted_callback(self._volume_deleted_callback)
         self.client.set_volume_new_generation_callback(
-                                        self._volume_new_generation_callback)
+            self._volume_new_generation_callback)
 
         logger.info('Connection made.')
         return self.client
@@ -1104,7 +1078,7 @@
         if failure is not None:
             if event is None:
                 logger.info("The request '%s' failed with the error: %s",
-                             req_name, failure)
+                            req_name, failure)
             else:
                 logger.info("The request '%s' failed with the error: %s "
                             "and was handled with the event: %s",
@@ -1162,12 +1136,13 @@
         """Authenticate against the server using stored credentials."""
         metadata = {'version': clientdefs.VERSION,
                     'platform': platform}
+        username = self.credentials.get('username')
+        password = self.credentials.get('password')
         authenticate_d = self._send_request_and_handle_errors(
-            request=self.client.oauth_authenticate,
+            request=self.client.simple_authenticate,
             request_error=protocol_errors.AuthenticationFailedError,
             event_error='SYS_AUTH_ERROR', event_ok='SYS_AUTH_OK',
-            # XXX: handle self.token is None or self.consumer is None?
-            args=(self.consumer, self.token, metadata))
+            args=(username, password, metadata))
         req = yield authenticate_d
 
         # req can be None if the auth failed, but it's handled by
@@ -1380,7 +1355,7 @@
         """Create a logger for this object."""
         share_id = getattr(self, "share_id", UNKNOWN)
         node_id = getattr(self, "node_id", None) or \
-                      getattr(self, "marker", UNKNOWN)
+            getattr(self, "marker", UNKNOWN)
         self.log = mklog(logger, self.__class__.__name__,
                          share_id, node_id, **self.to_dict())
 
@@ -1620,7 +1595,7 @@
         name = self.__class__.__name__
         if len(str_attrs) == 0:
             return name
-        attrs = [str(attr) + '=' + str(getattr(self, attr, None) or 'None') \
+        attrs = [str(attr) + '=' + str(getattr(self, attr, None) or 'None')
                  for attr in str_attrs]
         return ''.join([name, '(', ', '.join([attr for attr in attrs]), ')'])
 
@@ -1668,8 +1643,8 @@
         """Acquire pathlock."""
         self.path = self._get_current_path(self.mdid)
         pathlock = self.action_queue.pathlock
-        return pathlock.acquire(*self.path.split(os.path.sep), on_parent=True,
-                                                               logger=self.log)
+        return pathlock.acquire(*self.path.split(os.path.sep),
+                                on_parent=True, logger=self.log)
 
 
 class MakeFile(MakeThing):
@@ -1955,9 +1930,9 @@
         """Do the actual running."""
         if self.use_http:
             # External user, do the HTTP REST method
-            return self._create_share_http(self.node_id, self.share_to,
-                                         self.name,
-                                         self.access_level != ACCESS_LEVEL_RW)
+            return self._create_share_http(
+                self.node_id, self.share_to, self.name,
+                self.access_level != ACCESS_LEVEL_RW)
         else:
             return self.action_queue.client.create_share(self.node_id,
                                                          self.share_to,
@@ -2384,7 +2359,7 @@
                  'fileobj', 'gunzip', 'mdid', 'download_req', 'tx_semaphore',
                  'deflated_size', 'n_bytes_read_last', 'n_bytes_read', 'path')
     logged_attrs = ActionQueueCommand.logged_attrs + (
-                    'share_id', 'node_id', 'server_hash', 'mdid', 'path')
+        'share_id', 'node_id', 'server_hash', 'mdid', 'path')
     possible_markers = 'node_id',
 
     def __init__(self, request_queue, share_id, node_id, server_hash, mdid):
@@ -2553,10 +2528,10 @@
                  'n_bytes_written', 'upload_id', 'mdid', 'path')
 
     logged_attrs = ActionQueueCommand.logged_attrs + (
-                    'share_id', 'node_id', 'previous_hash', 'hash', 'crc32',
-                    'size', 'upload_id', 'mdid', 'path')
+        'share_id', 'node_id', 'previous_hash', 'hash', 'crc32',
+        'size', 'upload_id', 'mdid', 'path')
     retryable_errors = ActionQueueCommand.retryable_errors + (
-                                        protocol_errors.UploadInProgressError,)
+        protocol_errors.UploadInProgressError,)
     possible_markers = 'node_id',
 
     def __init__(self, request_queue, share_id, node_id, previous_hash, hash,
@@ -2591,7 +2566,7 @@
             return True
         else:
             return self.action_queue.have_sufficient_space_for_upload(
-                                                    self.share_id, self.size)
+                self.share_id, self.size)
 
     def _should_be_queued(self):
         """Queue but keeping uniqueness."""
@@ -2633,8 +2608,7 @@
     def cleanup(self):
         """Cleanup: stop the producer."""
         self.log.debug('cleanup')
-        if self.upload_req is not None and \
-        self.upload_req.producer is not None:
+        if self.upload_req is not None and self.upload_req.producer is not None:
             self.log.debug('stopping the producer')
             self.upload_req.producer.stopProducing()
 
@@ -2696,7 +2670,7 @@
     def progress_hook(self):
         """Send event if accumulated enough progress."""
         written_since_last = self.n_bytes_written - self.n_bytes_written_last
-        if  written_since_last >= TRANSFER_PROGRESS_THRESHOLD:
+        if written_since_last >= TRANSFER_PROGRESS_THRESHOLD:
             event_data = dict(share_id=self.share_id, node_id=self.node_id,
                               n_bytes_written=self.n_bytes_written,
                               deflated_size=self.deflated_size)
 
=== modified file 'ubuntuone/syncdaemon/interaction_interfaces.py'
--- ubuntuone/syncdaemon/interaction_interfaces.py	2014-05-22 19:22:44 +0000
+++ ubuntuone/syncdaemon/interaction_interfaces.py	2015-05-18 21:26:35 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2011-2012 Canonical Ltd.
+# Copyright 2011-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -38,7 +38,6 @@
 """
 
 import collections
-import datetime
 import logging
 import os
 import uuid
@@ -846,7 +845,7 @@
 
     @log_call(logger.trace)
     def handle_AQ_UPLOAD_FILE_PROGRESS(self, share_id, node_id,
-                                         n_bytes_written, deflated_size):
+                                       n_bytes_written, deflated_size):
         """Handle AQ_UPLOAD_FILE_PROGRESS."""
         info = dict(n_bytes_written=str(n_bytes_written),
                     deflated_size=str(deflated_size))
@@ -1052,7 +1051,7 @@
             else:
                 logger.error("Unable to handle VM_VOLUME_DELETE_ERROR (%r) "
                              "for volume_id=%r as it's not a Share or UDF",
-                              error, volume_id)
+                             error, volume_id)
 
     @log_call(logger.debug)
     def handle_VM_SHARE_CHANGED(self, share_id):
@@ -1193,7 +1192,7 @@
 
         self.send_events = send_events
         self.network_manager = NetworkManagerState(
-                                result_cb=self.network_state_changed)
+            result_cb=self.network_state_changed)
         self.network_manager.find_online_state()
 
         if interface is None:
@@ -1209,7 +1208,7 @@
             self.all_events_sender = AllEventsSender(self.interface.events)
             self.main.event_q.subscribe(self.all_events_sender)
 
-        self.oauth_credentials = None
+        self.auth_credentials = None
 
     def _create_children(self):
         """Create the specific syncdaemon objects."""
@@ -1246,31 +1245,13 @@
         The token is requested via com.ubuntuone.credentials service. If
         'autoconnecting' is True, no UI window will be raised to prompt the user
         for login/registration, only already existent credentials will be used.
-
         """
-        # Avoid connecting after June 1.
-        end_date = datetime.date(2014, 6, 1)
-        if datetime.date.today() >= end_date:
-            return
-
-        if self.oauth_credentials is not None:
-            logger.debug('connect: oauth credentials were given by parameter.')
-            ckey = csecret = key = secret = None
-            if len(self.oauth_credentials) == 4:
-                ckey, csecret, key, secret = self.oauth_credentials
-            elif len(self.oauth_credentials) == 2:
-                ckey, csecret = ('ubuntuone', 'hammertime')
-                key, secret = self.oauth_credentials
-            else:
-                msg = 'connect: oauth_credentials (%r) was set but is useless!'
-                logger.warning(msg, self.oauth_credentials)
-                return
-            token = {'consumer_key': ckey, 'consumer_secret': csecret,
-                     'token': key, 'token_secret': secret}
+        if self.auth_credentials is not None:
+            logger.debug('connect: auth credentials were given by parameter.')
+            token = self.auth_credentials
         else:
             try:
-                token = yield self._request_token(
-                                            autoconnecting=autoconnecting)
+                token = yield self._request_token(autoconnecting=autoconnecting)
             except Exception, e:
                 logger.exception('failure while getting the token')
                 raise NoAccessToken(e)
@@ -1282,6 +1263,8 @@
 
     def _request_token(self, autoconnecting):
         """Request to SSO auth service to fetch the token."""
+        # FIXME: we need to unbind this from SSO, probably just
+        # get tokens from keyring
         # call ubuntu sso
         management = credentials.CredentialsManagementTool()
         # return the deferred, since we are no longer using signals
 
=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2014-05-22 18:00:54 +0000
+++ ubuntuone/syncdaemon/main.py	2015-05-18 21:26:35 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -89,7 +89,7 @@
                  handshake_timeout=30,
                  shares_symlink_name='Shared With Me',
                  read_limit=None, write_limit=None, throttling_enabled=False,
-                 ignore_files=None, oauth_credentials=None,
+                 ignore_files=None, auth_credentials=None,
                  monitor_class=None):
         self.root_dir = root_dir
         self.shares_dir = shares_dir
@@ -115,8 +115,8 @@
         self.vm = volume_manager.VolumeManager(self)
         self.fs = filesystem_manager.FileSystemManager(
             data_dir, partials_dir, self.vm, self.db)
-        self.event_q = event_queue.EventQueue(self.fs, ignore_files,
-                monitor_class=monitor_class)
+        self.event_q = event_queue.EventQueue(
+            self.fs, ignore_files, monitor_class=monitor_class)
         self.fs.register_eq(self.event_q)
 
         # subscribe VM to EQ, to be unsubscribed in shutdown
@@ -142,7 +142,7 @@
 
         self.external = SyncdaemonService(main=self,
                                           send_events=broadcast_events)
-        self.external.oauth_credentials = oauth_credentials
+        self.external.auth_credentials = auth_credentials
         if user_config.get_autoconnect():
             self.external.connect(autoconnecting=True)
 
@@ -154,8 +154,8 @@
 
     def start_status_listener(self):
         """Start the status listener if it is configured to start."""
-        self.status_listener = status_listener.get_listener(self.fs, self.vm,
-            self.external)
+        self.status_listener = status_listener.get_listener(
+            self.fs, self.vm, self.external)
         # subscribe to EQ, to be unsubscribed in shutdown
         if self.status_listener:
             self.event_q.subscribe(self.status_listener)
@@ -302,7 +302,7 @@
         def stop_the_press(failure):
             """Something went wrong in LR, can't continue."""
             self.logger.error("Local rescan finished with error: %s",
-                                                failure.getBriefTraceback())
+                              failure.getBriefTraceback())
             self.event_q.push('SYS_UNKNOWN_ERROR')
 
         d.addCallbacks(local_rescan_done, stop_the_press)