Merge lp:~alecu/ubuntu-sso-client/credentials-interface into lp:ubuntu-sso-client

[Alejandro J. Cura]

DBus interface for getting the credentials from the keyring, or show a dialog to login/register

DBus interface for getting the credentials from the keyring, or show a dialog to login/register

[lp:~alecu/ubuntu-sso-client/credentials-interface]

564. By Alejandro J. Cura on 2010-08-05

nessita's eagle eye spotted this pring

[Natalia Bidart (nataliabidart)]

keyring.py needs tests but they are coming on a different branch.

review: Approve

[lp:~alecu/ubuntu-sso-client/credentials-interface]

565. By Alejandro J. Cura on 2010-08-06

do not store the keyring tokens yet

[Rodrigo Moya (rodrigo-moya)]

Looks good

review: Approve

=== modified file 'bin/ubuntu-sso-login'
--- bin/ubuntu-sso-login	2010-08-03 20:03:44 +0000
+++ bin/ubuntu-sso-login	2010-08-06 02:49:40 +0000
@@ -30,12 +30,13 @@
 
 from dbus.mainloop.glib import DBusGMainLoop
 
-from ubuntu_sso import DBUS_IFACE_AUTH_NAME, DBUS_BUS_NAME
-from ubuntu_sso.main import Login, SSOLogin
+from ubuntu_sso import DBUS_IFACE_AUTH_NAME, DBUS_BUS_NAME, DBUS_CRED_PATH
+from ubuntu_sso.main import Login, SSOLogin, SSOCredentials
 
 from ubuntu_sso.logger import setupLogging
 logger = setupLogging("ubuntu-sso-login")
 
+gtk.gdk.threads_init()
 DBusGMainLoop(set_as_default=True)
 
 _ = gettext.gettext
@@ -235,5 +236,9 @@
                                              bus=dbus.SessionBus()))
     ssoLogin = SSOLogin(dbus.service.BusName(DBUS_BUS_NAME,
                                              bus=dbus.SessionBus()))
+    SSOCredentials(dbus.service.BusName(DBUS_BUS_NAME,
+                                        bus=dbus.SessionBus()),
+                   object_path=DBUS_CRED_PATH)
+
     manager = LoginMain()
     manager.main()

=== modified file 'ubuntu_sso/__init__.py'
--- ubuntu_sso/__init__.py	2010-08-03 15:02:15 +0000
+++ ubuntu_sso/__init__.py	2010-08-06 02:49:40 +0000
@@ -19,6 +19,7 @@
 DBUS_PATH_AUTH = "/"
 DBUS_BUS_NAME = "com.ubuntu.sso"
 DBUS_PATH = "/sso"
+DBUS_CRED_PATH = "/credentials"
 DBUS_IFACE_AUTH_NAME = "com.ubuntu.sso"
 DBUS_IFACE_USER_NAME = "com.ubuntu.sso.UserManagement"
 DBUS_IFACE_CRED_NAME = "com.ubuntu.sso.ApplicationCredentials"

