Merge lp:~mandel/ubuntuone-client/provide_credentials_management into lp:ubuntuone-client

[Manuel de la Peña]

This branch fixed the issue where windows does not have credential management code. This branch does the following:

* Refactor the CredentialsManagementTool so that it can be used by other platforms.
* Implemented the CredentialsManagement code for Windows.

This branch fixed the issue where windows does not have credential management code. This branch does the following:

* Refactor the CredentialsManagementTool so that it can be used by other platforms.
* Implemented the CredentialsManagement code for Windows.

This branch might break control panel (to be confirmed) and has to be tested in both platforms (windows/linux)

On Linux:
$ ./autogen
$ make check

On Windows:

python C:\Python27\Scripts\u1trial tests\platform\windows\test_credentials

[Shane Fagan (shanepatrickfagan)]

Passes tests and nothing big pops out in the code

review: Approve

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2011-02-21 23:16:03 +0000
+++ po/POTFILES.in	2011-05-03 09:17:06 +0000
@@ -1,6 +1,7 @@
 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-02-15 20:32:42 +0000
+++ tests/platform/linux/test_credentials.py	2011-05-03 09:17:06 +0000
@@ -25,12 +25,11 @@
 from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.platform.linux.credentials import (dbus, logger, logging,
-    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,
+    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,
 )
