Merge lp:~nataliabidart/ubuntuone-client/revert-provide_credentials_management into lp:ubuntuone-client

[Natalia Bidart]

- Reverting changes applied from https://code.launchpad.net/~mandel/ubuntuone-client/provide_credentials_management/+merge/59743 to fix import error on ubuntuone-launch.

[Natalia Bidart (nataliabidart)]

To test, run the suite and also confirm that ubuntuone-launch works:

PYTHONPATH=. ./bin/ubuntuone-launch

(on trunk the above fails with ImportError on CredentialsManagementTool).

[dobey (dobey)]

review: Approve

[Alejandro J. Cura (alecu)]

review: Approve

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2011-04-01 20:31:53 +0000
+++ po/POTFILES.in	2011-05-24 18:23:27 +0000
@@ -1,7 +1,6 @@
 ubuntuone/clientdefs.py.in
 ubuntuone/status/aggregator.py
 ubuntuone/platform/linux/credentials.py
-ubuntuone/platform/windows/credentials.py
 data/emblem-ubuntuone-downloading.icon.in
 data/emblem-ubuntuone-unsynchronized.icon.in
 data/emblem-ubuntuone-uploading.icon.in

=== modified file 'tests/platform/linux/test_credentials.py'
--- tests/platform/linux/test_credentials.py	2011-04-01 20:00:42 +0000
+++ tests/platform/linux/test_credentials.py	2011-05-24 18:23:27 +0000
@@ -25,11 +25,12 @@
 from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.platform.linux.credentials import (dbus, logger, logging,
-    CredentialsManagement, ubuntu_sso, DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH,
-    DBUS_CREDENTIALS_IFACE, APP_NAME, HELP_TEXT_KEY, DESCRIPTION, 
-    TC_URL_KEY, TC_URL, PING_URL_KEY, PING_URL, TIMEOUT_INTERVAL,
+    CredentialsManagement, CredentialsManagementTool, CredentialsError,
+    ubuntu_sso,
+    DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH, DBUS_CREDENTIALS_IFACE,
+    APP_NAME, HELP_TEXT_KEY, DESCRIPTION, TC_URL_KEY, TC_URL,
+    PING_URL_KEY, PING_URL, TIMEOUT_INTERVAL,
 )