=== added file 'ubuntu_sso/keyring.py'
--- ubuntu_sso/keyring.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/keyring.py	2010-08-06 02:49:40 +0000
@@ -0,0 +1,111 @@
+# Copyright (C) 2010 Canonical
+#
+# Authors:
+#  Andrew Higginson
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 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, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+import gnomekeyring
+
+from urllib import urlencode
+from urlparse import parse_qs
+
+class Keyring(object):
+
+    KEYRING_NAME = "login"
+
+    def __init__(self, app_name):
+
+        if not gnomekeyring.is_available():
+            raise gnomekeyring.NoKeyringDaemonError
+        self.app_name = app_name
+
+    def _create_keyring(self, name):
+        """
+        Creates a keyring, if it already exists,
+        it does nothing
+        """
+        keyring_names = gnomekeyring.list_keyring_names_sync()
+        if not name in keyring_names:
+            gnomekeyring.create_sync(name)
+
+    def _item_exists(self, sync, name):
+        """
+        Returns whether a named item exists in a
+        named keyring
+        """
+        return self._get_item_id_from_name(sync, name) != None
+
+    def _get_item_id_from_name(self, sync, name):
+        """
+        Returns the ID for a named item
+        """
+        for item_id in gnomekeyring.list_item_ids_sync(sync):
+            item_info = gnomekeyring.item_get_info_sync(sync, item_id)
+            display_name = item_info.get_display_name()
+            if display_name == name:
+                return item_id
+        return None
+
+    def _get_item_info_from_name(self, sync, name):
+        """
+        Returns the ID for a named item
+        """
+        for item_id in gnomekeyring.list_item_ids_sync(sync):
+            item_info = gnomekeyring.item_get_info_sync(sync, item_id)
+            display_name = item_info.get_display_name()
+            if display_name == name:
+                return item_info
+        return None
+
+    def set_ubuntusso_attr(self, attr):
+        """
+        Sets the attributes of the Ubuntu SSO item
+        """
+        # Creates the secret from the attributes
+        secret = urlencode(attr)
+
+        # Create the keyring
+        self._create_keyring(self.KEYRING_NAME)
+
+        # If the item already exists, delete it
+        if self._item_exists(self.KEYRING_NAME, self.app_name):
+            item_id = self._get_item_id_from_name(self.KEYRING_NAME,
+                                                  self.app_name)
+            gnomekeyring.item_delete_sync(self.KEYRING_NAME, item_id)
+
+        # Add our SSO item
+        gnomekeyring.item_create_sync(self.KEYRING_NAME,
+                gnomekeyring.ITEM_GENERIC_SECRET, self.app_name, {},
+                secret, True)
+
+    def get_ubuntusso_attr(self):
+        """
+        Returns the secret of the SSO item in a dictionary
+        """
+        # If we have no attributes, return None
+        if self._get_item_info_from_name(self.KEYRING_NAME,
+                                         self.app_name) == None:
+            return None
+        secret = self._get_item_info_from_name(self.KEYRING_NAME,
+                                               self.app_name).get_secret()
+        return parse_qs(secret)
+
+if __name__ == "__main__":
+    SSO_ITEM_NAME = "Software Center UbuntuSSO token"
+    keyring = Keyring(SSO_ITEM_NAME)
+    keyring.set_ubuntusso_attr({"ha":"hehddddeff", "hi":"hggehes", "ho":"he"})
+    print keyring.get_ubuntusso_attr()
+
+

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-08-05 02:24:33 +0000
+++ ubuntu_sso/main.py	2010-08-06 02:49:40 +0000
@@ -34,6 +34,7 @@
 
 import dbus.service
 import gobject
+import gtk
 import pynotify
 
 from dbus.mainloop.glib import DBusGMainLoop
@@ -43,20 +44,18 @@
 from lazr.restfulclient.resource import ServiceRoot
 from oauth.oauth import OAuthToken
 
+from keyring import Keyring
 from ubuntu_sso import (DBUS_IFACE_AUTH_NAME,
                         DBUS_IFACE_USER_NAME,
                         DBUS_IFACE_CRED_NAME,
+                        DBUS_CRED_PATH,
                         DBUS_BUS_NAME)
 from ubuntu_sso.config import get_config
 
 from ubuntu_sso.logger import setupLogging
 logger = setupLogging("ubuntu_sso.main")
 
-
 DBusGMainLoop(set_as_default=True)
-dbus.mainloop.glib.threads_init()
-gobject.threads_init()
-
 # Disable the invalid name warning, as we have a lot of DBus style names
 # pylint: disable-msg=C0103
 
@@ -92,6 +91,21 @@
     """The email token is not valid."""
 
 
+def keyring_store_token(token_name, token):
+    """Store the credentials in the keyring."""
+    attr = {"token": token}
+    Keyring(token_name).set_ubuntusso_attr(attr)
+
+
+def keyring_get_token(token_name):
+    """Get the credentials from the keyring or None if not there."""
+    d = Keyring(token_name).get_ubuntusso_attr()
+    if d is not None:
+        return d["token"]
+    else:
+        return None
+
+
 class SSOLoginProcessor(object):
     """Login and register users using the Ubuntu Single Sign On service."""
 
