Merge lp:~nataliabidart/ubuntuone-client/split-oauth into lp:ubuntuone-client

[Natalia Bidart]

Split out the code for oauthdesktop.

Split out the code for oauthdesktop.

Until the package for ubuntu-sso-client is built, you'll need to manually add symlinks to run the tests as per:

nessita@dali:~/canonical/ubuntuone-client/split-oauth$ ls -l bin/
lrwxrwxrwx 1 nessita nessita 49 2010-06-09 15:54 ubuntu-login -> ../../../ubuntu-sso-client/trunk/bin/ubuntu-login

nessita@dali:~/canonical/ubuntuone-client/split-oauth$ ls -l .
lrwxrwxrwx 1 nessita nessita 36 2010-06-09 15:54 ubuntu -> ../../ubuntu-sso-client/trunk/ubuntu

[Rodrigo Moya (rodrigo-moya)]

Let's first finish the renaming of the Python packages and DBus service in ubuntu-sso-client, and then let's change this branch to reflect that renaming, so that we don't need to do any further changes (at least renames) in u1-client

[Natalia Bidart (nataliabidart)]

> Let's first finish the renaming of the Python packages and DBus service in
> ubuntu-sso-client, and then let's change this branch to reflect that renaming,
> so that we don't need to do any further changes (at least renames) in
> u1-client

Renamed was finished.

[dobey (dobey)]

The tests/test_login.py needs to be moved to the ubuntu-sso-client tree, rather than staying here. Ideally the oauthdesktop code should be fixed to not use twisted for the temporary local http server any more. And in fact, it won't need to have a local server after it is fixed to not use the browser for doing auth. Moving this test will also obviate the need for having the symlink to ubuntu-login.

We're also going to need to have the symlink creation either be automated (or unneccessary).

Given the hour though, we can discuss it more tomorrow.

review: Needs Fixing

[Rodrigo Moya (rodrigo-moya)]

I think we can solve the test-login thing in another branch, so approve from me

review: Approve

[dobey (dobey)]

Can we simplify ubuntu-sso-client to just provide the "ubuntusso" namespace, rather than the empty ubuntu namespace (which may present future conflicts) with the sso sub package?

[Natalia Bidart (nataliabidart)]

> Can we simplify ubuntu-sso-client to just provide the "ubuntusso" namespace,
> rather than the empty ubuntu namespace (which may present future conflicts)
> with the sso sub package?

Name simplified to ubuntu_sso.

[lp:~nataliabidart/ubuntuone-client/split-oauth]

534. By Natalia Bidart on 2010-06-10

Merged trunk in.

535. By Natalia Bidart on 2010-06-10

Applying seconds rename for Ubuntu SSO.

536. By Natalia Bidart on 2010-06-14

Making tests no depend on sso-client tests.

537. By Natalia Bidart on 2010-06-14

Restoting FakeLogin and FakeProcessor.

538. By Natalia Bidart on 2010-06-15

Merged trunk in.

539. By Natalia Bidart on 2010-06-15

Skipping test_login.

540. By Natalia Bidart on 2010-06-15

Poiting to the righ binary.

541. By Natalia Bidart on 2010-06-16

Merged trunk in.

[Natalia Bidart (nataliabidart)]

Package ubuntu-sso-client is being sponsored and soon to be on main. In the mean time, it can be downloaded from https://launchpad.net/~nataliabidart/+archive/ppa

The split is ready to go into trunk.

[dobey (dobey)]

Please just remove the test_login.py in this branch. I have a branch for ubuntu-sso-client nearly ready to propose, which moves it there.

review: Needs Fixing

[lp:~nataliabidart/ubuntuone-client/split-oauth]

542. By Natalia Bidart on 2010-06-16

Removing test_login which will be moved to ubuntu-sso-client project.

[dobey (dobey)]

OK. Aside from potential smaller issues that might crop up, and some possible small changes we might need to make to use ubuntu-sso-client uninstalled, this seems ok to me now.

review: Approve

=== modified file 'Makefile.am'
--- Makefile.am	2010-06-11 15:33:16 +0000
+++ Makefile.am	2010-06-16 20:35:34 +0000
@@ -25,7 +25,6 @@
 	bin/u1sync
 
 libexec_SCRIPTS = 			\
-	bin/ubuntuone-login		\
 	bin/ubuntuone-syncdaemon
 
 manfilesdir = $(mandir)/man1

=== removed file 'bin/ubuntuone-login'
--- bin/ubuntuone-login	2010-04-14 23:31:21 +0000
+++ bin/ubuntuone-login	1970-01-01 00:00:00 +0000
@@ -1,238 +0,0 @@
-#!/usr/bin/python
-
-# ubuntuone-login - Client side log-in utility for Ubuntu One
-#
-# Author: Rodney Dawes <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import pygtk
-pygtk.require('2.0')
-import gtk
-import pango
-import sys
-import gettext
-from ubuntuone import clientdefs
-
-import dbus.service
-
-from dbus.mainloop.glib import DBusGMainLoop
-from ubuntuone.oauthdesktop.main import Login
-
-from ubuntuone.oauthdesktop.logger import setupLogging
-logger = setupLogging("ubuntuone-login")
-
-DBusGMainLoop(set_as_default=True)
-
-_ = gettext.gettext
-ngettext = gettext.ngettext
-
-DBUS_IFACE_AUTH_NAME = "com.ubuntuone.Authentication"
-
-OAUTH_REALM = "https://ubuntuone.com"
-OAUTH_CONSUMER = "ubuntuone"
-
-NOTIFY_ICON_SIZE = 48
-
-# Why thank you GTK+ for enforcing style-set and breaking API
-RCSTYLE = """
-style 'dialogs' {
-  GtkDialog::action-area-border = 12
-  GtkDialog::button-spacing = 6
-  GtkDialog::content-area-border = 0
-}
-widget_class '*Dialog*' style 'dialogs'
-"""
-
-
-class LoginMain(object):
-    """Main login manager process class."""
-
-    def __init__(self, *args, **kw):
-        """Initializes the child threads and dbus monitor."""
-        gtk.rc_parse_string(RCSTYLE)
-
-        logger.info(_("Starting Ubuntu One login manager version %s") %
-                    clientdefs.VERSION)
-
-        self.__bus = dbus.SessionBus()
-
-    def _connect_dbus_signals(self):
-        """Set up some signal handlers for DBus signals."""
-        self.__bus.add_signal_receiver(
-              handler_function=self.new_credentials,
-              signal_name="NewCredentials",
-              dbus_interface=DBUS_IFACE_AUTH_NAME)
-        self.__bus.add_signal_receiver(
-              handler_function=self.auth_denied,
-              signal_name="AuthorizationDenied",
-              dbus_interface=DBUS_IFACE_AUTH_NAME)
-        self.__bus.add_signal_receiver(
-              handler_function=self.got_oauth_error,
-              signal_name="OAuthError",
-              dbus_interface=DBUS_IFACE_AUTH_NAME)
-
-
-    def new_credentials(self, realm=None, consumer_key=None, sender=None):
-        """Signal callback for when we get new credentials."""
-        self.set_up_desktopcouch_pairing(consumer_key)
-
-        def got_port(*args, **kwargs):
-            # Discard the value.  We don't really care about the port, here.
-            pass
-
-        def got_error(*args, **kwargs):
-            logger.warn("On trying to start desktopcouch-service via DBus, "
-                    "we got an error.  %s %s" % (args, kwargs,))
-
-        # We have auth, so start desktopcouch service by asking for its port.
-        dc_serv_proxy = self.__bus.get_object("org.desktopcouch.CouchDB", "/")
-        dc_serv_proxy.getPort(reply_handler=got_port, error_handler=got_error)
-
-    def auth_denied(self):
-        """Signal callback for when auth was denied by user."""
-        logger.info(_("Access to Ubuntu One was denied."))
-
-        from twisted.internet import reactor
-        reactor.stop()
-
-    def got_oauth_error(self, message=None):
-        """Signal callback for when an OAuth error occured."""
-        def dialog_response(dialog, response):
-            """Handle the dialog closing."""
-            dialog.destroy()
-
-        if message:
-            logger.error(message)
-            dialog = gtk.Dialog(title=_("Ubuntu One: Error"),
-                                flags=gtk.DIALOG_NO_SEPARATOR,
-                                buttons=(gtk.STOCK_CLOSE,
-                                         gtk.RESPONSE_CLOSE))
-            dialog.set_default_response(gtk.RESPONSE_CLOSE)
-            dialog.set_icon_name("ubuntuone-client")
-
-            area = dialog.get_content_area()
-
-            hbox = gtk.HBox(spacing=12)
-            hbox.set_border_width(12)
-            area.pack_start(hbox)
-            hbox.show()
-
-            image = gtk.Image()
-            image.set_from_icon_name("dialog-error", gtk.ICON_SIZE_DIALOG)
-            image.set_alignment(0.5, 0.0)
-            image.show()
-            hbox.pack_start(image, False, False)
-
-            vbox = gtk.VBox(spacing=12)
-            vbox.show()
-            hbox.pack_start(vbox)
-
-            label = gtk.Label("<b>%s</b>" % _("Authorization Error"))
-            label.set_use_markup(True)
-            label.set_alignment(0.0, 0.5)
-            label.show()
-            vbox.pack_start(label, False, False)
-
-            label = gtk.Label(message)
-            label.set_line_wrap(True)
-            label.set_max_width_chars(64)
-            label.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
-            label.set_alignment(0.0, 0.0)
-            label.show()
-            vbox.pack_start(label, True, True)
-
-            dialog.connect('close', dialog_response, gtk.RESPONSE_CLOSE)
-            dialog.connect('response', dialog_response)
-
-            dialog.show()
-        else:
-            logger.error(_("Got an OAuth error with no message."))
-
-    def set_up_desktopcouch_pairing(self, consumer_key):
-        """Add a pairing record between desktopcouch and Ubuntu One"""
-        try:
-            from desktopcouch.pair.couchdb_pairing.couchdb_io import \
-                 put_static_paired_service
-            from desktopcouch.records.server import CouchDatabase
-        except ImportError:
-            # desktopcouch is not installed
-            logger.debug(_("Not adding desktopcouch pairing since"
-                " desktopcouch is not installed"))
-            return
-        # Check whether there is already a record of the Ubuntu One service
-        db = CouchDatabase("management", create=True)
-        if not db.view_exists("ubuntu_one_pair_record","ubuntu_one_pair_record"):
-            map_js = """function(doc) {
-                if (doc.service_name == "ubuntuone") {
-                    if (doc.application_annotations &&
-                        doc.application_annotations["Ubuntu One"] &&
-                        doc.application_annotations["Ubuntu One"]["private_application_annotations"] &&
-                        doc.application_annotations["Ubuntu One"]["private_application_annotations"]["deleted"]) {
-                        emit(doc._id, 1);
-                    } else {
-                        emit(doc._id, 0)
-                    }
-                }
-            }"""
-            db.add_view("ubuntu_one_pair_record", map_js, None,
-                "ubuntu_one_pair_record")
-        results = db.execute_view("ubuntu_one_pair_record",
-            "ubuntu_one_pair_record")
-        found = False
-        # Results should contain either one row or no rows
-        # If there is one row, its value will be 0, meaning that there is
-        #   already an Ubuntu One pairing record, or 1, meaning that there
-        #   was an Ubuntu One pairing record but it has since been unpaired
-        # Only create a new record if there is not one already. Specifically,
-        #   do not add the record if there is a deleted one, as this means
-        #   that the user explicitly unpaired it!
-        for row in results:
-            found = True
-            if row.value == 1:
-                logger.debug(_("Not adding desktopcouch pairing since"
-                " the user has explicitly unpaired with Ubuntu One"))
-            else:
-                logger.debug(_("Not adding desktopcouch pairing since"
-                " we are already paired"))
-        if not found:
-            put_static_paired_service(None, "ubuntuone")
-            logger.debug(_("Pairing desktopcouch with Ubuntu One"))
-
-    def main(self):
-        """Starts the gtk main loop."""
-        self._connect_dbus_signals()
-
-        from twisted.internet import reactor
-        reactor.run()
-
-
-if __name__ == "__main__":
-    gettext.bindtextdomain(clientdefs.GETTEXT_PACKAGE, clientdefs.LOCALEDIR)
-    gettext.textdomain(clientdefs.GETTEXT_PACKAGE)
-
-    # Register DBus service for making sure we run only one instance
-    bus = dbus.SessionBus()
-    if bus.request_name(DBUS_IFACE_AUTH_NAME, dbus.bus.NAME_FLAG_DO_NOT_QUEUE) == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
-        print _("Ubuntu One login manager already running, quitting")
-        sys.exit(0)
-
-    from twisted.internet import gtk2reactor
-    gtk2reactor.install()
-
-    login = Login(dbus.service.BusName(DBUS_IFACE_AUTH_NAME,
-                                       bus=dbus.SessionBus()))
-    manager = LoginMain()
-    manager.main()