-from ubuntuone.credentials import CredentialsManagementTool, CredentialsError
 
 FAKED_CREDENTIALS = {
     'consumer_key': 'faked_consumer_key',

=== removed file 'tests/platform/windows/test_credentials.py'
--- tests/platform/windows/test_credentials.py	2011-05-04 11:21:02 +0000
+++ tests/platform/windows/test_credentials.py	1970-01-01 00:00:00 +0000
@@ -1,151 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Author: Manuel de la Pena <[e-mail]>
-#
-# Copyright 2011 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 credentials management on Windows."""
-
-from mocker import MockerTestCase
-
-from ubuntu_sso.credentials import HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY
-from ubuntuone.platform.windows.credentials import (
-    CredentialsManagement,
-    APP_NAME,
-    DESCRIPTION,
-    PING_URL,
-    TC_URL)
-
-
-class TestCredentialsManagement(MockerTestCase):
-    """Test that the credentials management is correctly used."""
-
-    def setUp(self):
-        """Set the different tests."""
-        super(TestCredentialsManagement, self).setUp()
-        self.proxy = self.mocker.mock()
-        self.management = CredentialsManagement()
-        self.management._get_sso_proxy = lambda *args: self.proxy
-
-    def test_find_credentials(self):
-        """Ensure we do ask corectly for the credentials."""
-        reply_handler = lambda: None
-        error_handler = lambda: None
-        self.proxy.find_credentials(APP_NAME, {})
-        self.mocker.replay()
-        self.management.find_credentials(reply_handler=reply_handler,
-                                         error_handler=error_handler)
-
-    def test_clear_credentials(self):
-        """Ensure we do clear the credentials."""
-        reply_handler = lambda: None
-        error_handler = lambda: None
-        self.proxy.clear_credentials(APP_NAME, {})
-        self.mocker.replay()
-        self.management.clear_credentials(reply_handler=reply_handler,
-                                          error_handler=error_handler)
-
-    def test_store_credentials(self):
-        """Store the token for Ubuntu One application."""
-        credentials = 'creds'
-        reply_handler = lambda: None
-        error_handler = lambda: None
-        self.proxy.store_credentials(APP_NAME, credentials)
-        self.mocker.replay()
-        self.management.store_credentials(credentials,
-                    reply_handler=reply_handler, error_handler=error_handler)
-
-    def test_register(self):
-        """Get credentials if found else prompt to register to Ubuntu One."""
-        reply_handler = lambda: None
-        error_handler = lambda: None
-        args = dict(test='test', args='args')
-        extra_params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
-                  PING_URL_KEY: PING_URL}
-        extra_params.update(args)
-        self.proxy.register(APP_NAME, extra_params)
-        self.mocker.replay()
-        self.management.register(args, reply_handler, error_handler)
-
-    def test_login(self):
-        """Get credentials if found else prompt to login to Ubuntu One."""
-        reply_handler = lambda: None
-        error_handler = lambda: None
-        args = dict(test='test', args='args')
-        extra_params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
-                        PING_URL_KEY: PING_URL}
-        extra_params.update(args)
-        self.proxy.login(APP_NAME, extra_params)
-        self.mocker.replay()
-        self.management.login(args, reply_handler, error_handler)
-
-    def test_register_to_credentials_stored(self):
-        """Register to the CredentialsStored dbus signal."""
-        callback = lambda: None
-        self.proxy.register_to_signals()
-        self.proxy.on_credentials_stored_cb = callback
-        self.proxy.on_credentials_stored_cb
-        self.mocker.result(callback)
-        self.mocker.replay()
-        self.management.register_to_credentials_stored(callback)
-
-    def test_register_to_credentials_cleared(self):
-        """Register to the CredentialsCleared dbus signal."""
-        callback = lambda: None
-        self.proxy.register_to_signals()
-        self.proxy.on_credentials_cleared_cb = callback
-        self.proxy.on_credentials_cleared_cb
-        self.mocker.result(callback)
-        self.mocker.replay()
-        self.management.register_to_credentials_cleared(callback)
-
-    def test_register_to_credentials_found(self):
-        """Register to the CredentialsFound dbus signal."""
-        callback = lambda: None
-        self.proxy.register_to_signals()
-        self.proxy.on_credentials_found_cb = callback
-        self.proxy.on_credentials_found_cb
-        self.mocker.result(callback)
-        self.mocker.replay()
-        self.management.register_to_credentials_found(callback)
-
-    def test_register_to_credentials_not_found(self):
-        """Register to the CredentialsFound dbus signal."""
-        callback = lambda: None
-        self.proxy.register_to_signals()
-        self.proxy.on_credentials_not_found_cb = callback
-        self.proxy.on_credentials_not_found_cb
-        self.mocker.result(callback)
-        self.mocker.replay()
-        self.management.register_to_credentials_not_found(callback)
-
-    def test_register_to_authorization_denied(self):
-        """Register to the AuthorizationDenied dbus signal."""
-        callback = lambda: None
-        self.proxy.register_to_signals()
-        self.proxy.on_authorization_denied_cb = callback
-        self.proxy.on_authorization_denied_cb
-        self.mocker.result(callback)
-        self.mocker.replay()
-        self.management.register_to_authorization_denied(callback)
-
-    def test_register_to_credentials_error(self):
-        """Register to the CredentialsError dbus signal."""
-        callback = lambda: None
-        self.proxy.register_to_signals()
-        self.proxy.on_credentials_error_cb = callback
-        self.proxy.on_credentials_error_cb
-        self.mocker.result(callback)
-        self.mocker.replay()
-        self.management.register_to_credentials_error(callback)