@@ -208,7 +222,7 @@
         try:
             result_cb(f())
         except Exception, e:
-            logger.error(e)
+            logger.exception(e)
             error_cb(str(e))
     threading.Thread(target=_in_thread).start()
 
@@ -230,9 +244,6 @@
         return self.sso_login_processor_class(
                                     sso_service_class=self.sso_service_class)
 
-    # ========================================
-    # DBUS_IFACE_USER_NAME methods and signals
-
     # generate_capcha signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
     def CaptchaGenerated(self, result):
@@ -285,7 +296,10 @@
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            return self.processor().login(email, password, token_name)
+            token = self.processor().login(email, password, token_name)
+            # XXX: will be fixed in upcoming branch
+            #keyring_store_token(token_name, token)
+            return "Ok"
         return blocking(f, self.LoggedIn, self.LoginError)
 
     # validate_email signals
@@ -307,8 +321,9 @@
                                                token_name, email_token)
         return blocking(f, self.EmailValidated, self.EmailValidationError)
 
-    # ----------------------------------------
-    # DBUS_IFACE_CRED_NAME methods and signals
+
+class SSOCredentials(dbus.service.Object):
+    """DBus object that gets credentials, and login/registers if needed."""
 
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
     def CredentialsFound(self, result):
@@ -319,17 +334,53 @@
         """Signal thrown when there is a problem finding the credentials."""
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature="s", out_signature="")
-    def find_credentials(self, application_name):
-        # XXX: placeholder; coming in the following branch
-        pass
+                         in_signature="s", out_signature="s")
+    def find_credentials(self, token_name):
+        """Get the credentials from the keyring or '' if not there."""
+        token = keyring_get_token(token_name)
+        if token is None:
+            return ""
+        else:
+            return token
+
+    def _response_cb(self, dialog, response, token_name):
+        """Handles the response from the UI dialog."""
+        # XXX: to be replaced in the following branch
+        try:
+            token = "token%d" % response
+            keyring_store_token(token_name, token)
+            self.CredentialsFound(token)
+        except Exception, e:
+            self.CredentialsError(str(e))
+        dialog.destroy()
+
+    def _show_login_or_register_ui(self, token_name, terms_and_conditions_url):
+        """Shows the UI so the user can login or register."""
+        # XXX: to be replaced in the following branch
+        try:
+            dialog = gtk.MessageDialog(None,
+                 gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_INFO,
+                          gtk.BUTTONS_CLOSE, terms_and_conditions_url)
+            dialog.connect("response", self._response_cb, token_name)
+            dialog.show()
+        except Exception, e:
+            self.CredentialsError(str(e))
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
                          in_signature="ss", out_signature="")
-    def login_or_register_to_get_credentials(self, application_name,
+    def login_or_register_to_get_credentials(self, token_name,
                                         terms_and_conditions_url):
-        # XXX: placeholder; coming in the following branch
-        pass
+
+        """Get credentials if found else prompt to login or register first."""
+        try:
+            token = keyring_get_token(token_name)
+            if token is None:
+                gobject.idle_add(self._show_login_or_register_ui, token_name,
+                                 terms_and_conditions_url)
+            else:
+                self.CredentialsFound(token)
+        except Exception, e:
+            self.CredentialsError(str(e))
 
 
 class LoginProcessor:
@@ -558,6 +609,8 @@
 
 def main():
     """Start everything"""
+    dbus.mainloop.glib.threads_init()
+    gobject.threads_init()
     logger.debug("Starting up at %s", time.asctime())
     logger.debug("Installing the Twisted glib2reactor")
     from twisted.internet import glib2reactor  # for non-GUI apps
@@ -569,6 +622,9 @@
                                bus=dbus.SessionBus()))
     SSOLogin(dbus.service.BusName(DBUS_BUS_NAME,
                                bus=dbus.SessionBus()))