+from ubuntuone.credentials import CredentialsManagementTool, CredentialsError
 
 FAKED_CREDENTIALS = {
     'consumer_key': 'faked_consumer_key',

=== added file 'tests/platform/windows/test_credentials.py'
--- tests/platform/windows/test_credentials.py	1970-01-01 00:00:00 +0000
+++ tests/platform/windows/test_credentials.py	2011-05-03 09:17:06 +0000
@@ -0,0 +1,155 @@
+#!/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.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, {}, reply_handler=reply_handler,
+                                    error_handler=error_handler)
+        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, {}, reply_handler=reply_handler,
+                                     error_handler=error_handler)
+        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,
+            reply_handler=reply_handler, error_handler=error_handler)
+        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,
+            reply_handler=reply_handler, error_handler=error_handler)
+        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,
+            reply_handler=reply_handler, error_handler=error_handler)
+        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.on_credentials_stored_cb = callback
+        self.proxy.on_credentials_stored_cb
+        self.mocker.result(callback)
+        self.mocker.replay()
+        self.assertIs(callback,
+                      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.on_credentials_cleared_cb = callback
+        self.proxy.on_credentials_cleared_cb
+        self.mocker.result(callback)
+        self.mocker.replay()
+        self.assertIs(callback,
+                    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.on_credentials_found_cb = callback
+        self.proxy.on_credentials_found_cb
+        self.mocker.result(callback)
+        self.mocker.replay()
+        self.assertIs(callback,
+                      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.on_credentials_not_found_cb = callback
+        self.proxy.on_credentials_not_found_cb
+        self.mocker.result(callback)
+        self.mocker.replay()
+        self.assertIs(callback,
+                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.on_authorization_denied_cb = callback
+        self.proxy.on_authorization_denied_cb
+        self.mocker.result(callback)
+        self.mocker.replay()
+        self.assertIs(callback,
+                    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.on_credentials_error_cb = callback
+        self.proxy.on_credentials_error_cb
+        self.mocker.result(callback)
+        self.mocker.replay()
+        self.assertIs(callback,
+                      self.management.register_to_credentials_error(callback))

=== added file 'tests/test_credentials.py'
--- tests/test_credentials.py	1970-01-01 00:00:00 +0000
+++ tests/test_credentials.py	2011-05-03 09:17:06 +0000
@@ -0,0 +1,99 @@
+#!/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)
+

=== added file 'ubuntuone/credentials.py'
--- ubuntuone/credentials.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/credentials.py	2011-05-03 09:17:06 +0000
@@ -0,0 +1,255 @@
+#!/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-03-30 16:17:37 +0000
+++ ubuntuone/platform/linux/__init__.py	2011-05-03 09:17:06 +0000
@@ -51,7 +51,7 @@
     get_udf_path,
     VMMetadataUpgraderMixIn
 )
-from ubuntuone.platform.linux.credentials import CredentialsManagement
+from ubuntuone.platform.linux.credentials import get_creds_proxy
 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-02-24 14:07:32 +0000
+++ ubuntuone/platform/linux/credentials.py	2011-05-03 09:17:06 +0000
@@ -15,7 +15,6 @@
 #
 # 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
@@ -24,7 +23,6 @@
 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,
@@ -238,237 +236,71 @@
             reply_handler=reply_handler, error_handler=error_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.
-
+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.
     """
 
     def __init__(self):
-        self._cleanup_signals = []
-
-    def _get_creds_proxy(self):
-        """Get the CredentialsManagement dbus proxy."""
+        """Create a new instance."""
         bus = dbus.SessionBus()
         try:
             obj = bus.get_object(DBUS_BUS_NAME,
                                  DBUS_CREDENTIALS_PATH,
                                  follow_name_owner_changes=True)
-            proxy = dbus.Interface(obj, DBUS_CREDENTIALS_IFACE)
+            self.proxy = dbus.Interface(obj, DBUS_CREDENTIALS_IFACE)
         except:
             logger.exception('get_creds_proxy:')
             raise
 
-        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)
+    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()

=== added file 'ubuntuone/platform/windows/credentials.py'
--- ubuntuone/platform/windows/credentials.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/platform/windows/credentials.py	2011-05-03 09:17:06 +0000
@@ -0,0 +1,131 @@
+#!/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, proxy, *args, **kwargs):
+        super(CredentialsManagement, self).__init__(*args, **kwargs)
+        self.sso_proxy = proxy
+
+    def find_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
+        """Ask the Ubuntu One credentials."""
+        self.sso_proxy.find_credentials(APP_NAME, {},
+            reply_handler=reply_handler, error_handler=error_handler)
+
+
+    def clear_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
+        """Clear the Ubuntu One credentials."""
+        self.sso_proxy.clear_credentials(APP_NAME, {},
+            reply_handler=reply_handler, error_handler=error_handler)
+
+    def store_credentials(self, credentials,
+                          reply_handler=NO_OP, error_handler=NO_OP):
+        """Store the token for Ubuntu One application."""
+        self.sso_proxy.store_credentials(APP_NAME, credentials,
+            reply_handler=reply_handler, error_handler=error_handler)
+
+    def register(self, args, reply_handler=NO_OP, error_handler=NO_OP):
+        """Get credentials if found else prompt to register to Ubuntu One."""
+        params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
+                  PING_URL_KEY: PING_URL}
+        params.update(args)
+        self.sso_proxy.register(APP_NAME, params,
+            reply_handler=reply_handler, error_handler=error_handler)
+
+    def login(self, args, reply_handler=NO_OP, error_handler=NO_OP):
+        """Get credentials if found else prompt to login to Ubuntu One."""
+        params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
+                  PING_URL_KEY: PING_URL}
+        params.update(args)
+        self.sso_proxy.login(APP_NAME, params,
+            reply_handler=reply_handler, error_handler=error_handler)
+
+    def register_to_credentials_stored(self, callback):
+        """Register to the CredentialsStored dbus signal."""
+        self.sso_proxy.on_credentials_stored_cb = callback
+        return self.sso_proxy.on_credentials_stored_cb
+
+    def register_to_credentials_cleared(self, callback):
+        """Register to the CredentialsCleared dbus signal."""
+        self.sso_proxy.on_credentials_cleared_cb = callback
+        return self.sso_proxy.on_credentials_cleared_cb
+
+    def register_to_credentials_found(self, callback):
+        """Register to the CredentialsFound dbus signal."""
+        self.sso_proxy.on_credentials_found_cb = callback
+        return self.sso_proxy.on_credentials_found_cb
+
+    def register_to_credentials_not_found(self, callback):
+        """Register to the CredentialsFound dbus signal."""
+        self.sso_proxy.on_credentials_not_found_cb = callback
+        return self.sso_proxy.on_credentials_not_found_cb
+
+    def register_to_authorization_denied(self, callback):
+        """Register to the AuthorizationDenied dbus signal."""
+        self.sso_proxy.on_authorization_denied_cb = callback
+        return self.sso_proxy.on_authorization_denied_cb
+
+    def register_to_credentials_error(self, callback):
+        """Register to the CredentialsError dbus signal."""
+        self.sso_proxy.on_credentials_error_cb = callback
+        return self.sso_proxy.on_credentials_error_cb
+
+
[e-mail]
+def get_creds_proxy():
+    """Get the CredentialsManagement dbus proxy."""
+    client = UbuntuSSOClient()
+    client = yield client.connect()
+    defer.returnValue(CredentialsManagement(client.cred_management))