=== removed file 'tests/test_credentials.py'
--- tests/test_credentials.py	2011-04-01 20:31:53 +0000
+++ tests/test_credentials.py	1970-01-01 00:00:00 +0000
@@ -1,99 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Author: Manuel de la Pena<[e-mail]>
-#
-# Copyright 2011 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/>.
-"""Platform independent tests for the credentials management."""
-
-from mocker import MockerTestCase, MATCH
-
-from ubuntuone.credentials import CredentialsManagementTool
-
-
-class TestCredentialsManagementTool(MockerTestCase):
-    """Test the crendentials management tool mocking the proxy."""
-
-    def setUp(self):
-        """Set the diff tests."""
-        super(TestCredentialsManagementTool, self).setUp()
-        self.get_cred_proxy = self.mocker.replace(
-                                    'ubuntuone.platform.get_creds_proxy')
-        self.proxy = self.mocker.mock()
-        self.management_tool = CredentialsManagementTool()
-
-    def test_find_credentials(self):
-        """Test that we do ask for the credentials correctly."""
-        signals = ['creds_found', 'creds_not_found', 'creds_erro']
-        self.get_cred_proxy()
-        self.mocker.result(self.proxy)
-        self.proxy.register_to_credentials_found(MATCH(callable))
-        self.mocker.result(signals[0])
-        self.proxy.register_to_credentials_not_found(MATCH(callable))
-        self.mocker.result(signals[1])
-        self.proxy.register_to_credentials_error(MATCH(callable))
-        self.mocker.result(signals[2])
-        self.proxy.find_credentials(reply_handler=MATCH(callable),
-                                    error_handler=MATCH(callable))
-        self.mocker.replay()
-        return self.management_tool.find_credentials()
-
-    def test_clear_credentials(self):
-        """Test that we clear the credentials correctly."""
-        signals = ['creds_cleared', 'creds_error']
-        self.get_cred_proxy()
-        self.mocker.result(self.proxy)
-        self.proxy.register_to_credentials_cleared(MATCH(callable))
-        self.mocker.result(signals[0])
-        self.proxy.register_to_credentials_error(MATCH(callable))
-        self.mocker.result(signals[1])
-        self.proxy.clear_credentials(reply_handler=MATCH(callable),
-                                     error_handler=MATCH(callable))
-        self.mocker.replay()
-        return self.management_tool.clear_credentials()
-
-    def test_store_credentials(self):
-        """Test that we store the credentials correctly."""
-        token = 'token'
-        signals = ['creds_stored','creds_error']
-        self.get_cred_proxy()
-        self.mocker.result(self.proxy)
-        self.proxy.register_to_credentials_stored(MATCH(callable))
-        self.mocker.result(signals[0])
-        self.proxy.register_to_credentials_error(MATCH(callable))
-        self.mocker.result(signals[1])
-        self.proxy.store_credentials(token, reply_handler=MATCH(callable),
-                                     error_handler=MATCH(callable))
-        self.mocker.replay()
-        return self.management_tool.store_credentials(token)
-
-    def test_register(self):
-        """Test that we correctly register."""
-        window_id = 10
-        window_id_dict = dict(window_id=str(window_id))
-        signals = ['creds_found', 'creds_denied', 'creds_error']
-        self.get_cred_proxy()
-        self.mocker.result(self.proxy)
-        self.proxy.register_to_credentials_found(MATCH(callable))
-        self.mocker.result(signals[0])
-        self.proxy.register_to_authorization_denied(MATCH(callable))
-        self.mocker.result(signals[1])
-        self.proxy.register_to_credentials_error(MATCH(callable))
-        self.mocker.result(signals[2])
-        self.proxy.register(window_id_dict, reply_handler=MATCH(callable),
-                            error_handler=MATCH(callable))
-        self.mocker.replay()
-        return self.management_tool.register(window_id=window_id)
-