+    SSOCredentials(dbus.service.BusName(DBUS_BUS_NAME,
+                               bus=dbus.SessionBus()),
+                   object_path=DBUS_CRED_PATH)
     # cleverness here to say:
     # am I already running (bound to this d-bus name)?
     # if so, send a signal to the already running instance

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-08-05 02:24:33 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-08-06 02:49:40 +0000
@@ -46,12 +46,6 @@
 EMAIL_TOKEN = 'B2Pgtf'
 
 
-def process_pending():
-    """Process all the pending GTK events."""
-    while gtk.events_pending():
-        gtk.main_iteration()
-
-
 class FakedSSOBackend(object):
     """Fake a SSO Backend (acts as a dbus.Interface as well)."""
 
@@ -149,7 +143,6 @@
         """Grab focus on widget, if None use self.entry."""
         direction = 'in' if focus_in else 'out'
         self.entry.emit('focus-%s-event' % direction, None)
-        process_pending()
 
     def assert_correct_label(self):
         """Check that the entry has the correct label."""
@@ -212,7 +205,6 @@
         self.grab_focus()  # grab focus
 
         self.entry.set_text('        ')  # add empty text to the entry
-        process_pending()
 
         self.grab_focus(focus_in=False)  # loose focus
 
@@ -227,7 +219,6 @@
         self.grab_focus()  # grab focus
 
         self.entry.set_text(expected)  # add empty text to the entry
-        process_pending()
 
         self.grab_focus(focus_in=False)  # loose focus
 
@@ -241,7 +232,6 @@
         self.grab_focus()  # grab focus
 
         self.entry.set_text(expected)  # add text to the entry
-        process_pending()
 
         self.grab_focus(focus_in=False)  # loose focus
         self.grab_focus()  # grab focus again!

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-08-04 00:10:14 +0000
+++ ubuntu_sso/tests/test_main.py	2010-08-06 02:49:40 +0000
@@ -31,7 +31,8 @@
 from ubuntu_sso import config
 from ubuntu_sso.main import (
     AuthenticationError, BadRealmError, blocking, EmailTokenError,
-    InvalidEmailError, InvalidPasswordError, SSOLogin,
+    InvalidEmailError, InvalidPasswordError, SSOLogin, SSOCredentials,
+    keyring_get_token, keyring_store_token,
     LoginProcessor, SSOLoginProcessor, RegistrationError)
 
 
@@ -110,7 +111,7 @@
         self.accounts = FakedAccounts()
 
 
-class SSOLoginProcessorTestCase(TestCase):
+class SSOLoginProcessorTestCase(TestCase, MockerTestCase):
     """Test suite for the SSO login processor."""
 
     def setUp(self):
@@ -436,14 +437,14 @@
         email = "sample email"
         password = "sample password"
         token_name = "sample token_name"
-        expected_result = "expected result"
+        sample_result = {"sample": "tokens"}
         self.create_mock_processor().login(email, password, token_name)
-        self.mocker.result(expected_result)
+        self.mocker.result(sample_result)
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
 
         def verify(result):
-            self.assertEqual(result, expected_result)
+            self.assertEqual(result, "Ok")
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
@@ -556,8 +557,148 @@
             raise BlockingSampleException(expected_error_message)
 
         def verify(error):
-            self.assertEquals(error, expected_error_message)
+            self.assertEqual(error, expected_error_message)
             d.callback("Ok")
 
         blocking(f, d.errback, verify)
         return d