=== modified file 'bin/ubuntuone-preferences'
--- bin/ubuntuone-preferences	2010-06-11 16:17:34 +0000
+++ bin/ubuntuone-preferences	2010-06-16 20:35:34 +0000
@@ -33,6 +33,8 @@
 import subprocess
 from threading import Thread
 from oauth import oauth
+
+from ubuntu_sso import DBUS_IFACE_AUTH_NAME, DBUS_PATH_AUTH
 from ubuntuone import clientdefs
 from ubuntuone.syncdaemon.tools import SyncDaemonTool
 from ubuntuone.api.restclient import RestClient
@@ -68,9 +70,6 @@
 DBUS_IFACE_CONFIG_NAME = DBUS_IFACE_NAME + ".Config"
 DBUS_IFACE_STATUS_NAME = DBUS_IFACE_NAME + ".Status"
 
-DBUS_IFACE_AUTH_NAME = "com.ubuntuone.Authentication"
-DBUS_IFACE_AUTH_PATH = "/"
-
 # Our own DBus interface
 PREFS_BUS_NAME = "com.ubuntuone.Preferences"
 
@@ -104,7 +103,7 @@
     """Make a login request to the login handling daemon."""
     try:
         client = bus.get_object(DBUS_IFACE_AUTH_NAME,
-                                DBUS_IFACE_AUTH_PATH,
+                                DBUS_PATH_AUTH,
                                 follow_name_owner_changes=True)
         iface = dbus.Interface(client, DBUS_IFACE_AUTH_NAME)
         iface.login('https://ubuntuone.com', 'ubuntuone',
@@ -474,7 +473,7 @@
         if token == local.key:
             try:
                 client = self.bus.get_object(DBUS_IFACE_AUTH_NAME,
-                                             DBUS_IFACE_AUTH_PATH,
+                                             DBUS_PATH_AUTH,
                                              follow_name_owner_changes=True)
                 iface = dbus.Interface(client, DBUS_IFACE_AUTH_NAME)
                 iface.clear_token('https://ubuntuone.com', 'ubuntuone',

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-05-26 21:43:27 +0000
+++ contrib/testing/testcase.py	2010-06-16 20:35:34 +0000
@@ -25,7 +25,7 @@
 import shutil
 import itertools
 
-from ubuntuone.oauthdesktop.main import Login, LoginProcessor
+from ubuntu_sso.main import Login, LoginProcessor
 from ubuntuone.syncdaemon import (
     config,
     action_queue,

=== modified file 'data/Makefile.am'
--- data/Makefile.am	2010-06-11 15:33:16 +0000
+++ data/Makefile.am	2010-06-16 20:35:34 +0000
@@ -7,10 +7,7 @@
 
 configdir = $(sysconfdir)/xdg/ubuntuone
 config_in_files = logging.conf.in
-config_DATA = oauth_urls syncdaemon.conf $(config_in_files:.conf.in=.conf)
-
-oauthdir = $(configdir)/oauth_registration.d
-oauth_DATA = oauth_registration.d/ubuntuone
+config_DATA = syncdaemon.conf $(config_in_files:.conf.in=.conf)
 
 memenudir = $(datadir)/indicators/me
 memenu_in_files = ubuntuone.menu.in
@@ -45,7 +42,6 @@
 
 servicedir = $(DBUS_SERVICES_DIR)
 service_in_files = \
-	com.ubuntuone.Authentication.service.in \
 	com.ubuntuone.SyncDaemon.service.in
 service_DATA = $(service_in_files:.service.in=.service)
 
@@ -146,8 +142,7 @@
 	stamp-render		\
 	$(config_DATA)		\
 	$(apport_DATA)		\
-	$(crashdb_DATA)		\
-	oauth_registration.d
+	$(crashdb_DATA)
 
 CLEANFILES =		\
 	$(memenu_DATA)	\

=== removed file 'data/com.ubuntuone.Authentication.service.in'
--- data/com.ubuntuone.Authentication.service.in	2009-12-23 19:44:00 +0000
+++ data/com.ubuntuone.Authentication.service.in	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-[D-BUS Service]
-Name=com.ubuntuone.Authentication
-Exec=@libexecdir@/ubuntuone-login

=== removed directory 'data/oauth_registration.d'
=== removed file 'data/oauth_registration.d/ubuntuone'
--- data/oauth_registration.d/ubuntuone	2010-03-31 16:12:39 +0000
+++ data/oauth_registration.d/ubuntuone	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-[storagefs-live]
-realm = https://ubuntuone.com
-consumer_key = ubuntuone
-exe_path = /usr/bin/python
-application_name = ubuntuone-syncdaemon
-
-[storagefs-local]
-realm = http://localhost
-consumer_key = ubuntuone
-exe_path = /usr/bin/python
-application_name = ubuntuone-syncdaemon
-
-[control-panel]
-realm = https://ubuntuone.com
-consumer_key = ubuntuone
-exe_path = /usr/bin/python
-application_name = ubuntuone-preferences
-
-[launcher]
-realm = https://ubuntuone.com
-consumer_key = ubuntuone
-exe_path = /usr/bin/python
-application_name = ubuntuone-launch

=== removed file 'data/oauth_urls'
--- data/oauth_urls	2009-05-12 13:36:05 +0000
+++ data/oauth_urls	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-[default]
-request_token_url = /oauth/request/
-user_authorisation_url = /oauth/authorize/
-access_token_url = /oauth/access/
-consumer_secret=hammertime

=== removed directory 'tests/oauthdesktop'
=== removed file 'tests/oauthdesktop/__init__.py'
--- tests/oauthdesktop/__init__.py	2009-05-12 13:36:05 +0000
+++ tests/oauthdesktop/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,14 +0,0 @@
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Tests for OAuth library"""

=== removed file 'tests/oauthdesktop/test_auth.py'
--- tests/oauthdesktop/test_auth.py	2010-01-11 17:46:00 +0000
+++ tests/oauthdesktop/test_auth.py	1970-01-01 00:00:00 +0000
@@ -1,263 +0,0 @@
-# test_auth - Tests for ubuntuone.oauthdesktop.auth module
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Tests for the OAuth client code for StorageFS."""
-
-import gnomekeyring
-from contrib.mocker import ANY, IN, MockerTestCase
-import testresources
-
-from oauth import oauth
-from twisted.trial.unittest import TestCase as TwistedTestCase
-from ubuntuone.oauthdesktop.auth import (AuthorisationClient,
-                                                NoAccessToken)
-
-
-# Adding TwistedTestCase as parent to be able to skip
-# test_ensure_access_token_no_token
-class AuthorisationClientTests(MockerTestCase, TwistedTestCase):
-    """Test the GNOME keyring integration portions of the auth code."""
-
-    def setUp(self):
-        """Sets up a mock keyring."""
-        MockerTestCase.setUp(self)
-        self.keyring = self.mocker.mock()
-        self.client = None
-        self.item = self.mocker.mock(gnomekeyring.Found)
-
-        self.item_id = 999
-
-        ex = self.expect(self.item.item_id)
-        ex.result(self.item_id)
-        ex.count(0, None)
-
-        ex = self.expect(self.item.secret)
-        ex.result('oauth_token=access_key&oauth_token_secret=access_secret')
-        ex.count(0, None)
-
-    def expect_token_query(self):
-        """Expects the keyring to be queried for a token."""
-        return self.expect(
-            self.keyring.find_items_sync(
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                {'ubuntuone-realm': 'realm',
-                 'oauth-consumer-key': 'consumer_key'})
-            )
-
-    def expect_token_store(self):
-        """Expects the token to be stored in the keyring."""
-        return self.expect(self.keyring.item_create_sync(
-                None, gnomekeyring.ITEM_GENERIC_SECRET,
-                'UbuntuOne token for realm',
-                {'ubuntuone-realm': 'realm',
-                 'oauth-consumer-key': 'consumer_key'},
-                # Either order for the token and secret is valid
-                IN(['oauth_token=access_key&oauth_token_secret=access_secret',
-                    'oauth_token_secret=access_secret&oauth_token=access_key']),
-                True))
-
-    def expect_token_store_denied(self):
-        """Expects the token to be denied for storing in keyring."""
-        self.expect_token_store().throw(gnomekeyring.DeniedError)
-
-    def mock_has_token(self):
-        """Mocks a cached token in the keyring."""
-        self.expect_token_query().result([self.item])
-
-    def mock_no_token(self, exception):
-        """Mocks no token in the keyring."""
-        self.expect_token_query().throw(exception)
-
-    def replay(self, callback_parent=None, callback_denied=None,
-                     do_login=True):
-        """Starts the replay phase and sets up a client object to be tested,
-        wired up to the mock keyring.
-
-        """
-        self.mocker.replay()
-        self.client = AuthorisationClient(
-            'realm', 'request_token_url', 'user_authorisation_url',
-            'access_token_url', 'consumer_key', 'consumer_secret',
-            callback_parent, callback_denied, do_login, keyring=self.keyring)
-
-    def test_get_access_token(self):
-        """The get_access_token method returns the access token"""
-        self.mock_has_token()
-        self.replay()
-        token = self.client.get_access_token()
-        self.assertTrue(isinstance(token, oauth.OAuthToken))
-        self.assertEqual(token.key, 'access_key')
-        self.assertEqual(token.secret, 'access_secret')
-
-    def test_get_access_token_no_match(self):
-        """The get_access_token method fails if there are no matching items"""
-        self.mock_no_token(gnomekeyring.NoMatchError)
-        self.replay()
-        self.assertRaises(NoAccessToken, self.client.get_access_token)
-
-    def test_get_access_token_denied(self):
-        """The get_access_token method fails if access is denied"""
-        self.mock_no_token(gnomekeyring.DeniedError)
-        self.replay()
-        self.assertRaises(NoAccessToken, self.client.get_access_token)
-
-    def test_have_access_token(self):
-        """The `have_access_token` method returns True if a the
-        keyring contains a token."""
-        self.mock_has_token()
-        self.replay()
-        self.assertEqual(self.client.have_access_token(), True)
-
-    def test_have_access_token_fail(self):
-        """The `have_access_token` method returns False if the keyring
-        does not contain a token."""
-        self.mock_no_token(gnomekeyring.NoMatchError)
-        self.replay()
-        self.assertEqual(self.client.have_access_token(), False)
-
-    def test_store_token(self):
-        """The store_token method correctly stores an item in the keyring,
-           and correctly sets an ACL on it."""
-        self.expect_token_store().result(self.item_id)
-        saka = self.mocker.replace(
-          "ubuntuone.oauthdesktop.key_acls.set_all_key_acls")
-        saka(item_id=self.item_id)
-        self.mocker.result(None)
-
-        sleep = self.mocker.replace("time.sleep")
-        sleep(4)
-        self.mocker.result(None)
-
-        self.replay()
-        self.client.store_token(oauth.OAuthToken('access_key', 'access_secret'))
-
-    def test_store_token_denied(self):
-        """The store_token method correctly stores an item in the keyring,
-           and correctly sets an ACL on it."""
-        self.expect_token_store_denied()
-
-        self.replay()
-        self.client.store_token(oauth.OAuthToken('access_key', 'access_secret'))
-
-    def test_clear_existing_token(self):
-        """Makes sure that clear token clears an existing token."""
-        self.mock_has_token()
-        self.expect(self.keyring.item_delete_sync(None, self.item_id))
-        self.replay()
-        self.client.clear_token()
-
-    def test_clear_no_existing_token(self):
-        """Makes sure that clear with no existing token still works."""
-        self.mock_no_token(gnomekeyring.NoMatchError)
-        self.replay()
-        self.client.clear_token()
-
-    def test_ensure_access_token(self):
-        """If the user already has a token, no new token is requested."""
-        self.mock_has_token()
-        callback_function = self.mocker.mock()
-        callback_function(ANY)
-        self.replay(callback_parent=callback_function)
-        self.client.ensure_access_token()
-
-    def test_ensure_access_token_no_token(self):
-        """If the user has no token, a new one is requested and stored, via
-           an OAuth callback to the internal webserver."""
-
-        self.mock_no_token(gnomekeyring.NoMatchError)
-
-        request_token = self.mocker.mock()
-        self.expect(request_token.key).result('access_key').count(0, None)
-        ex = self.expect(request_token.secret)
-        ex.result('access_secret').count(0, None)
-        make_token_request = self.mocker.mock()
-        self.expect(make_token_request(ANY)).result(request_token)
-
-        open_in_browser = self.mocker.mock()
-        open_in_browser(ANY)
-
-        ri = self.mocker.replace("random.randint")
-        ri(1000000, 10000000)
-        self.mocker.result(12345678)
-        get_temporary_httpd = self.mocker.mock()
-        get_temporary_httpd(12345678, ANY, True)
-        self.mocker.result("http://callbackurl")
-
-        self.replay(callback_parent=lambda a: None)
-
-        self.client.make_token_request = make_token_request
-        self.client.open_in_browser = open_in_browser
-        self.client.get_temporary_httpd = get_temporary_httpd
-        # skip the "are we online, via networkmanager" bit
-        self.client.acquire_access_token_if_online = \
-            self.client.acquire_access_token
-        self.client.ensure_access_token()
-    test_ensure_access_token_no_token.skip = \
-        "Fails with exceptions.AssertionError: [Mocker] Unmet expectations, "\
-        "see bug #488933"
-
-
-class AcquireAccessTokenTests(testresources.ResourcedTestCase):
-    """OAuth token acquisition tests."""
-
-    def setUp(self):
-        super(AcquireAccessTokenTests, self).setUp()
-
-    def tearDown(self):
-        super(AcquireAccessTokenTests, self).tearDown()
-
-    def test_acquire_access_token(self):
-        """Test that acquire_access_token() can acquire the access token."""
-
-        def make_token_request(oauth_request):
-            """Make an OAuth token request via the test browser."""
-            return oauth.OAuthToken.from_string("oauth_token=access_token&" +
-                                                "oauth_token_secret=" +
-                                                "access_secret")
-
-        def open_in_browser(url):
-            """Just return as we aren't subscribed to the page."""
-            return
-
-        def got_token(token):
-            """Called with the token once auth is completed"""
-            self.assertTrue(isinstance(token, oauth.OAuthToken))
-
-        def get_temporary_httpd(nonce, retrieve_function, store):
-            """Mock the temporary httpd and return a callback URL"""
-            # returns callback URL; this is an invalid URL, of course,
-            # (port is too high) but we check later that the mechanize
-            # browser tries to navigate there
-            return "http://localhost:99999/?nonce=99999"
-
-        def store_token(token):
-            """Don't use the keyring; do nothing"""
-            pass
-
-        client = AuthorisationClient(
-            'http://ubuntuone/',
-            'http://ubuntuone/oauth/request/',
-            'http://ubuntuone/oauth/authorize/',
-            'http://ubuntuone/oauth/access/',
-            'consumer_key', 'consumer_secret',
-            callback_parent=got_token)
-        client.make_token_request = make_token_request
-        client.open_in_browser = open_in_browser
-        client.get_temporary_httpd = get_temporary_httpd
-        client.store_token = store_token
-
-        client.acquire_access_token('token description')

=== removed file 'tests/oauthdesktop/test_config.py'
--- tests/oauthdesktop/test_config.py	2009-07-02 20:22:51 +0000
+++ tests/oauthdesktop/test_config.py	1970-01-01 00:00:00 +0000
@@ -1,90 +0,0 @@
-# test_config - tests for ubuntuone.oauthdesktop.config
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Tests for the OAuth client code for StorageFS."""
-
-import os, StringIO
-from contrib.mocker import MockerTestCase
-from ubuntuone.oauthdesktop import config
-from ubuntuone.oauthdesktop.config import get_config
-
-class ConfigFileTests(MockerTestCase):
-    """Test the config file finder"""
-
-    def test_get_file_from_tmp(self):
-        """Does the tmp file get chosen?"""
-        
-        # mock that tmp config file exists
-        tmp_config_file = os.path.realpath(os.path.join(
-          os.path.split(config.__file__)[0], "../../data/oauth_urls"
-        ))
-        osp = self.mocker.replace("os.path")
-        osp.isfile(tmp_config_file)
-        self.mocker.result(True)
-        self.mocker.replay()
-        
-        conf = get_config()
-        self.assertEqual(conf.FILENAME, tmp_config_file)
-
-    def test_get_file_from_home(self):
-        """Does our home config file get chosen?"""
-        
-        # mock that home config file exists
-        home_config_file = os.path.expanduser("~/.config/ubuntuone/oauth_urls")
-        osp = self.mocker.replace("os.path")
-        osp.exists(home_config_file)
-        self.mocker.result(True)
-        self.mocker.replay()
-        
-        conf = get_config(use_tmpconfig=False) # pretend not in source tree
-        self.assertEqual(conf.FILENAME, home_config_file)
-
-    def test_get_file_from_etc(self):
-        """Does our /etc config file get chosen?"""
-        
-        # mock that etc config file exists
-        etc_config_file = os.path.expanduser("/etc/xdg/ubuntuone/oauth_urls")
-        osp = self.mocker.replace("os.path")
-        osp.exists(etc_config_file)
-        self.mocker.result(True)
-        self.mocker.replay()
-        
-        conf = get_config(use_tmpconfig=False) # pretend not in source tree
-        self.assertEqual(conf.FILENAME, etc_config_file)
-
-    def test_tmp_file_parses(self):
-        """Does the tmp file get chosen and parse correctly?"""
-        
-        # mock that tmp config file exists
-        tmp_config_file = os.path.realpath(os.path.join(
-          os.path.split(config.__file__)[0], "../../data/oauth_urls"
-        ))
-        osp = self.mocker.replace("os.path")
-        osp.isfile(tmp_config_file)
-        self.mocker.result(True)
-        
-        sio = StringIO.StringIO("[default]\n")
-        mock_open = self.mocker.replace(open)
-        mock_open(tmp_config_file)
-        self.mocker.result(sio)
-        
-        self.mocker.replay()
-        
-        conf = get_config()
-        self.assertTrue(conf.has_section("default"))
-
-

=== removed file 'tests/oauthdesktop/test_key_acls.py'
--- tests/oauthdesktop/test_key_acls.py	2009-06-26 17:01:42 +0000
+++ tests/oauthdesktop/test_key_acls.py	1970-01-01 00:00:00 +0000
@@ -1,181 +0,0 @@
-# test_key_acls - tests for ubuntuone.oauthdesktop.key_acls
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Tests for the ACL setting code for ubuntuone-oauth-login."""
-
-import os, StringIO
-import xdg.BaseDirectory
-from contrib.mocker import MockerTestCase, IN, ANY
-from ubuntuone.oauthdesktop.key_acls import (
-  get_privileged_config_folder, get_acl_preregistrations, set_all_key_acls,
-  set_single_acl)
-
-class Loader(MockerTestCase):
-    """Confirm only the /etc/xdg config files are loaded"""
-
-    def test_etc_found(self):
-        """Is the /etc/xdg folder found if present?"""
-        
-        ETC_FOLDER = "/etc/xdg/ubuntuone"
-        osp = self.mocker.replace("os.path")
-        osp.exists(ETC_FOLDER)
-        self.mocker.result(True)
-        self.mocker.replay()
-        
-        self.assertEqual(ETC_FOLDER,
-          get_privileged_config_folder(use_source_tree_folder=False))
-
-    def test_etc_found_despite_home(self):
-        """Is the /etc/xdg folder found even if the $HOME folder is present?"""
-        
-        ETC_FOLDER = "/etc/xdg/ubuntuone"
-        HOME_FOLDER = os.path.join(xdg.BaseDirectory.xdg_config_home, 
-          "ubuntuone")
-        osp = self.mocker.replace("os.path")
-        osp.exists(ETC_FOLDER)
-        self.mocker.result(True)
-        osp.exists(HOME_FOLDER)
-        self.mocker.result(True)
-        self.mocker.replay()
-        
-        self.assertEqual(ETC_FOLDER,
-          get_privileged_config_folder(use_source_tree_folder=False))
-
-    def test_etc_files_found(self):
-        """Are files in /etc found?"""
-        ETC_FOLDER = "/etc/xdg/ubuntuone"
-        ETC_FILES_FOLDER = "/etc/xdg/ubuntuone/oauth_registration.d"
-        FILE_LIST = ["a", "b"]
-        osp = self.mocker.replace("os.path")
-        osp.exists(ETC_FOLDER)
-        self.mocker.result(True)
-        osp.isdir(ETC_FILES_FOLDER)
-        self.mocker.result(True)
-        listdir = self.mocker.replace("os.listdir")
-        listdir(ETC_FILES_FOLDER)
-        self.mocker.result(FILE_LIST)
-        self.mocker.replay()
-        
-        our_list = sorted(
-          [os.path.join(ETC_FILES_FOLDER, x) for x in FILE_LIST])
-        their_list = sorted(
-          get_acl_preregistrations(use_source_tree_folder=False))
-        self.assertEqual(our_list, their_list)
-        
-    def test_set_single_acl(self):
-        """Does set_single_acl work?"""
-
-        giifr = self.mocker.replace(
-          "ubuntuone.oauthdesktop.key_acls.get_item_ids_for_realm")
-        igas = self.mocker.replace("gnomekeyring.item_get_acl_sync")
-        isas = self.mocker.replace("gnomekeyring.item_set_acl_sync")
-        acon = self.mocker.replace("gnomekeyring.AccessControl")
-        self.expect(giifr("realm", "consumer_key")).result([999])
-        self.expect(igas(None, 999)).result([])
-        ac1 = self.mocker.mock()
-        self.expect(acon(ANY, ANY)).result(ac1)
-        ac1.set_display_name("application_name")
-        ac1.set_path_name("/tmp/exe_path")
-        self.expect(isas(None, 999, [ac1])).result(None)
-        self.expect(giifr("realm2", "consumer_key2")).result([9999])
-        self.expect(igas(None, 9999)).result([])
-        ac2 = self.mocker.mock()
-        self.expect(acon(ANY, ANY)).result(ac2)
-        ac2.set_display_name("application_name2")
-        ac2.set_path_name("/tmp/exe_path2")
-        self.expect(isas(None, 9999, [ac2])).result(None)
-        self.mocker.replay()
-
-        set_single_acl([
-          ("realm", "consumer_key", "/tmp/exe_path", "application_name"),
-          ("realm2", "consumer_key2", "/tmp/exe_path2", "application_name2"),
-        ])
-        
-        
-    def test_etc_files_parsed(self):
-        """Are files in /etc parsed correctly?"""
-        
-        ETC_FOLDER = "/etc/xdg/ubuntuone"
-        ETC_FILES_FOLDER = "/etc/xdg/ubuntuone/oauth_registration.d"
-        FILE_LIST = ["a", "b"]
-        osp = self.mocker.replace("os.path")
-        osp.exists(ETC_FOLDER)
-        self.mocker.result(True)
-        osp.isdir(ETC_FILES_FOLDER)
-        self.mocker.result(True)
-        listdir = self.mocker.replace("os.listdir")
-        listdir(ETC_FILES_FOLDER)
-        self.mocker.result(FILE_LIST)
-
-        sio1 = StringIO.StringIO("""[app1]
-realm = https://realm.example.com/
-consumer_key = example_key
-exe_path = /nowhere/executable/path
-application_name = example_app_name
-
-[app2]
-realm = https://other.example.com/
-consumer_key = example_key
-exe_path = /nowhere/executable/path
-application_name = example_app_name
-
-""")
-        sio2 = StringIO.StringIO("""[app3]
-exe_path = /nowhere/path/2
-application_name = example_app_name2
-consumer_key = example_key2
-realm = https://realm2.example.com/
-""")
-        mock_open = self.mocker.replace(open)
-        mock_open(os.path.join(ETC_FILES_FOLDER, "a"))
-        self.mocker.result(sio1)
-        mock_open(os.path.join(ETC_FILES_FOLDER, "b"))
-        self.mocker.result(sio2)
-        
-        ssa = self.mocker.replace(
-          "ubuntuone.oauthdesktop.key_acls.set_single_acl")
-        # list may come up in any order
-        ssa(IN([
-              [
-                ("https://realm.example.com/", "example_key", 
-                "/nowhere/executable/path", "example_app_name"),
-                ("https://other.example.com/", "example_key", 
-                "/nowhere/executable/path", "example_app_name"),
-              ],
-              [
-                ("https://other.example.com/", "example_key", 
-                "/nowhere/executable/path", "example_app_name"),
-                ("https://realm.example.com/", "example_key", 
-                "/nowhere/executable/path", "example_app_name"),
-              ],
-            ]), specific_item_id=None
-        )
-        self.mocker.result(None)
-        ssa([
-            ("https://realm2.example.com/", "example_key2", 
-            "/nowhere/path/2", "example_app_name2")
-            ], specific_item_id=None)
-        self.mocker.result(None)
-        self.mocker.replay()
-        
-        set_all_key_acls(use_source_tree_folder=False)
-    
-    
-    
-    
-    
-    

=== removed file 'tests/oauthdesktop/test_main.py'
--- tests/oauthdesktop/test_main.py	2009-06-26 17:01:42 +0000
+++ tests/oauthdesktop/test_main.py	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-# test_main - tests for ubuntuone.oauthdesktop.main
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Tests for the OAuth client code for StorageFS."""
-
-import os, StringIO
-from contrib.mocker import MockerTestCase
-from ubuntuone.oauthdesktop import config
-from ubuntuone.oauthdesktop.main import LoginProcessor, BadRealmError
-
-class Realm(MockerTestCase):
-    """Test the realm handling finder"""
-
-    def test_invalid_realm(self):
-        """Are invalid realms rejected?"""
-                
-        login = LoginProcessor(None, use_libnotify=False)
-        self.assertRaises(BadRealmError, login.login, "bad realm", "key")
-
-    def test_realms(self):
-        """Are realm URLs correctly retrieved from the config?"""
-        
-        # mock that tmp config file exists
-        tmp_config_file = os.path.realpath(os.path.join(
-          os.path.split(config.__file__)[0], "../../data/oauth_urls"
-        ))
-        osp = self.mocker.replace("os.path")
-        osp.isfile(tmp_config_file)
-        self.mocker.result(True)
-        
-        sio = StringIO.StringIO("""[default]
-request_token_url = /rtu-default
-user_authorisation_url = /uau-default
-access_token_url = /atu-default
-consumer_secret = foo-default
-
-[http://localhost]
-request_token_url = /rtu-localhost
-user_authorisation_url = /uau-localhost
-access_token_url = /atu-localhost
-consumer_secret = foo-localhost
-
-[http://ubuntuone.com]
-request_token_url = /rtu-ubuntuone
-user_authorisation_url = /uau-ubuntuone
-access_token_url = /atu-ubuntuone
-consumer_secret = foo-ubuntuone
-
-""")
-        mock_open = self.mocker.replace(open)
-        mock_open(tmp_config_file)
-        self.mocker.result(sio)
-        
-        self.mocker.replay()
-        
-        login = LoginProcessor(None, use_libnotify=False)
-        
-        # are localhost:XXXX URLs correctly fetched?
-        (rtu, uau, atu, cs) = login.get_config_urls("http://localhost:9876")
-        self.assertEqual(rtu, "http://localhost:9876/rtu-localhost")
-        self.assertEqual(uau, "http://localhost:9876/uau-localhost")
-        self.assertEqual(atu, "http://localhost:9876/atu-localhost")
-        self.assertEqual(cs, "foo-localhost")
-
-        # is a URL specifically in the config correctly fetched?
-        (rtu, uau, atu, cs) = login.get_config_urls("http://ubuntuone.com")
-        self.assertEqual(rtu, "http://ubuntuone.com/rtu-ubuntuone")
-        self.assertEqual(uau, "http://ubuntuone.com/uau-ubuntuone")
-        self.assertEqual(atu, "http://ubuntuone.com/atu-ubuntuone")
-        self.assertEqual(cs, "foo-ubuntuone")
-
-        # is a URL not in the config correctly fetched as default?
-        (rtu, uau, atu, cs) = login.get_config_urls("http://other.example.net")
-        self.assertEqual(rtu, "http://other.example.net/rtu-default")
-        self.assertEqual(uau, "http://other.example.net/uau-default")
-        self.assertEqual(atu, "http://other.example.net/atu-default")
-        self.assertEqual(cs, "foo-default")
-
-

=== removed file 'tests/test_login.py'
--- tests/test_login.py	2010-01-15 16:32:12 +0000
+++ tests/test_login.py	1970-01-01 00:00:00 +0000
@@ -1,187 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Author: Rodney Dawes <[e-mail]>
-#
-# Copyright 2010 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-""" Tests for the ubuntuone-login script """
-
-import dbus.service
-import new
-import os
-
-from contrib.testing.testcase import DBusTwistedTestCase, FakeLogin
-from twisted.internet import defer
-from twisted.python.failure import Failure
-from ubuntuone.syncdaemon import dbus_interface
-
-class InvalidSignalError(Exception):
-    """Exception for when we get the wrong signal called."""
-    pass
-
-class LoginTests(DBusTwistedTestCase):
-    """Basic tests for the ubuntuone-login script """
-
-    _path = os.path.join(os.getcwd(), "bin", "ubuntuone-login")
-    u1login = new.module('u1login')
-    execfile(_path, u1login.__dict__)
-
-    def setUp(self):
-        DBusTwistedTestCase.setUp(self)
-        self.oauth = FakeLogin(self.bus)
-        self._old_path = dbus_interface.DBUS_PATH_AUTH
-        dbus_interface.DBUS_PATH_AUTH = '/oauthdesktop'
-
-    def tearDown(self):
-        # collect all signal receivers registered during the test
-        signal_receivers = set()
-        with self.bus._signals_lock:
-            for group in self.bus._signal_recipients_by_object_path.values():
-                for matches in group.values():
-                    for match in matches.values():
-                        signal_receivers.update(match)
-        d = self.cleanup_signal_receivers(signal_receivers)
-        def shutdown(r):
-            self.oauth.shutdown()
-            dbus_interface.DBUS_PATH_AUTH = self._old_path
-        d.addBoth(shutdown)
-        d.addBoth(lambda _: DBusTwistedTestCase.tearDown(self))
-        return d
-
-    def test_new_credentials(self):
-        """ Test logging in """
-        def new_creds(realm=None, consumer_key=None, sender=None):
-            """ Override the callback """
-            d.callback(True)
-
-        def auth_denied():
-            """ Override the callback """
-            d.errback(Failure(InvalidSignalError()))
-
-        def got_oauth_error(message=None):
-            """ Override the callback """
-            d.errback(Failure(InvalidSignalError()))
-
-        def set_up_desktopcouch_pairing(consumer_key):
-            """ Override the method """
-            return
-
-        def main():
-            """ Override LoginMain.main """
-            return
-
-        login = self.u1login.LoginMain()
-        login.main = main
-        login.new_credentials = new_creds
-        login.auth_denied = auth_denied
-        login.got_oauth_error = got_oauth_error
-        login.set_up_desktopcouch_pairing = set_up_desktopcouch_pairing
-
-        login._connect_dbus_signals()
-
-        client = self.bus.get_object(self.u1login.DBUS_IFACE_AUTH_NAME,
-                                     '/oauthdesktop',
-                                     follow_name_owner_changes=True)
-        d = defer.Deferred()
-
-        def login_handler():
-            """ login handler """
-            return
-
-        iface = dbus.Interface(client, self.u1login.DBUS_IFACE_AUTH_NAME)
-        iface.login('http://localhost', self.u1login.OAUTH_CONSUMER,
-                    reply_handler=login_handler,
-                    error_handler=self.error_handler)
-        return d
-
-    def test_auth_denied(self):
-        """ Test that denying authorization works correctly. """
-
-        def new_creds(realm=None, consumer_key=None, sender=None):
-            """ Override the callback """
-            d.errback(Failure(InvalidSignalError()))
-
-        def auth_denied():
-            """ Override the callback """
-            d.callback(True)
-
-        def got_oauth_error(message=None):
-            """ override the callback """
-            d.errback(Failure(InvalidSignalError()))
-
-        login = self.u1login.LoginMain()
-        login.main = self.main
-        login.new_credentials = new_creds
-        login.auth_denied = auth_denied
-        login.got_oauth_error = got_oauth_error
-
-        login._connect_dbus_signals()
-
-        self.oauth.processor.next_login_with(self.oauth.processor.got_denial)
-
-        client = self.bus.get_object(self.u1login.DBUS_IFACE_AUTH_NAME,
-                                     '/oauthdesktop',
-                                     follow_name_owner_changes=True)
-        d = defer.Deferred()
-
-        def login_handler():
-            """ login handler """
-            return
-
-        iface = dbus.Interface(client, self.u1login.DBUS_IFACE_AUTH_NAME)
-        iface.login('http://localhost', self.u1login.OAUTH_CONSUMER,
-                    reply_handler=login_handler,
-                    error_handler=self.error_handler)
-        return d
-
-    def test_oauth_error(self):
-        """ Test that getting an error works correctly. """
-
-        def new_creds(realm=None, consumer_key=None, sender=None):
-            """ Override the callback """
-            d.errback(Failure(InvalidSignalError()))
-
-        def auth_denied():
-            """ Override the callback """
-            d.errback(Failure(InvalidSignalError()))
-
-        def got_oauth_error(message=None):
-            """ override the callback """
-            d.callback(True)
-
-        login = self.u1login.LoginMain()
-        login.main = self.main
-        login.new_credentials = new_creds
-        login.auth_denied = auth_denied
-        login.got_oauth_error = got_oauth_error
-
-        login._connect_dbus_signals()
-
-        self.oauth.processor.next_login_with(self.oauth.processor.got_error,
-                                             ('error!',))
-
-        client = self.bus.get_object(self.u1login.DBUS_IFACE_AUTH_NAME,
-                                     '/oauthdesktop',
-                                     follow_name_owner_changes=True)
-        d = defer.Deferred()
-
-        def login_handler():
-            """ login handler """
-            return
-
-        iface = dbus.Interface(client, self.u1login.DBUS_IFACE_AUTH_NAME)
-        iface.login('http://localhost', self.u1login.OAUTH_CONSUMER,
-                    reply_handler=login_handler,
-                    error_handler=self.error_handler)
-        return d

=== modified file 'tests/test_preferences.py'
--- tests/test_preferences.py	2010-06-15 09:16:48 +0000
+++ tests/test_preferences.py	2010-06-16 20:35:34 +0000
@@ -498,3 +498,5 @@
                                       error_handler=got_dbus_error)
 
         return d
+    test_login_check.skip = \
+        "This shouldn't depend on the real DBus service (see bug #591340)."

=== removed directory 'ubuntuone/oauthdesktop'
=== removed file 'ubuntuone/oauthdesktop/__init__.py'
--- ubuntuone/oauthdesktop/__init__.py	2009-06-26 17:01:42 +0000
+++ ubuntuone/oauthdesktop/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-# ubuntuone.oauthdesktop - OAuth client support for desktop apps
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""OAuth client authorisation code."""

=== removed file 'ubuntuone/oauthdesktop/auth.py'
--- ubuntuone/oauthdesktop/auth.py	2010-02-10 17:35:26 +0000
+++ ubuntuone/oauthdesktop/auth.py	1970-01-01 00:00:00 +0000
@@ -1,480 +0,0 @@
-# ubuntuone.oauthdesktop.auth - Client authorization module
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""OAuth client authorisation code.
-
-This code handles acquisition of an OAuth access token for a service,
-managed through the GNOME keyring for future use, and asynchronously.
-"""
-
-__metaclass__ = type
-
-import subprocess
-import random
-import dbus
-import os
-import socket, httplib, urllib
-
-import gnomekeyring
-from oauth import oauth
-try:
-    from ubuntuone.clientdefs import VERSION
-    ubuntuone_client_version = VERSION
-except ImportError:
-    ubuntuone_client_version = "Unknown"
-from ubuntuone.oauthdesktop.key_acls import set_all_key_acls
-
-from threading import Thread
-from twisted.internet import reactor
-from twisted.web import server, resource
-
-from ubuntuone.oauthdesktop.logger import setupLogging
-logger = setupLogging("UbuntuOne.OAuthDesktop.auth")
-
-
-class NoAccessToken(Exception):
-    """No access token available."""
-
-# NetworkManager State constants
-NM_STATE_UNKNOWN = 0
-NM_STATE_ASLEEP = 1
-NM_STATE_CONNECTING = 2
-NM_STATE_CONNECTED = 3
-NM_STATE_DISCONNECTED = 4
-
-# Monkeypatch httplib so that urllib will fail on invalid certificate
-# Only patch if we can import ssl to work around fail in 2.5
-try:
-    import ssl
-except ImportError:
-    pass
-else:
-    def _connect_wrapper(self):
-        """Override HTTPSConnection.connect to require certificate checks"""
-        sock = socket.create_connection((self.host, self.port), self.timeout)
-        try:
-            if self._tunnel_host:
-                self.sock = sock
-                self._tunnel()
-        except AttributeError:
-            pass
-        self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file,
-                cert_reqs=ssl.CERT_REQUIRED, 
-                ca_certs="/etc/ssl/certs/ca-certificates.crt")
-    httplib.HTTPSConnection.connect = _connect_wrapper
-
-
-class FancyURLOpenerWithRedirectedPOST(urllib.FancyURLopener):
-    """FancyURLopener does not redirect postdata when redirecting POSTs"""
-    version = "Ubuntu One/Login (%s)" % ubuntuone_client_version
-    def redirect_internal(self, url, fp, errcode, errmsg, headers, data):
-        """Actually perform a redirect"""
-        # All the same as the original, except passing data, below
-        if 'location' in headers:
-            newurl = headers['location']
-        elif 'uri' in headers:
-            newurl = headers['uri']
-        else:
-            return
-        fp.read()
-        fp.close()
-        # In case the server sent a relative URL, join with original:
-        newurl = urllib.basejoin(self.type + ":" + url, newurl)
-        
-        # pass data if present when we redirect
-        if data:
-            return self.open(newurl, data)
-        else:
-            return self.open(newurl)
-
-class AuthorisationClient(object):
-    """OAuth authorisation client."""
-    def __init__(self, realm, request_token_url, user_authorisation_url,
-                 access_token_url, consumer_key, consumer_secret,
-                 callback_parent, callback_denied=None,
-                 callback_notoken=None, callback_error=None, do_login=True,
-                 keyring=gnomekeyring):
-        """Create an `AuthorisationClient` instance.
-
-        @param realm: the OAuth realm.
-        @param request_token_url: the OAuth request token URL.
-        @param user_authorisation_url: the OAuth user authorisation URL.
-        @param access_token_url: the OAuth access token URL.
-        @param consumer_key: the OAuth consumer key.
-        @param consumer_secret: the OAuth consumer secret.
-        @param callback_parent: a function in the includer to call with a token
-
-        The preceding parameters are defined in sections 3 and 4.1 of the
-        OAuth Core 1.0 specification.  The following parameters are not:
-
-        @param callback_denied: a function to call if no token is available
-        @param do_login: whether to create a token if one is not cached
-        @param keychain: the keyring object to use (defaults to gnomekeyring)
-
-        """
-        self.realm = realm
-        self.request_token_url = request_token_url
-        self.user_authorisation_url = user_authorisation_url
-        self.access_token_url = access_token_url
-        self.consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
-        self.callback_parent = callback_parent
-        self.callback_denied = callback_denied
-        self.callback_notoken = callback_notoken
-        self.callback_error = callback_error
-        self.do_login = do_login
-        self.request_token = None
-        self.saved_acquire_details = (None, None, None)
-        self.keyring = keyring
-        logger.debug("auth.AuthorisationClient created with parameters "+ \
-           "realm='%s', request_token_url='%s', user_authorisation_url='%s',"+\
-           "access_token_url='%s', consumer_key='%s', callback_parent='%s'",
-           realm, request_token_url, user_authorisation_url, access_token_url,
-           consumer_key, callback_parent)
-
-    def _get_keyring_items(self):
-        """Raw interface to obtain keyring items."""
-        return self.keyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET,
-                                            {'ubuntuone-realm': self.realm,
-                                             'oauth-consumer-key':
-                                             self.consumer.key})
-
-    def _forward_error_callback(self, error):
-        """Forward an error through callback_error()"""
-        if self.callback_error:
-            self.callback_error(str(error))
-        else:
-            raise error
-
-    def get_access_token(self):
-        """Get the access token from the keyring.
-
-        If no token is available in the keyring, `NoAccessToken` is raised.
-        """
-        logger.debug("Trying to fetch the token from the keyring")
-        try:
-            items = self._get_keyring_items()
-        except (gnomekeyring.NoMatchError,
-                gnomekeyring.DeniedError):
-            logger.debug("Access token was not in the keyring")
-            raise NoAccessToken("No access token found.")
-        logger.debug("Access token successfully found in the keyring")
-        return oauth.OAuthToken.from_string(items[0].secret)
-
-    def clear_token(self):
-        """Clear any stored tokens from the keyring."""
-        logger.debug("Searching keyring for existing tokens to delete.")
-        try:
-            items = self._get_keyring_items()
-        except (gnomekeyring.NoMatchError,
-                gnomekeyring.DeniedError):
-            logger.debug("No preexisting tokens found")
-        else:
-            logger.debug("Deleting %s tokens from the keyring" % len(items))
-            for item in items:
-                try:
-                    self.keyring.item_delete_sync(None, item.item_id)
-                except gnomekeyring.DeniedError:
-                    logger.debug("Permission denied deleting token")
-
-    def store_token(self, access_token):
-        """Store the given access token in the keyring.
-
-        The keyring item is identified by the OAuth realm and consumer
-        key to support multiple instances.
-        """
-        logger.debug("Trying to store the token in the keyring")
-        try:
-            item_id = self.keyring.item_create_sync(
-                None,
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                'UbuntuOne token for %s' % self.realm,
-                {'ubuntuone-realm': self.realm,
-                 'oauth-consumer-key': self.consumer.key},
-                access_token.to_string(),
-                True)
-        except gnomekeyring.DeniedError:
-            logger.debug("Permission denied storing token")
-        else:
-            # set ACLs on the key for all apps listed in xdg BaseDir, but only
-            # the root level one, not the user-level one
-            logger.debug("Setting ACLs on the token in the keyring")
-            set_all_key_acls(item_id=item_id)
-
-            # keyring seems to take a while to actually apply the change
-            # for when other people retrieve it, so sleep a bit.
-            # this ought to get fixed.
-            import time
-            time.sleep(4)
-
-    def have_access_token(self):
-        """Returns true if an access token is available from the keyring."""
-        try:
-            self.get_access_token()
-        except NoAccessToken:
-            return False
-        else:
-            return True
-
-    def make_token_request(self, oauth_request):
-        """Perform the given `OAuthRequest` and return the associated token."""
-        
-        logger.debug("Making a token request")
-        # Note that we monkeypatched httplib above to handle invalid certs
-        # Ways this urlopen can fail:
-        # bad certificate
-        #    raises IOError, e.args[1] == SSLError, e.args[1].errno == 1
-        # No such server 
-        #    raises IOError, e.args[1] == SSLError, e.args[1].errno == -2
-        try:
-            opener = FancyURLOpenerWithRedirectedPOST()
-            fp = opener.open(oauth_request.http_url, oauth_request.to_postdata())
-            data = fp.read()
-        except IOError, e:
-            self._forward_error_callback(e)
-            return
-        
-        # we deliberately trap anything that might go wrong when parsing the
-        # token, because we do not want this to explicitly fail
-        # pylint: disable-msg=W0702
-        try:
-            out_token = oauth.OAuthToken.from_string(data)
-            logger.debug("Token successfully requested")
-            return out_token
-        except:
-            error = Exception(data)
-            logger.error("Token was not successfully retrieved: data was '%s'",
-               str(error))
-            self._forward_error_callback(error)
-
-    def open_in_browser(self, url):
-        """Open the given URL in the user's web browser."""
-        logger.debug("Opening '%s' in the browser", url)
-        p = subprocess.Popen(["xdg-open", url], bufsize=4096,
-                             stderr=subprocess.PIPE)
-        p.wait()
-        if p.returncode != 0:
-            errors = "".join(p.stderr.readlines())
-            if errors != "":
-                self._forward_error_callback(IOError(errors))
-
-    def acquire_access_token_if_online(self, description=None, store=False):
-        """Check to see if we are online before trying to acquire"""
-        # Get NetworkManager state
-        logger.debug("Checking whether we are online")
-        try:
-            nm = dbus.SystemBus().get_object('org.freedesktop.NetworkManager',
-                                             '/org/freedesktop/NetworkManager',
-                                             follow_name_owner_changes=True)
-        except dbus.exceptions.DBusException:
-            logger.warn("Unable to connect to NetworkManager. Trying anyway.")
-            self.acquire_access_token(description, store)
-        else:
-            iface = dbus.Interface(nm, 'org.freedesktop.NetworkManager')
-
-            def got_state(state):
-                """Handler for when state() call succeeds."""
-                if state == NM_STATE_CONNECTED:
-                    logger.debug("We are online")
-                    self.acquire_access_token(description, store)
-                elif state == NM_STATE_CONNECTING:
-                    logger.debug("We are currently going online")
-                    # attach to NM's StateChanged signal
-                    signal_match = nm.connect_to_signal(
-                        signal_name="StateChanged",
-                        handler_function=self.connection_established,
-                        dbus_interface="org.freedesktop.NetworkManager")
-                    # stash the details so the handler_function can get at them
-                    self.saved_acquire_details = (signal_match, description,
-                                                  store)
-                else:
-                    # NM is not connected: fail
-                    logger.debug("We are not online")
-
-            def got_error(error):
-                """Handler for D-Bus errors when calling state()."""
-                if error.get_dbus_name() == \
-                        'org.freedesktop.DBus.Error.ServiceUnknown':
-                    logger.debug("NetworkManager not available.")
-                    self.acquire_access_token(description, store)
-                else:
-                    logger.error("Error contacting NetworkManager: %s" % \
-                                     str(error))
-
-
-            iface.state(reply_handler=got_state, error_handler=got_error)
-
-    def connection_established(self, state):
-        """NetworkManager's state has changed, and we're watching for
-           a connection"""
-        logger.debug("Online status has changed to %s" % state)
-        if int(state) == NM_STATE_CONNECTED:
-            signal_match, description, store = self.saved_acquire_details
-            # disconnect the signal so we don't get called again
-            signal_match.remove()
-            # call the real acquire_access_token now it has a connection
-            logger.debug("Correctly connected: now starting auth process")
-            self.acquire_access_token(description, store)
-        else:
-            # connection changed but not to "connected", so keep waiting
-            logger.debug("Not yet connected: continuing to wait")
-
-    def acquire_access_token(self, description=None, store=False):
-        """Create an OAuth access token authorised against the user."""
-        signature_method = oauth.OAuthSignatureMethod_PLAINTEXT()
-
-        # Create a request token ...
-        logger.debug("Creating a request token to begin access request")
-        parameters = {}
-        if description:
-            parameters['description'] = description
-        # Add a nonce to the query so we know the callback (to our temp
-        # webserver) came from us
-        nonce = random.randint(1000000, 10000000)
-
-        # start temporary webserver to receive browser response
-        callback_url = self.get_temporary_httpd(nonce,
-           self.retrieve_access_token, store)
-
-        oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-            callback=callback_url,
-            http_url=self.request_token_url,
-            oauth_consumer=self.consumer,
-            parameters=parameters)
-        oauth_request.sign_request(signature_method, self.consumer, None)
-        logger.debug("Making token request")
-        self.request_token = self.make_token_request(oauth_request)
-
-        # Request authorisation from the user
-        oauth_request = oauth.OAuthRequest.from_token_and_callback(
-            http_url=self.user_authorisation_url,
-            token=self.request_token)
-        nodename = os.uname()[1]
-        if nodename:
-            oauth_request.set_parameter("description", nodename)
-        Thread(target=self.open_in_browser, name="authorization",
-               args=(oauth_request.to_url(),)).start()
-
-    def get_temporary_httpd(self, nonce, retrieve_function, store):
-        "A separate class so it can be mocked in testing"
-        logger.debug("Creating a listening temp web server")
-        site = TemporaryTwistedWebServer(nonce=nonce,
-          retrieve_function=retrieve_function, store_yes_no=store)
-        temphttpd = server.Site(site)
-        temphttpdport = reactor.listenTCP(0, temphttpd)
-        callback_url = "http://localhost:%s/?nonce=%s" % (
-          temphttpdport.getHost().port, nonce)
-        site.set_port(temphttpdport)
-        logger.debug("Webserver listening on port '%s'", temphttpdport)
-        return callback_url
-
-    def retrieve_access_token(self, store=False, verifier=None):
-        """Retrieve the access token, once OAuth is done. This is a callback."""
-        logger.debug("Access token callback from temp webserver")
-        signature_method = oauth.OAuthSignatureMethod_PLAINTEXT()
-        oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-            http_url=self.access_token_url,
-            oauth_consumer=self.consumer,
-            token=self.request_token)
-        oauth_request.set_parameter("oauth_verifier", verifier)
-        oauth_request.sign_request(
-            signature_method, self.consumer, self.request_token)
-        logger.debug("Retrieving access token from OAuth")
-        access_token = self.make_token_request(oauth_request)
-        if not access_token:
-            logger.error("Failed to get access token.")
-            if self.callback_denied is not None:
-                self.callback_denied()
-        else:
-            if store:
-                logger.debug("Storing access token in keyring")
-                self.store_token(access_token)
-            logger.debug("Calling the callback_parent")
-            self.callback_parent(access_token)
-
-    def ensure_access_token(self, description=None):
-        """Returns an access token, either from the keyring or newly acquired.
-
-        If a new token is acquired, it will be stored in the keyring
-        for future use.
-        """
-        try:
-            access_token = self.get_access_token()
-            self.callback_parent(access_token)
-        except NoAccessToken:
-            if self.do_login:
-                access_token = self.acquire_access_token_if_online(
-                    description,
-                    store=True)
-            else:
-                if self.callback_notoken is not None:
-                    self.callback_notoken()
-
-
-class TemporaryTwistedWebServer(resource.Resource):
-    """A temporary httpd for the oauth process to call back to"""
-    isLeaf = True
-    def __init__(self, nonce, store_yes_no, retrieve_function):
-        """Initialize the temporary web server."""
-        resource.Resource.__init__(self)
-        self.nonce = nonce
-        self.store_yes_no = store_yes_no
-        self.retrieve_function = retrieve_function
-        reactor.callLater(600, self.stop) # ten minutes
-        self.port = None
-    def set_port(self, port):
-        """Save the Twisted port object so we can stop it later"""
-        self.port = port
-    def stop(self):
-        """Stop the httpd"""
-        logger.debug("Stopping temp webserver")
-        self.port.stopListening()
-    def render_GET(self, request):
-        """Handle incoming web requests"""
-        logger.debug("Incoming temp webserver hit received")
-        nonce = request.args.get("nonce", [None])[0]
-        url = request.args.get("return", ["https://one.ubuntu.com/"])[0]
-        verifier = request.args.get("oauth_verifier", [None])[0]
-        logger.debug("Got verifier %s" % verifier)
-        if nonce and (str(nonce) == str(self.nonce) and verifier):
-            self.retrieve_function(store=self.store_yes_no, verifier=verifier)
-            reactor.callLater(3, self.stop)
-            return """<!doctype html>
-        <html><head><meta http-equiv="refresh"
-        content="0;url=%(url)s">
-        </head>
-        <body>
-        <p>You should now automatically <a
-        href="%(url)s">return to %(url)s</a>.</p>
-        </body>
-        </html>
-        """ % { 'url' : url }
-        else:
-            self.retrieve_function(store=self.store_yes_no, verifier=verifier)
-            reactor.callLater(3, self.stop)
-            request.setResponseCode(400)
-            return """<!doctype html>
-        <html><head><title>Error</title></head>
-        <body>
-        <h1>There was an error</h1>
-        <p>The authentication process has not succeeded. This may be a
-        temporary problem; please try again in a few minutes.</p>
-        </body>
-        </html>
-        """
-
-
-

=== removed file 'ubuntuone/oauthdesktop/config.py'
--- ubuntuone/oauthdesktop/config.py	2009-07-22 18:14:52 +0000
+++ ubuntuone/oauthdesktop/config.py	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-# ubuntuone.oauthdesktop.config - Configuration for OAuthDesktop
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"Find the config file for ubuntuone-oauth-config"
-import os, ConfigParser
-from xdg.BaseDirectory import load_first_config
-
-def get_config(use_tmpconfig=True):
-    """Return a ConfigParser object from a config file.
-    Config file is looked for in the source tree first and then in the
-    FreeDesktop BaseDirectory folders.
-    """
-    # if tmpconfig exists, then we are running out of the source tree
-    tmpconfig = os.path.realpath(os.path.join(
-            __file__, "../../../data/oauth_urls"
-            ))
-    if os.path.isfile(tmpconfig) and use_tmpconfig:
-        config_file = tmpconfig
-    else:
-        config_file = load_first_config('ubuntuone','oauth_urls')
-
-    cfp = ConfigParser.ConfigParser()
-    cfp.FILENAME = None
-    if config_file is not None:
-        try:
-            cfp.read(config_file)
-            cfp.FILENAME = config_file
-        except ConfigParser.Error:
-            cfp = ConfigParser.ConfigParser()
-            cfp.FILENAME = None
-    return cfp
-
-

=== removed file 'ubuntuone/oauthdesktop/key_acls.py'
--- ubuntuone/oauthdesktop/key_acls.py	2010-03-10 21:11:45 +0000
+++ ubuntuone/oauthdesktop/key_acls.py	1970-01-01 00:00:00 +0000
@@ -1,162 +0,0 @@
-# ubuntuone.oauthdesktop.key_acls - OAuth ACL handling for keyring
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""OAuth client authorisation code.
-
-This code finds all apps that have pre-registered themselves as wanting to
-access OAuth tokens from the Gnome keyring without the user having to approve
-that, and sets ACLs on relevant keys so they can do so.
-
-Apps pre-register themselves by dropping an ini file in 
-/etc/xdg/ubuntuone/oauth_registration.d/ in which each section has keys
-realm, consumer_key, exe_path, application_name.
-"""
-
-import xdg.BaseDirectory, os, ConfigParser, gnomekeyring
-
-def get_privileged_config_folder(use_source_tree_folder=True):
-    """Find the XDG config folder to use which is not the user's personal 
-       config (i.e., ~/.config) so that files in it are root-owned"""
-       
-    # First, check for folder (if we're running from the source tree)
-    if use_source_tree_folder:
-        source_tree_folder = os.path.join(
-             os.path.split(__file__)[0], 
-             "../../data/oauth_registration.d")
-        if os.path.isdir(source_tree_folder):
-            return os.path.join(source_tree_folder, "..")
-    
-    # Otherwise, check for proper XDG folders
-    privileged_folders = [x for x in 
-       xdg.BaseDirectory.load_config_paths('ubuntuone')
-       if not x.startswith(xdg.BaseDirectory.xdg_config_home)]
-    if privileged_folders:
-        return privileged_folders[0]
-    else:
-        return None
-
-def get_acl_preregistrations(use_source_tree_folder=True):
-    "Return a list of all config files in the pre-registration folder"
-    config_folder = get_privileged_config_folder(use_source_tree_folder)
-    if config_folder:
-        conf_dir = os.path.join(config_folder, 
-          "oauth_registration.d")
-        if os.path.isdir(conf_dir):
-            return [os.path.join(conf_dir, x) for x in os.listdir(conf_dir)]
-    return []
-
-def get_item_ids_for_realm(realm, consumer_key):
-    "Find all keyring tokens for a specific realm/consumer_key"
-    if realm == "http://localhost":
-        # if realm (from the config file) is localhost, then the token
-        # will have ubuntuone-realm == http://localhost:SOMETHING
-        # so find all keys with this consumer_key, and pass on any
-        # where ubuntuone-realm begins with http://localhost:
-        try:
-            items = gnomekeyring.find_items_sync(
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                {
-                 'oauth-consumer-key': consumer_key})
-        except (gnomekeyring.NoMatchError,
-                gnomekeyring.DeniedError):
-            return []
-        items = [x.item_id for x in items if 
-        x.attributes.get("ubuntuone-realm", "").startswith("http://localhost:")]
-        return items
-    else:
-        # realm was not localhost, so search for it explicitly
-        try:
-            items = gnomekeyring.find_items_sync(
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                {'ubuntuone-realm': realm,
-                 'oauth-consumer-key': consumer_key})
-        except (gnomekeyring.NoMatchError,
-                gnomekeyring.DeniedError):
-            return []
-        return [x.item_id for x in items]
-
-def set_single_acl(app_sets, specific_item_id=None):
-    """Allow a specified set of apps to access a matching keyring 
-       token without prompts"""
-    for realm, consumer_key, exe_path, application_name in app_sets:
-        if specific_item_id is None:
-            items = get_item_ids_for_realm(realm, consumer_key)
-        else:
-            # item_id specified
-            items = [specific_item_id]
-    
-        # set an ACL on the key so the calling app can read it without
-        # a prompt dialog
-        for item_id in items:
-            acl = gnomekeyring.item_get_acl_sync(None, item_id)
-            new_acls = False
-            real_exe_path = os.path.realpath(exe_path)
-            for acl_item in acl:
-                if acl_item.get_display_name() == application_name and \
-                   acl_item.get_path_name() == real_exe_path:
-                    # this ACL is already set
-                    break
-            else:
-                appref = gnomekeyring.ApplicationRef()
-                ac = gnomekeyring.AccessControl(appref, 
-                   gnomekeyring.ACCESS_READ | 
-                   gnomekeyring.ACCESS_WRITE | gnomekeyring.ACCESS_REMOVE)
-                ac.set_display_name(application_name)
-                ac.set_path_name(real_exe_path)
-                acl.append(ac)
-                new_acls = True
-            if new_acls:
-                gnomekeyring.item_set_acl_sync(None, item_id, acl)
-        
-def set_all_key_acls(item_id=None, use_source_tree_folder=True):
-    """For each file in the config folder, get the (realm, key) pair that
-       the program therein is interested in and register the program as able
-       to access those keys by setting an ACL on them."""
-    for config_file in get_acl_preregistrations(use_source_tree_folder):
-        cfp = ConfigParser.ConfigParser()
-        try:
-            cfp.read(config_file)
-        except ConfigParser.Error:
-            continue
-        
-        app_sets = []
-        
-        for section in cfp.sections():
-            try:
-                realm = cfp.get(section, "realm")
-            except ConfigParser.NoOptionError:
-                realm = None
-            try:
-                consumer_key = cfp.get(section, "consumer_key")
-            except ConfigParser.NoOptionError:
-                consumer_key = None
-            try:
-                exe_path = cfp.get(section, "exe_path")
-            except ConfigParser.NoOptionError:
-                exe_path = None
-            try:
-                application_name = cfp.get(section, "application_name")
-            except ConfigParser.NoOptionError:
-                application_name = None
-            if realm and consumer_key and exe_path and application_name:
-                app_sets.append((realm, consumer_key, exe_path, 
-                                 application_name))
-        
-        if app_sets:
-            set_single_acl(app_sets, specific_item_id=item_id)
-
-

=== removed file 'ubuntuone/oauthdesktop/logger.py'
--- ubuntuone/oauthdesktop/logger.py	2009-10-16 19:56:57 +0000
+++ ubuntuone/oauthdesktop/logger.py	1970-01-01 00:00:00 +0000
@@ -1,49 +0,0 @@
-# ubuntuone.oauthdesktop.logger - logging miscellany
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Miscellaneous logging functions."""
-import os
-import logging
-import xdg.BaseDirectory
-
-from logging.handlers import RotatingFileHandler
-
-home = xdg.BaseDirectory.xdg_cache_home
-LOGFOLDER = os.path.join(home, 'ubuntuone', 'log')
-# create log folder if it doesn't exists
-if not os.path.exists(LOGFOLDER):
-    os.makedirs(LOGFOLDER)
-
-LOGFILENAME = os.path.join(LOGFOLDER, 'oauth-login.log')
-
-# Only log this level and above
-LOG_LEVEL = logging.INFO
-
-root_formatter = logging.Formatter(
-    fmt="%(asctime)s:%(msecs)s %(name)s %(message)s")
-root_handler = RotatingFileHandler(LOGFILENAME, maxBytes=1048576,
-                                   backupCount=1)
-root_handler.setLevel(LOG_LEVEL)
-root_handler.setFormatter(root_formatter)
-
-def setupLogging(log_domain):
-    """Create basic logger to set filename"""
-    logger = logging.getLogger(log_domain)
-    logger.propagate = False
-    logger.setLevel(LOG_LEVEL)
-    logger.addHandler(root_handler)
-    return logger

=== removed file 'ubuntuone/oauthdesktop/main.py'
--- ubuntuone/oauthdesktop/main.py	2010-03-30 21:11:52 +0000
+++ ubuntuone/oauthdesktop/main.py	1970-01-01 00:00:00 +0000
@@ -1,296 +0,0 @@
-#!/usr/bin/python
-
-# ubuntuone.oauthdesktop.main - main login handling interface
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 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
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""OAuth login handler.
-
-A command-line utility which accepts requests for OAuth login over D-Bus,
-handles the OAuth process (including adding the OAuth access token to the
-gnome keyring), and then alerts the calling app (and others) with a D-Bus
-signal so they can retrieve the new token.
-"""
-
-import dbus.service, urlparse, time, gobject
-import pynotify
-
-from dbus.mainloop.glib import DBusGMainLoop
-
-from ubuntuone.oauthdesktop.config import get_config
-
-from ubuntuone.oauthdesktop.logger import setupLogging
-logger = setupLogging("UbuntuOne.OAuthDesktop.main")
-
-DBusGMainLoop(set_as_default=True)
-
-# Disable the invalid name warning, as we have a lot of DBus style names
-# pylint: disable-msg=C0103
-
-class NoDefaultConfigError(Exception):
-    """No default section in configuration file"""
-    pass
-
-class BadRealmError(Exception):
-    """Realm must be a URL"""
-    pass
-
-class LoginProcessor:
-    """Actually do the work of processing passed parameters"""
-    def __init__(self, dbus_object, use_libnotify=True):
-        """Initialize the login processor."""
-        logger.debug("Creating a LoginProcessor")
-        self.use_libnotify = use_libnotify
-        if self.use_libnotify and pynotify:
-            logger.debug("Hooking libnotify")
-            pynotify.init("UbuntuOne Login")
-        self.note1 = None
-        self.realm = None
-        self.consumer_key = None
-        self.dbus_object = dbus_object
-        logger.debug("Getting configuration")
-        self.config = get_config()
-
-    def login(self, realm, consumer_key, do_login=True):
-        """Initiate an OAuth login"""
-        logger.debug("Initiating OAuth login in LoginProcessor")
-        self.realm = str(realm) # because they are dbus.Strings, not str
-        self.consumer_key = str(consumer_key)
-
-        logger.debug("Obtaining OAuth urls")
-        (request_token_url, user_authorisation_url,
-          access_token_url, consumer_secret) =  self.get_config_urls(realm)
-        logger.debug("OAuth URLs are: request='%s', userauth='%s', " +\
-                     "access='%s', secret='%s'", request_token_url,
-                     user_authorisation_url, access_token_url, consumer_secret)
-
-        from ubuntuone.oauthdesktop.auth import AuthorisationClient
-        client = AuthorisationClient(self.realm,
-                                     request_token_url,
-                                     user_authorisation_url,
-                                     access_token_url, self.consumer_key,
-                                     consumer_secret,
-                                     callback_parent=self.got_token,
-                                     callback_denied=self.got_denial,
-                                     callback_notoken=self.got_no_token,
-                                     callback_error=self.got_error,
-                                     do_login=do_login)
-
-        logger.debug("Calling auth.client.ensure_access_token in thread")
-        gobject.timeout_add_seconds(1, client.ensure_access_token)
-
-    def clear_token(self, realm, consumer_key):
-        """Remove the currently stored OAuth token from the keyring."""
-        self.realm = str(realm)
-        self.consumer_key = str(consumer_key)
-        (request_token_url, user_authorisation_url,
-          access_token_url, consumer_secret) =  self.get_config_urls(self.realm)
-        from ubuntuone.oauthdesktop.auth import AuthorisationClient
-        client = AuthorisationClient(self.realm,
-                                     request_token_url,
-                                     user_authorisation_url,
-                                     access_token_url,
-                                     self.consumer_key, consumer_secret,
-                                     callback_parent=self.got_token,
-                                     callback_denied=self.got_denial,
-                                     callback_notoken=self.got_no_token,
-                                     callback_error=self.got_error)
-        gobject.timeout_add_seconds(1, client.clear_token)
-
-    def error_handler(self, failure):
-        """Deal with errors returned from auth process"""
-        logger.debug("Error returned from auth process")
-        self.dbus_object.currently_authing = False # not block future requests
-
-    def get_config_urls(self, realm):
-        """Look up the URLs to use in the config file"""
-        logger.debug("Fetching config URLs for realm='%s'", realm)
-        if self.config.has_section(realm):
-            logger.debug("Realm '%s' is in config", realm)
-            request_token_url = self.__get_url(realm, "request_token_url")
-            user_authorisation_url = self.__get_url(realm,
-              "user_authorisation_url")
-            access_token_url = self.__get_url(realm, "access_token_url")
-            consumer_secret = self.__get_option(realm, "consumer_secret")
-        elif realm.startswith("http://localhost") and \
-          self.config.has_section("http://localhost"):
-            logger.debug("Realm is localhost and is in config")
-            request_token_url = self.__get_url("http://localhost",
-              "request_token_url", realm)
-            user_authorisation_url = self.__get_url("http://localhost",
-              "user_authorisation_url", realm)
-            access_token_url = self.__get_url("http://localhost",
-              "access_token_url", realm)
-            consumer_secret = self.__get_option("http://localhost",
-              "consumer_secret")
-        elif self.is_valid_url(realm):
-            logger.debug("Realm '%s' is not in config", realm)
-            request_token_url = self.__get_url("default",
-              "request_token_url", realm)
-            user_authorisation_url = self.__get_url("default",
-              "user_authorisation_url", realm)
-            access_token_url = self.__get_url("default",
-              "access_token_url", realm)
-            consumer_secret = self.__get_option(realm, "consumer_secret")
-        else:
-            logger.debug("Realm '%s' is a bad realm", realm)
-            raise BadRealmError
-        return (request_token_url, user_authorisation_url,
-                access_token_url, consumer_secret)
-
-    def is_valid_url(self, url):
-        """Simple check for URL validity"""
-        # pylint: disable-msg=W0612
-        scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
-        if scheme and netloc:
-            return True
-        else:
-            return False
-
-    def got_token(self, access_token):
-        """Callback function when access token has been retrieved"""
-        logger.debug("Token retrieved, calling NewCredentials function")
-        self.dbus_object.NewCredentials(self.realm, self.consumer_key)
-
-    def got_denial(self):
-        """Callback function when request token has been denied"""
-        self.dbus_object.AuthorizationDenied()
-
-    def got_no_token(self):
-        """Callback function when access token is not in keyring."""
-        self.dbus_object.NoCredentials()
-
-    def got_error(self, message):
-        """Callback function to emit an error message over DBus."""
-        self.dbus_object.OAuthError(message)
-
-    def __get_url(self, realm, option, actual_realm=None):
-        """Construct a full URL from realm and a URLpath for that realm in
-           the config file."""
-        if actual_realm:
-            realm_to_use = actual_realm
-        else:
-            realm_to_use = realm
-        urlstub = self.__get_option(realm, option)
-        return urlparse.urljoin(realm_to_use, urlstub)
-
-    def __get_option(self, realm, option):
-        """Return a specific option for that realm in
-           the config file. If the realm does not exist in the config file,
-           fall back to the [default] section."""
-        if self.config.has_section(realm) and \
-           self.config.has_option(realm, option):
-            urlstub = self.config.get(realm, option)
-            return urlstub
-
-        # either the realm exists and this url does not, or
-        # the realm doesn't exist; either way, fall back to [default] section
-        urlstub = self.config.get("default", option, None)
-        if urlstub is not None:
-            return urlstub
-
-        # this url does not exist in default section either
-        # this shouldn't happen
-        raise NoDefaultConfigError("No default configuration for %s" % option)
-
-
-class Login(dbus.service.Object):
-    """Object which listens for D-Bus OAuth requests"""
-    def __init__(self, bus_name):
-        """Initiate the Login object."""
-        dbus.service.Object.__init__(self, object_path="/", bus_name=bus_name)
-        self.processor = LoginProcessor(self)
-        self.currently_authing = False
-        logger.debug("Login D-Bus service starting up")
-
-    @dbus.service.method(dbus_interface='com.ubuntuone.Authentication',
-                                           in_signature='ss', out_signature='')
-    def login(self, realm, consumer_key):
-        """D-Bus method, exported over the bus, to initiate an OAuth login"""
-        logger.debug("login() D-Bus message received with realm='%s', " +
-                     "consumer_key='%s'", realm, consumer_key)
-        if self.currently_authing:
-            logger.debug("Currently in the middle of OAuth: rejecting this")
-            return
-        self.currently_authing = True
-        self.processor.login(realm, consumer_key)
-
-    @dbus.service.method(dbus_interface='com.ubuntuone.Authentication',
-                                           in_signature='ssb', out_signature='')
-    def maybe_login(self, realm, consumer_key, do_login):
-        """
-        D-Bus method, exported over the bus, to maybe initiate an OAuth login
-        """
-        logger.debug("maybe_login() D-Bus message received with realm='%s', " +
-                     "consumer_key='%s'", realm, consumer_key)
-        if self.currently_authing:
-            logger.debug("Currently in the middle of OAuth: rejecting this")
-            return
-        self.currently_authing = True
-        self.processor.login(realm, consumer_key, do_login)
-
-    @dbus.service.method(dbus_interface='com.ubuntuone.Authentication',
-                         in_signature='ss', out_signature='')
-    def clear_token(self, realm, consumer_key):
-        """
-        D-Bus method, exported over the bus, to clear the existing token.
-        """
-        self.processor.clear_token(realm, consumer_key)
-
-    @dbus.service.signal(dbus_interface='com.ubuntuone.Authentication',
-                                             signature='ss')
-    def NewCredentials(self, realm, consumer_key):
-        """Fire D-Bus signal when the user accepts authorization."""
-        logger.debug("Firing the NewCredentials signal")
-        self.currently_authing = False
-        return (self.processor.realm, self.processor.consumer_key)
-
-    @dbus.service.signal(dbus_interface='com.ubuntuone.Authentication')
-    def AuthorizationDenied(self):
-        """Fire the signal when the user denies authorization."""
-        self.currently_authing = False
-
-    @dbus.service.signal(dbus_interface='com.ubuntuone.Authentication')
-    def NoCredentials(self):
-        """Fired when the user does not have a token in the keyring."""
-        self.currently_authing = False
-
-    @dbus.service.signal(dbus_interface='com.ubuntuone.Authentication',
-                         signature='s')
-    def OAuthError(self, message):
-        """Fire the signal when an error needs to be propagated to the user."""
-        self.currently_authing = False
-        return message
-
-def main():
-    """Start everything"""
-    logger.debug("Starting up at %s", time.asctime())
-    logger.debug("Installing the Twisted glib2reactor")
-    from twisted.internet import glib2reactor # for non-GUI apps
-    glib2reactor.install()
-    from twisted.internet import reactor
-
-    logger.debug("Creating the D-Bus service")
-    Login(dbus.service.BusName("com.ubuntuone.Authentication",
-                               bus=dbus.SessionBus()))
-    # cleverness here to say:
-    # am I already running (bound to this d-bus name)?
-    # if so, send a signal to the already running instance
-    # this means that this app can be started from an x-ubutnuone: URL
-    # to kick off the signin process
-    logger.debug("Starting the reactor mainloop")
-    reactor.run()
-

=== modified file 'ubuntuone/syncdaemon/dbus_interface.py'
--- ubuntuone/syncdaemon/dbus_interface.py	2010-06-02 18:00:29 +0000
+++ ubuntuone/syncdaemon/dbus_interface.py	2010-06-16 20:35:34 +0000
@@ -33,7 +33,7 @@
 from ubuntuone.syncdaemon.interfaces import IMarker
 from ubuntuone.syncdaemon import config
 from ubuntuone.syncdaemon.volume_manager import Share, UDF, VolumeDoesNotExist
-
+from ubuntu_sso import DBUS_IFACE_AUTH_NAME, DBUS_PATH_AUTH
 
 # Disable the "Invalid Name" check here, as we have lots of DBus style names
 # pylint: disable-msg=C0103
@@ -58,10 +58,6 @@
 NM_STATE_EVENTS = {NM_STATE_CONNECTED: 'SYS_NET_CONNECTED',
                    NM_STATE_DISCONNECTED: 'SYS_NET_DISCONNECTED'}
 
-# OAuthDesktop constants
-DBUS_IFACE_AUTH_NAME = "com.ubuntuone.Authentication"
-DBUS_PATH_AUTH = "/"
-
 logger = logging.getLogger("ubuntuone.SyncDaemon.DBus")
 
 def get_classname(thing):