=== removed file 'ubuntuone/credentials.py'
--- ubuntuone/credentials.py	2011-05-03 07:58:57 +0000
+++ ubuntuone/credentials.py	1970-01-01 00:00:00 +0000
@@ -1,255 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Author: Natalia B. Bidart <[e-mail]>
-# Author: Manuel de la Pena<[e-mail]>
-#
-# Copyright 2011 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/>.
-"""Common code for the credentials management."""
-
-import os
-
-from twisted.internet import defer
-
-from ubuntuone.logger import (basic_formatter, logging,
-    CustomRotatingFileHandler, LOGFOLDER)
-from ubuntuone.platform import get_creds_proxy
-
-LOG_LEVEL = logging.DEBUG
-path = os.path.join(LOGFOLDER, 'credentials.log')
-MAIN_HANDLER = CustomRotatingFileHandler(path)
-MAIN_HANDLER.setFormatter(basic_formatter)
-MAIN_HANDLER.setLevel(LOG_LEVEL)
-
-logger = logging.getLogger("ubuntuone.credentials")
-logger.setLevel(LOG_LEVEL)
-logger.addHandler(MAIN_HANDLER)
-
-
-class CredentialsError(Exception):
-    """A general exception when hadling credentilas."""
-
-
-class CredentialsManagementTool(object):
-    """Wrapper to CredentialsManagement.
-
-    The goal of this class is to abstract the caller from calling the DBus
-    service implemented in the class CredentialsManagement.
-
-    """
-
-    def __init__(self):
-        self._cleanup_signals = []
-
-    def cleanup(self, _):
-        """Disconnect all the DBus signals."""
-        for sig in self._cleanup_signals:
-            logger.debug('cleanup: removing signal match %r', sig)
-            sig.remove()
-
-        return _
-
-    @defer.inlineCallbacks
-    def find_credentials(self):
-        """Find credentials for Ubuntu One.
-
-        Return a deferred that, when fired, will return the credentials for
-        Ubuntu One for the current logged in user.
-
-        The credentials is a dictionary with both string keys and values. The
-        dictionary may be either empty if there are no credentials for the
-        user, or will hold five items as follow:
-
-        - "name"
-        - "token"
-        - "token_secret"
-        - "consumer_key"
-        - "consumer_secret"
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = get_creds_proxy()
-
-        sig = proxy.register_to_credentials_found(d.callback)
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.register_to_credentials_not_found(lambda: d.callback({}))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.register_to_credentials_error(
-            lambda error_dict: d.errback(CredentialsError(error_dict)))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.find_credentials(reply_handler=lambda: done.callback(None),
-            error_handler=lambda *a: done.errback(a))
-
-        yield done
-
-        result = yield d
-        defer.returnValue(result)
-
-    @defer.inlineCallbacks
-    def clear_credentials(self):
-        """Clear credentials for Ubuntu One.
-
-        Return a deferred that, when fired, will return no result but will
-        indicate that the Ubuntu One credentials for the current user were
-        removed from the local keyring.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = get_creds_proxy()
-        sig = proxy.register_to_credentials_cleared(lambda: d.callback(None))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.register_to_credentials_error(
-            lambda error_dict: d.errback(CredentialsError(error_dict)))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.clear_credentials(reply_handler=lambda: done.callback(None),
-            error_handler=lambda *a: done.errback(a))
-
-        yield done
-
-        yield d
-
-    @defer.inlineCallbacks
-    def store_credentials(self, token):
-        """Store credentials for Ubuntu One.
-
-        The parameter 'token' should be a dictionary that matches the
-        description of the result of 'find_credentials'.
-
-        Return a deferred that, when fired, will return no result but will
-        indicate that 'token' was stored in the local keyring as the new Ubuntu
-        One credentials for the current user.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = get_creds_proxy()
-        sig = proxy.register_to_credentials_stored(lambda: d.callback(None))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.register_to_credentials_error(
-            lambda error_dict: d.errback(CredentialsError(error_dict)))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.store_credentials(token,
-            reply_handler=lambda: done.callback(None),
-            error_handler=lambda *a: done.errback(a))
-
-        yield done
-
-        yield d
-
-    @defer.inlineCallbacks
-    def register(self, window_id=0):
-        """Register to Ubuntu One.
-
-        Return a deferred that, when fired, will return the credentials for
-        Ubuntu One for the current logged in user.
-
-        If there are no credentials for the current user, a GTK UI will be
-        opened to invite the user to register to Ubuntu One. This UI provides
-        options to either register (main screen) or login (secondary screen).
-
-        You can pass an optional 'window_id' parameter that will be used by the
-        GTK UI to be set transient for it.
-
-        The returned credentials will be either a non-empty dictionary like the
-        one described in 'find_credentials', or None. The latter indicates that
-        there were no credentials for the user in the local keyring and that
-        the user refused to register to Ubuntu One.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = get_creds_proxy()
-
-        sig = proxy.register_to_credentials_found(d.callback)
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.register_to_authorization_denied(lambda: d.callback(None))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.register_to_credentials_error(
-            lambda error_dict: d.errback(CredentialsError(error_dict)))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.register({'window_id': str(window_id)},
-            reply_handler=lambda: done.callback(None),
-            error_handler=lambda *a: done.errback(a))
-
-        yield done
-
-        result = yield d
-        defer.returnValue(result)
-
-    @defer.inlineCallbacks
-    def login(self, window_id=0):
-        """Login to Ubuntu One.
-
-        Return a deferred that, when fired, will return the credentials for
-        Ubuntu One for the current logged in user.
-
-        If there are no credentials for the current user, a GTK UI will be
-        opened to invite the user to login to Ubuntu One. This UI provides
-        options to either login (main screen) or retrieve password (secondary
-        screen).
-
-        You can pass an optional 'window_id' parameter that will be used by the
-        GTK UI to be set transient for it.
-
-        The returned credentials will be either a non-empty dictionary like the
-        one described in 'find_credentials', or None. The latter indicates that
-        there were no credentials for the user in the local keyring and that
-        the user refused to login to Ubuntu One.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = get_creds_proxy()
-
-        sig = proxy.register_to_credentials_found(d.callback)
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.register_to_authorization_denied(lambda: d.callback(None))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.register_to_credentials_error(
-            lambda error_dict: d.errback(CredentialsError(error_dict)))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.login({'window_id': str(window_id)},
-            reply_handler=lambda: done.callback(None),
-            error_handler=lambda *a: done.errback(a))
-
-        yield done
-
-        result = yield d
-        defer.returnValue(result)

=== modified file 'ubuntuone/platform/linux/__init__.py'
--- ubuntuone/platform/linux/__init__.py	2011-05-03 15:22:19 +0000
+++ ubuntuone/platform/linux/__init__.py	2011-05-24 18:23:27 +0000
@@ -55,7 +55,7 @@
     get_udf_path,
     VMMetadataUpgraderMixIn
 )
-from ubuntuone.platform.linux.credentials import get_creds_proxy
+from ubuntuone.platform.linux.credentials import CredentialsManagement
 from ubuntuone.platform.linux.logger import setup_filesystem_logging, get_filesystem_logger
 from ubuntuone.platform.linux.filesystem_notifications import FilesystemMonitor
 from ubuntuone.platform.linux.notification import Notification

=== modified file 'ubuntuone/platform/linux/credentials.py'
--- ubuntuone/platform/linux/credentials.py	2011-05-03 07:58:57 +0000
+++ ubuntuone/platform/linux/credentials.py	2011-05-24 18:23:27 +0000
@@ -15,6 +15,7 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 """Ubuntu One credentials management dbus service."""
 
 import os
@@ -23,6 +24,7 @@
 import gettext
 import ubuntu_sso
 
+from twisted.internet import defer
 from ubuntu_sso.credentials import HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY
 
 from ubuntuone.logger import (basic_formatter, logging,
@@ -236,71 +238,237 @@
             reply_handler=reply_handler, error_handler=error_handler)
 
 
-class CredentialsManagementProxy(object):
-    """Proxy that allows to work with the dbus api.
-
-    This proxy has been added to hide the exact details of
-    how the signals are connected. This allows the reuse of 
-    the CredentialsManagementTool in diff platforms.
+class CredentialsError(Exception):
+    """A general exception when hadling credentilas."""
+
+
+class CredentialsManagementTool(object):
+    """Wrapper to CredentialsManagement.
+
+    The goal of this class is to abstract the caller from calling the DBus
+    service implemented in the class CredentialsManagement.
+
     """
 
     def __init__(self):