+
+
+class KeyringTokenTestCase(MockerTestCase):
+    """Checks the functions that access the keyring."""
+
+    def test_keyring_store_token(self):
+        """Verify the method that stores tokens."""
+        token_name = "token_name"
+        token_value = "token value"
+        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
+        mockKeyringClass(token_name)
+        mockKeyring = self.mocker.mock()
+        self.mocker.result(mockKeyring)
+        mockKeyring.set_ubuntusso_attr({"token": token_value})
+        self.mocker.replay()
+
+        keyring_store_token(token_name, token_value)
+
+    def test_keyring_get_token(self):
+        """The method returns the right token."""
+        token_name = "token_name"
+        token_value = "token value"
+        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
+        mockKeyringClass(token_name)
+        mockKeyring = self.mocker.mock()
+        self.mocker.result(mockKeyring)
+        mockKeyring.get_ubuntusso_attr()
+        self.mocker.result({"token": token_value})
+        self.mocker.replay()
+
+        token = keyring_get_token(token_name)
+        self.assertEqual(token, token_value)
+
+    def test_keyring_get_token_not_found(self):
+        """The method returns None when the token is not found."""
+        token_name = "token_name"
+        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
+        mockKeyringClass(token_name)
+        mockKeyring = self.mocker.mock()
+        self.mocker.result(mockKeyring)
+        mockKeyring.get_ubuntusso_attr()
+        self.mocker.result(None)
+        self.mocker.replay()
+
+        token = keyring_get_token(token_name)
+        self.assertEqual(token, None)
+
+
+class RegisterSampleException(Exception):
+    """A mock exception thrown just when testing."""
+
+
+class CredentialsTestCase(TestCase, MockerTestCase):
+    """Tests for the credentials related DBus methods."""
+
+    def test_find_credentials(self):
+        """find_credentials immediately returns the token when found."""
+        expected_token = "expected token"
+        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_token")
+        kgt(ARGS)
+        self.mocker.result(expected_token)
+        self.mocker.replay()
+
+        client = SSOCredentials(self.mocker.mock())
+        token = client.find_credentials("token_name")
+        self.assertEqual(token, expected_token)
+
+    def test_credentials_not_found(self):
+        """find_credentials immediately returns '' when no token found."""
+        expected_token = ""
+        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_token")
+        kgt(ARGS)
+        self.mocker.result(None)
+        self.mocker.replay()
+
+        client = SSOCredentials(self.mocker.mock())
+        token = client.find_credentials("token_name")
+        self.assertEqual(token, expected_token)
+
+    def test_login_or_register(self):
+        """login_or_register_... throws the signal when token is found."""
+        expected_token = "expected token"
+        d = Deferred()
+
+        def verify(result):
+            self.assertEqual(result, expected_token)
+            d.callback("ok")
+
+        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_token")
+        kgt(ARGS)
+        self.mocker.result(expected_token)
+        self.mocker.replay()
+        client = SSOCredentials(self.mocker.mock())
+        self.patch(client, "_show_login_or_register_ui", self.fail)
+        self.patch(client, "CredentialsFound", verify)
+        self.patch(client, "CredentialsError", self.fail)
+        client.login_or_register_to_get_credentials("token name", "tcurl")
+        return d
+
+    def test_login_or_register_not_found(self):
+        """Check that login_or_register_... opens the ui when no cred found."""
+        token_name = "token name"
+        d = Deferred()
+
+        def verify(result, *a):
+            self.assertEqual(result, token_name)
+            d.callback("ok")
+
+        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_token")
+        kgt(ARGS)
+        self.mocker.result(None)
+        self.mocker.replay()
+
+        client = SSOCredentials(self.mocker.mock())
+        self.patch(client, "_show_login_or_register_ui", verify)
+        self.patch(client, "CredentialsFound", self.fail)
+        self.patch(client, "CredentialsError", self.fail)
+        client.login_or_register_to_get_credentials(token_name, "tcurl")
+        return d
+
+    def test_login_or_register_problem(self):
+        """login_or_register_... returns the right signal on error."""
+        expected_error = "Sample Error - not for resale"
+        d = Deferred()
+
+        def verify(result, *a):
+            self.assertEqual(result, expected_error)
+            d.callback("ok")
+
+        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_token")
+        kgt(ARGS)
+        self.mocker.throw(RegisterSampleException(expected_error))
+        self.mocker.replay()
+
+        client = SSOCredentials(self.mocker.mock())
+        self.patch(client, "_show_login_or_register_ui", self.fail)
+        self.patch(client, "CredentialsFound", self.fail)
+        self.patch(client, "CredentialsError", verify)
+        client.login_or_register_to_get_credentials("token name", "tcurl")
+        return d