-        """Create a new instance."""
+        self._cleanup_signals = []
+
+    def _get_creds_proxy(self):
+        """Get the CredentialsManagement dbus proxy."""
         bus = dbus.SessionBus()
         try:
             obj = bus.get_object(DBUS_BUS_NAME,
                                  DBUS_CREDENTIALS_PATH,
                                  follow_name_owner_changes=True)
-            self.proxy = dbus.Interface(obj, DBUS_CREDENTIALS_IFACE)
+            proxy = dbus.Interface(obj, DBUS_CREDENTIALS_IFACE)
         except:
             logger.exception('get_creds_proxy:')
             raise
 
-    def find_credentials(self, *args, **kwargs):
-        """Relay the find_credentials method."""
-        return self.proxy.find_credentials(*args, **kwargs)
-
-    def clear_credentials(self, *args, **kwargs):
-        """Relay the clear_credentials method."""
-        return self.proxy.clear_credentials(*args, **kwargs)
-
-    def store_credentials(self, *args, **kwargs):
-        """Relay the store_credentials method."""
-        return self.proxy.store_credentials(*args, **kwargs)
-
-    def register(self, *args, **kwargs):
-        """Relay the register method."""
-        return self.proxy.register(*args, **kwargs)
-
-    def login(self, *args, **kwargs):
-        """Relay the login method."""
-        return self.proxy.login(*args, **kwargs)
-
-    def register_to_credentials_stored(self, callback):
-        """Register to the CredentialsStored dbus signal."""
-        return self.proxy.connect_to_signal('CredentialsStored', callback)
-
-    def register_to_credentials_cleared(self, callback):
-        """Register to the CredentialsCleared dbus signal."""
-        return self.proxy.connect_to_signal('CredentialsCleared', callback)
-
-    def register_to_credentials_found(self, callback):
-        """Register to the CredentialsFound dbus signal."""
-        return self.proxy.connect_to_signal('CredentialsFound', callback)
-
-    def register_to_credentials_not_found(self, callback):
-        """Register to the CredentialsFound dbus signal."""
-        return self.proxy.connect_to_signal('CredentialsNotFound', callback)
-
-    def register_to_authorization_denied(self, callback):
-        """Register to the AuthorizationDenied dbus signal."""
-        return self.proxy.connect_to_signal('AuthorizationDenied', callback)
-
-    def register_to_credentials_error(self, callback):
-        """Register to the CredentialsError dbus signal."""
-        return self.proxy.connect_to_signal('CredentialsError', callback)
-
-
-def get_creds_proxy():
-    """Get the CredentialsManagement dbus proxy."""
-    return CredentialsManagementProxy()
+        return proxy
+
+    def cleanup(self, _):
+        """Disconnect all the DBus signals."""
+        for sig in self._cleanup_signals:
+            logger.debug('cleanup: removing signal match %r', sig)
+            sig.remove()
+
+        return _
+
+    @defer.inlineCallbacks
+    def find_credentials(self):
+        """Find credentials for Ubuntu One.
+
+        Return a deferred that, when fired, will return the credentials for
+        Ubuntu One for the current logged in user.
+
+        The credentials is a dictionary with both string keys and values. The
+        dictionary may be either empty if there are no credentials for the
+        user, or will hold five items as follow:
+
+        - "name"
+        - "token"
+        - "token_secret"
+        - "consumer_key"
+        - "consumer_secret"
+
+        """
+        d = defer.Deferred()
+        d.addBoth(self.cleanup)
+
+        proxy = self._get_creds_proxy()
+
+        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
+        self._cleanup_signals.append(sig)
+
+        sig = proxy.connect_to_signal('CredentialsNotFound',
+            lambda: d.callback({}))
+        self._cleanup_signals.append(sig)
+
+        sig = proxy.connect_to_signal('CredentialsError',
+            lambda error_dict: d.errback(CredentialsError(error_dict)))
+        self._cleanup_signals.append(sig)
+
+        done = defer.Deferred()
+        proxy.find_credentials(reply_handler=lambda: done.callback(None),
+            error_handler=lambda *a: done.errback(a))
+
+        yield done
+
+        result = yield d
+        defer.returnValue(result)
+
+    @defer.inlineCallbacks
+    def clear_credentials(self):
+        """Clear credentials for Ubuntu One.
+
+        Return a deferred that, when fired, will return no result but will
+        indicate that the Ubuntu One credentials for the current user were
+        removed from the local keyring.
+
+        """
+        d = defer.Deferred()
+        d.addBoth(self.cleanup)
+
+        proxy = self._get_creds_proxy()
+        sig = proxy.connect_to_signal('CredentialsCleared',
+            lambda: d.callback(None))
+        self._cleanup_signals.append(sig)
+
+        sig = proxy.connect_to_signal('CredentialsError',
+            lambda error_dict: d.errback(CredentialsError(error_dict)))
+        self._cleanup_signals.append(sig)
+
+        done = defer.Deferred()
+        proxy.clear_credentials(reply_handler=lambda: done.callback(None),
+            error_handler=lambda *a: done.errback(a))
+
+        yield done
+
+        yield d
+
+    @defer.inlineCallbacks
+    def store_credentials(self, token):
+        """Store credentials for Ubuntu One.
+
+        The parameter 'token' should be a dictionary that matches the
+        description of the result of 'find_credentials'.
+
+        Return a deferred that, when fired, will return no result but will
+        indicate that 'token' was stored in the local keyring as the new Ubuntu
+        One credentials for the current user.
+
+        """
+        d = defer.Deferred()
+        d.addBoth(self.cleanup)
+
+        proxy = self._get_creds_proxy()
+        sig = proxy.connect_to_signal('CredentialsStored',
+            lambda: d.callback(None))
+        self._cleanup_signals.append(sig)
+
+        sig = proxy.connect_to_signal('CredentialsError',
+            lambda error_dict: d.errback(CredentialsError(error_dict)))
+        self._cleanup_signals.append(sig)
+
+        done = defer.Deferred()
+        proxy.store_credentials(token,
+            reply_handler=lambda: done.callback(None),
+            error_handler=lambda *a: done.errback(a))
+
+        yield done
+
+        yield d
+
+    @defer.inlineCallbacks
+    def register(self, window_id=0):
+        """Register to Ubuntu One.
+
+        Return a deferred that, when fired, will return the credentials for
+        Ubuntu One for the current logged in user.
+
+        If there are no credentials for the current user, a GTK UI will be
+        opened to invite the user to register to Ubuntu One. This UI provides
+        options to either register (main screen) or login (secondary screen).
+
+        You can pass an optional 'window_id' parameter that will be used by the
+        GTK UI to be set transient for it.
+
+        The returned credentials will be either a non-empty dictionary like the
+        one described in 'find_credentials', or None. The latter indicates that
+        there were no credentials for the user in the local keyring and that
+        the user refused to register to Ubuntu One.
+
+        """
+        d = defer.Deferred()
+        d.addBoth(self.cleanup)
+
+        proxy = self._get_creds_proxy()
+
+        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
+        self._cleanup_signals.append(sig)
+
+        sig = proxy.connect_to_signal('AuthorizationDenied',
+            lambda: d.callback(None))
+        self._cleanup_signals.append(sig)
+
+        sig = proxy.connect_to_signal('CredentialsError',
+            lambda error_dict: d.errback(CredentialsError(error_dict)))
+        self._cleanup_signals.append(sig)
+
+        done = defer.Deferred()
+        proxy.register({'window_id': str(window_id)},
+            reply_handler=lambda: done.callback(None),
+            error_handler=lambda *a: done.errback(a))
+
+        yield done
+
+        result = yield d
+        defer.returnValue(result)
+
+    @defer.inlineCallbacks
+    def login(self, window_id=0):
+        """Login to Ubuntu One.
+
+        Return a deferred that, when fired, will return the credentials for
+        Ubuntu One for the current logged in user.
+
+        If there are no credentials for the current user, a GTK UI will be
+        opened to invite the user to login to Ubuntu One. This UI provides
+        options to either login (main screen) or retrieve password (secondary
+        screen).
+
+        You can pass an optional 'window_id' parameter that will be used by the
+        GTK UI to be set transient for it.
+
+        The returned credentials will be either a non-empty dictionary like the
+        one described in 'find_credentials', or None. The latter indicates that
+        there were no credentials for the user in the local keyring and that
+        the user refused to login to Ubuntu One.
+
+        """
+        d = defer.Deferred()
+        d.addBoth(self.cleanup)
+
+        proxy = self._get_creds_proxy()
+
+        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
+        self._cleanup_signals.append(sig)
+
+        sig = proxy.connect_to_signal('AuthorizationDenied',
+            lambda: d.callback(None))
+        self._cleanup_signals.append(sig)
+
+        sig = proxy.connect_to_signal('CredentialsError',
+            lambda error_dict: d.errback(CredentialsError(error_dict)))
+        self._cleanup_signals.append(sig)
+
+        done = defer.Deferred()
+        proxy.login({'window_id': str(window_id)},
+            reply_handler=lambda: done.callback(None),
+            error_handler=lambda *a: done.errback(a))
+
+        yield done
+
+        result = yield d
+        defer.returnValue(result)

=== removed file 'ubuntuone/platform/windows/credentials.py'
--- ubuntuone/platform/windows/credentials.py	2011-05-04 11:21:02 +0000
+++ ubuntuone/platform/windows/credentials.py	1970-01-01 00:00:00 +0000
@@ -1,178 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Author: Manuel de la Pena<[e-mail]>
-#
-# Copyright 2011 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/>.
-"""Ubuntu One credentials management IPC service."""
-
-import os
-
-import gettext
-
-from ubuntu_sso.main.windows import UbuntuSSOClient
-from ubuntu_sso.credentials import HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY
-from twisted.internet import defer
-
-from ubuntuone.logger import (basic_formatter, logging,
-    CustomRotatingFileHandler, LOGFOLDER)
-from ubuntuone.clientdefs import GETTEXT_PACKAGE
-
-
-Q_ = lambda string: gettext.dgettext(GETTEXT_PACKAGE, string)
-NO_OP = lambda *args, **kwargs: None
-
-LOG_LEVEL = logging.DEBUG
-path = os.path.join(LOGFOLDER, 'credentials.log')
-MAIN_HANDLER = CustomRotatingFileHandler(path)
-MAIN_HANDLER.setFormatter(basic_formatter)
-MAIN_HANDLER.setLevel(LOG_LEVEL)
-
-logger = logging.getLogger("ubuntuone.credentials")
-logger.setLevel(LOG_LEVEL)
-logger.addHandler(MAIN_HANDLER)
-
-APP_NAME = "Ubuntu One"
-TC_URL = "https://one.ubuntu.com/terms/"
-PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
-DESCRIPTION = Q_('Ubuntu One requires an Ubuntu Single Sign On (SSO) account. '
-                 'This process will allow you to create a new account, '
-                 'if you do not yet have one.')
-
-
-class CredentialsManagement(object):
-    """Object that manages Ubuntu One credentials."""
-
-    def __init__(self):
-        super(CredentialsManagement, self).__init__()
-        self._sso_proxy = None
-        self._registered_to_signals = False
-
-    @defer.inlineCallbacks
-    def _get_sso_proxy(self):
-        if not self._sso_proxy:
-            client = UbuntuSSOClient()
-            client = yield client.connect()
-            self._sso_proxy = client
-        defer.returnValue(self._sso_proxy.cred_management)
-    
-    @defer.inlineCallbacks
-    def _register_to_signals(self):
-        if not self._registered_to_signals:
-            self._registered_to_signals = True
-            proxy = yield self._get_sso_proxy()
-            yield proxy.register_to_signals()
-
-    @defer.inlineCallbacks
-    def find_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Ask the Ubuntu One credentials."""
-        sso_proxy = yield self._get_sso_proxy()
-        sso_proxy.find_credentials(APP_NAME, {})
-
-    @defer.inlineCallbacks
-    def clear_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Clear the Ubuntu One credentials."""
-        sso_proxy = yield self._get_sso_proxy()
-        sso_proxy.clear_credentials(APP_NAME, {})
-
-    @defer.inlineCallbacks
-    def store_credentials(self, credentials,
-                          reply_handler=NO_OP, error_handler=NO_OP):
-        """Store the token for Ubuntu One application."""
-        sso_proxy = yield self._get_sso_proxy()
-        sso_proxy.store_credentials(APP_NAME, credentials)
-
-    @defer.inlineCallbacks
-    def register(self, args, reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else prompt to register to Ubuntu One."""
-        sso_proxy = yield self._get_sso_proxy()
-        params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
-                  PING_URL_KEY: PING_URL}
-        params.update(args)
-        sso_proxy.register(APP_NAME, params)
-
-    @defer.inlineCallbacks
-    def login(self, args, reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else prompt to login to Ubuntu One."""
-        sso_proxy = yield self._get_sso_proxy()
-        params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
-                  PING_URL_KEY: PING_URL}
-        params.update(args)
-        sso_proxy.login(APP_NAME, params)
-
-    @defer.inlineCallbacks
-    def register_to_credentials_stored(self, callback):
-        """Register to the CredentialsStored dbus signal."""
-        logger.info('%s: Registering to credentials stored "%s".',
-                    self.__class__.__name__, callback)
-        sso_proxy = yield self._get_sso_proxy()
-        yield self._register_to_signals()
-        sso_proxy.on_credentials_stored_cb = callback
-        defer.returnValue(sso_proxy.on_credentials_stored_cb)
-
-    @defer.inlineCallbacks
-    def register_to_credentials_cleared(self, callback):
-        """Register to the CredentialsCleared dbus signal."""
-        logger.info('%s: Registering to credentials stored "%s".',
-                    self.__class__.__name__, callback)
-        sso_proxy = yield self._get_sso_proxy()
-        yield self._register_to_signals()
-        sso_proxy.on_credentials_cleared_cb = callback
-        defer.returnValue(sso_proxy.on_credentials_cleared_cb)
-
-    @defer.inlineCallbacks
-    def register_to_credentials_found(self, callback):
-        """Register to the CredentialsFound dbus signal."""
-        logger.info('%s: Registering to credentials found"%s".',
-                    self.__class__.__name__, callback)
-        sso_proxy = yield self._get_sso_proxy()
-        yield self._register_to_signals()
-        sso_proxy.on_credentials_found_cb = callback
-        defer.returnValue(sso_proxy.on_credentials_found_cb)
-
-    @defer.inlineCallbacks
-    def register_to_credentials_not_found(self, callback):
-        """Register to the CredentialsFound dbus signal."""
-        logger.info('%s: Registering to credentials NOT found"%s".',
-                    self.__class__.__name__, callback)
-        sso_proxy = yield self._get_sso_proxy()
-        yield self._register_to_signals()
-        sso_proxy.on_credentials_not_found_cb = callback
-        defer.returnValue(sso_proxy.on_credentials_not_found_cb)
-
-    @defer.inlineCallbacks
-    def register_to_authorization_denied(self, callback):
-        """Register to the AuthorizationDenied dbus signal."""
-        logger.info('%s: Registering to credentials denied"%s".',
-                    self.__class__.__name__, callback)
-        sso_proxy = yield self._get_sso_proxy()
-        yield self._register_to_signals()
-        sso_proxy.on_authorization_denied_cb = callback
-        defer.returnValue(sso_proxy.on_authorization_denied_cb)
-
-    @defer.inlineCallbacks
-    def register_to_credentials_error(self, callback):
-        """Register to the CredentialsError dbus signal."""
-        logger.info('%s: Registering to credentials error"%s".',
-                    self.__class__.__name__, callback)
-        sso_proxy = yield self._get_sso_proxy()
-        yield self._register_to_signals()
-        sso_proxy.on_credentials_error_cb = callback
-        defer.returnValue(sso_proxy.on_credentials_error_cb)
-
-
-def get_creds_proxy():
-    """Get the CredentialsManagement dbus proxy."""
-    return CredentialsManagement()