Merge lp:~mvo/software-center/login-cleanup into lp:software-center

[Michael Vogt]

Cleanup around the login backend code to make the naming better and to move the actual implementation of the login backend into softwarecenter.backend.login_impl (to be in sync what is done for other interfaces/implementations).

Plus it removes a unused launchpad interfaces for private ppas that never got used nor does it work correctly.

[lp:~mvo/software-center/login-cleanup]

3190. By Michael Vogt on 2012-09-14

fix tests

3191. By Michael Vogt on 2012-09-14

merged from merge-prev-purchases-lp969273

[Michael Vogt (mvo)]

Should just be rename/reshuffle but still a careful look will be good.

[lp:~mvo/software-center/login-cleanup]

3192. By Michael Vogt on 2012-09-14

pep8 fixes

[Gary Lasker (gary-lasker)]

review: Approve

=== modified file 'software-center'
--- software-center	2012-09-06 10:19:43 +0000
+++ software-center	2012-09-14 14:02:22 +0000
@@ -62,11 +62,6 @@
     parser.add_option("--display-navlog", action="store_true",
                       help="display a navigation history log (useful for debugging)", 
                       default=False)
-    # FIXME:  REMOVE THIS option once launchpad integration is enabled
-    #         by default
-    parser.add_option("--enable-lp", action="store_true",
-                      help="enable launchpad integration (for development use)", 
-                      default=False)
     parser.add_option("--disable-buy", action="store_true",
                       help="disable support to buy software",
                       default=False)

=== removed file 'softwarecenter/backend/launchpad.py'
--- softwarecenter/backend/launchpad.py	2012-08-07 13:15:08 +0000
+++ softwarecenter/backend/launchpad.py	1970-01-01 00:00:00 +0000
@@ -1,341 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-
-# Copyright (C) 2009 Canonical
-#
-# Authors:
-#  Michael Vogt
-#
-# 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 os
-from gi.repository import GObject
-import time
-import threading
-
-import logging
-from softwarecenter.distro import get_distro
-
-from launchpadlib.launchpad import Launchpad
-from launchpadlib.credentials import RequestTokenAuthorizationEngine
-from launchpadlib.uris import LPNET_SERVICE_ROOT
-from softwarecenter.paths import SOFTWARE_CENTER_CACHE_DIR
-
-# py3 compat
-try:
-    from queue import Queue
-    Queue  # pyflakes
-except ImportError:
-    from Queue import Queue
-
-from login import LoginBackend
-
-# LP to use
-SERVICE_ROOT = LPNET_SERVICE_ROOT
-
-# internal
-
-# the various states that the login can be in
-LOGIN_STATE_UNKNOWN = "unkown"
-LOGIN_STATE_ASK_USER_AND_PASS = "ask-user-and-pass"
-LOGIN_STATE_HAS_USER_AND_PASS = "has-user-pass"
-LOGIN_STATE_SUCCESS = "success"
-LOGIN_STATE_SUCCESS_PENDING = "success-pending"
-LOGIN_STATE_AUTH_FAILURE = "auth-fail"
-LOGIN_STATE_USER_CANCEL = "user-cancel"
-
-
-class UserCancelException(Exception):
-    """ user pressed cancel """
-    pass
-
-
-class LaunchpadlibWorker(threading.Thread):
-    """The launchpadlib worker thread - it does not touch the UI
-       and only communicates via the following:
-
-       "login_state" - the current LOGIN_STATE_* value
-
-       To input reviews call "queue_review()"
-       When no longer needed, call "shutdown()"
-    """
-
-    def __init__(self):
-        # init parent
-        threading.Thread.__init__(self)
-        # the current login state, this is used accross multiple threads
-        self.login_state = LOGIN_STATE_UNKNOWN
-        # the username/pw to use
-        self.login_username = ""
-        self.login_password = ""
-        self._launchpad = None
-        self._pending_requests = Queue()
-        self._shutdown = False
-        self._logger = logging.getLogger("softwarecenter.backend")
-
-    def run(self):
-        """
-        Main thread run interface, logs into launchpad
-        """
-        self._logger.debug("lp worker thread run")
-        # login
-        self._lp_login()
-        # loop
-        self._wait_for_commands()
-
-    def shutdown(self):
-        """Request shutdown"""
-        self._shutdown = True
-
-    def queue_request(self, func, args, result_callback):
-        # FIXME: add support to pass strings instead of callable
-        self._pending_requests.put((func, args, result_callback))
-
-    def _wait_for_commands(self):
-        """internal helper that waits for commands"""
-        while True:
-            while not self._pending_requests.empty():
-                self._logger.debug("found pending request")
-                (func, args, result_callback) = self._pending_requests.get()
-                # run func async
-                res = func(*args)
-                # provide result to the callback
-                result_callback(res)
-                self._pending_requests.task_done()
-            # wait a bit
-            time.sleep(0.1)
-            if (self._shutdown and
-                self._pending_requests.empty()):
-                return
-
-    def _lp_login(self, access_level=['READ_PRIVATE']):
-        """ internal LP login code """
-        self._logger.debug("lp_login")
-        # use cachedir
-        cachedir = SOFTWARE_CENTER_CACHE_DIR
-        if not os.path.exists(cachedir):
-            os.makedirs(cachedir)
-        # login into LP with GUI
-        try:
-            self._launchpad = Launchpad.login_with(
-                'software-center', SERVICE_ROOT, cachedir,
-                allow_access_levels=access_level,
-                authorizer_class=AuthorizeRequestTokenFromThread)
-            self.display_name = self._launchpad.me.display_name
-        except Exception as e:
-            if type(e) == UserCancelException:
-                return
-            self._logger.exception("Launchpad.login_with()")
-            # remove token on failure, it may be e.g. expired
-            # FIXME: store the token in a different place and to avoid
-            #        having to use _get_paths()
-            (service_root, launchpadlib_dir, cache_path,
-             service_root_dir) = Launchpad._get_paths(SERVICE_ROOT, cachedir)
-            credentials_path = os.path.join(service_root_dir, 'credentials')
-            consumer_credentials_path = os.path.join(credentials_path,
-                'software-center')
-            # ---
-            if os.path.exists(consumer_credentials_path):
-                os.remove(consumer_credentials_path)
-            self._lp_login(access_level)
-            return
-        self.login_state = LOGIN_STATE_SUCCESS
-        self._logger.debug("/done %s" % self._launchpad)
-
-
-class AuthorizeRequestTokenFromThread(RequestTokenAuthorizationEngine):
-    """ Internal helper that updates the login_state of
-        the modul global lp_worker_thread object
-    """
-    def __init__(self, *args, **kwargs):
-        super(AuthorizeRequestTokenFromThread, self).__init__(*args, **kwargs)
-        self._logger = logging.getLogger("softwarecenter.backend")
-
-    # we need this to give the engine a place to store the state
-    # for the UI
-    def __new__(cls, *args, **kwargs):
-        o = object.__new__(cls)
-        # keep the state here (the lp_worker_thead global to this module)
-        o.lp_worker = lp_worker_thread
-        return o
-
-    def input_username(self, cached_username, suggested_message):
-        self._logger.debug("input_username: %s" % self.lp_worker.login_state)
-        # otherwise go into ASK state
-        if not self.lp_worker.login_state in (LOGIN_STATE_ASK_USER_AND_PASS,
-                                              LOGIN_STATE_AUTH_FAILURE,
-                                              LOGIN_STATE_USER_CANCEL):
-            self.lp_worker.login_state = LOGIN_STATE_ASK_USER_AND_PASS
-        # check if user canceled and if so just return ""
-        if self.lp_worker.login_state == LOGIN_STATE_USER_CANCEL:
-            raise UserCancelException
-        # wait for username to become available
-        while not self.lp_worker.login_state in (LOGIN_STATE_HAS_USER_AND_PASS,
-                                                 LOGIN_STATE_USER_CANCEL):
-            time.sleep(0.2)
-        # note: returning None here make lplib open a registration page
-        #       in the browser
-        return self.lp_worker.login_username
-
-    def input_password(self, suggested_message):
-        self._logger.debug("Input password size %s" %
-            len(self.lp_worker.login_password))
-        return self.lp_worker.login_password
-
-    def input_access_level(self, available_levels, suggested_message,
-                           only_one_option=None):
-        """Collect the desired level of access from the end-user."""
-        self._logger.debug("input_access_level")
-        return "WRITE_PUBLIC"
-
-    def startup(self, suggested_messages):
-        self._logger.debug("startup")
-
-    def authentication_failure(self, suggested_message):
-        """The user entered invalid credentials."""
-        self._logger.debug("auth failure")
-        # ignore auth failures if the user canceled
-        if self.lp_worker.login_state == LOGIN_STATE_USER_CANCEL:
-            return
-        self.lp_worker.login_state = LOGIN_STATE_AUTH_FAILURE
-
-    def success(self, suggested_message):
-        """The token was successfully authorized."""
-        self._logger.debug("success")
-        self.lp_worker.login_state = LOGIN_STATE_SUCCESS_PENDING
-
-
-class GLaunchpad(LoginBackend):
-    """ A launchpad connection that uses GObject signals
-        for communication and async tasks
-    """
-
-    NEW_ACCOUNT_URL = "https://login.launchpad.net/+standalone-login"
-    FORGOT_PASSWORD_URL = "https://login.launchpad.net/+standalone-login"
-
-    def __init__(self):
-        LoginBackend.__init__(self)
-        self.distro = get_distro()
-        self.oauth_token = None
-
-    def connect_to_server(self):
-        """ Connects to launchpad and emits one of:
-            - need-username-password (use enter_username_password() then)
-            - login-successful
-            - login-failed
-        """
-        GObject.timeout_add(200, self._wait_for_login)
-        lp_worker_thread.start()
-
-    def shutdown(self):
-        """ shutdown the server connection thread """
-        lp_worker_thread.shutdown()
-
-    def enter_username_password(self, user, password):
-        """
-        provider username and password, ususally used when the
-        need-username-password signal was send
-        """
-        lp_worker_thread.login_username = user
-        lp_worker_thread.login_password = password
-        lp_worker_thread.login_state = LOGIN_STATE_HAS_USER_AND_PASS
-
-    def login(self, username=None, password=None):
-        if username and password:
-            self.enter_username_password(username, password)
-        else:
-            self.connect_to_server()
-
-    def cancel_login(self):
-        lp_worker_thread.login_state = LOGIN_STATE_USER_CANCEL
-
-    def get_subscribed_archives(self):
-        """ return list of sources.list entries """
-        urls = lp_worker_thread._launchpad.me.getArchiveSubscriptionURLs()
-        return self._format_archive_subscription_urls_as_deb_lines(urls)
-
-    def _format_archive_subscription_urls_as_deb_lines(self, urls):
-        deb_lines = ["deb %s %s main" % (url, self.distro.get_codename())
-                     for url in urls]
-        return deb_lines
-
-    def get_subscribed_archives_async(self, callback):
-        """ get the available subscribed archives and run 'callback' when
-            they become availalbe
-        """
-        def _result_cb(urls):
-            # format as deb lines
-            callback(self._format_archive_subscription_urls_as_deb_lines(urls))
-        #func = "me.getArchiveSubscriptionURLs"
-        func = lp_worker_thread._launchpad.me.getArchiveSubscriptionURLs
-        lp_worker_thread.queue_request(func, (), _result_cb)
-
-    def _wait_for_login(self):
-        state = lp_worker_thread.login_state
-        if state == LOGIN_STATE_AUTH_FAILURE:
-            self.emit("login-failed")
-        elif state == LOGIN_STATE_ASK_USER_AND_PASS:
-            self.emit("need-username-password")
-        elif state == LOGIN_STATE_SUCCESS:
-            self.emit("login-successful", self.oauth_token)
-            return False
-        elif state == LOGIN_STATE_USER_CANCEL:
-            return False
-        return True
-
-# IMPORTANT: create one (module) global LP worker thread here
-lp_worker_thread = LaunchpadlibWorker()
-# daemon threads make it crash on cancel
-lp_worker_thread.daemon = True
-
-
-# test code
-def _login_success(lp):
-    print ("success %s" % lp)
-    print(lp.get_subscribed_archives())
-    print(lp.get_subscribed_archives_async(_result_callback))
-
-
-def _login_failed(lp):
-    print ("fail %s" % lp)
-
-
-def _result_callback(result_list):
-    print("_result_callback %s" % result_list)
-
-
-def _login_need_user_and_password(lp):
-    import sys
-    sys.stdout.write("user: ")
-    sys.stdout.flush()
-    user = sys.stdin.readline().strip()
-    sys.stdout.write("pass: ")
-    sys.stdout.flush()
-    password = sys.stdin.readline().strip()
-    lp.enter_username_password(user, password)
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.DEBUG)
-    lp = GLaunchpad()
-    lp.connect("login-successful", _login_success)
-    lp.connect("login-failed", _login_failed)
-    lp.connect("need-username-password", _login_need_user_and_password)
-    lp.connect_to_server()
-
-    # wait
-    try:
-        GObject.MainLoop().run()
-    except KeyboardInterrupt:
-        lp_worker_thread.shutdown()

=== modified file 'softwarecenter/backend/login.py'
--- softwarecenter/backend/login.py	2012-09-14 14:02:22 +0000
+++ softwarecenter/backend/login.py	2012-09-14 14:02:22 +0000
@@ -21,6 +21,11 @@
 
 from gi.repository import GObject
 
+import logging
+import os
+
+LOG = logging.getLogger(__name__)
+
 
 class LoginBackend(GObject.GObject):
 
@@ -46,7 +51,7 @@
                                   ),
         }
 
-    def login(self, username=None, password=None):
+    def login(self):
         raise NotImplemented
 
     def login_or_register(self):
@@ -57,3 +62,31 @@
 
     def cancel_login(self):
         self.emit("login-canceled")
+
+
+def get_login_backend(window_id, appname, help_text):
+    """
+    factory that returns an sso loader singelton
+    """
+    if "SOFTWARE_CENTER_FAKE_REVIEW_API" in os.environ:
+        from softwarecenter.backend.login_impl.login_fake import (
+            LoginBackendDbusSSOFake)
+        sso_class = LoginBackendDbusSSOFake(window_id, appname, help_text)
+        LOG.warn('Using fake login SSO functionality. Only meant for '
+            'testing purposes')
+    else:
+        from softwarecenter.backend.login_impl.login_sso import (
+            LoginBackendDbusSSO)
+        sso_class = LoginBackendDbusSSO(window_id, appname, help_text)
+    return sso_class
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG)
+
+    from softwarecenter.enums import SOFTWARE_CENTER_NAME_KEYRING
+    login = get_login_backend(0, SOFTWARE_CENTER_NAME_KEYRING, "login-text")
+    login.login()
+
+    from gi.repository import Gtk
+    Gtk.main()

=== added directory 'softwarecenter/backend/login_impl'
=== added file 'softwarecenter/backend/login_impl/__init__.py'
=== added file 'softwarecenter/backend/login_impl/login_fake.py'
--- softwarecenter/backend/login_impl/login_fake.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/backend/login_impl/login_fake.py	2012-09-14 14:02:22 +0000
@@ -0,0 +1,85 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2012 Canonical
+#
+# Authors:
+#  Michael Vogt
+#
+# 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 dbus
+import logging
+import random
+import string
+
+from softwarecenter.backend.fake_review_settings import (
+    FakeReviewSettings,
+    network_delay,
+    )
+from softwarecenter.backend.login import LoginBackend
+
+LOG = logging.getLogger(__name__)
+
+
+class LoginBackendDbusSSOFake(LoginBackend):
+
+    def __init__(self, window_id, appname, help_text):
+        super(LoginBackendDbusSSOFake, self).__init__()
+        self.appname = appname
+        self.help_text = help_text
+        self._window_id = window_id
+        self._fake_settings = FakeReviewSettings()
+
+    @network_delay
+    def login(self):
+        response = self._fake_settings.get_setting('login_response')
+
+        if response == "successful":
+            self.emit("login-successful", self._return_credentials())
+        elif response == "failed":
+            self.emit("login-failed")
+        elif response == "denied":
+            self.cancel_login()
+
+        return
+
+    def login_or_register(self):
+        #fake functionality for this is no different to fake login()
+        self.login()
+        return
+
+    def _random_unicode_string(self, length):
+        retval = ''
+        for i in range(0, length):
+            retval = retval + random.choice(string.letters + string.digits)
+        return retval.decode('utf-8')
+
+    def _return_credentials(self):
+        c = dbus.Dictionary(
+            {
+              dbus.String(u'consumer_secret'): dbus.String(
+                self._random_unicode_string(30)),
+              dbus.String(u'token'): dbus.String(
+                self._random_unicode_string(50)),
+              dbus.String(u'consumer_key'): dbus.String(
+                self._random_unicode_string(7)),
+              dbus.String(u'name'): dbus.String('Ubuntu Software Center @ ' +
+                self._random_unicode_string(6)),
+              dbus.String(u'token_secret'): dbus.String(
+                self._random_unicode_string(50))
+             },
+             signature=dbus.Signature('ss')
+             )
+        return c

=== renamed file 'softwarecenter/backend/login_sso.py' => 'softwarecenter/backend/login_impl/login_sso.py'
--- softwarecenter/backend/login_sso.py	2012-09-14 14:02:22 +0000
+++ softwarecenter/backend/login_impl/login_sso.py	2012-09-14 14:02:22 +0000
@@ -21,24 +21,18 @@
 
 import dbus
 import logging
-import random
-import string
-import os
 
 from dbus.mainloop.glib import DBusGMainLoop
 DBusGMainLoop(set_as_default=True)
 
-from softwarecenter.utils import utf8
-from login import LoginBackend
-
 from ubuntu_sso import (
     DBUS_BUS_NAME,
     DBUS_CREDENTIALS_IFACE,
     DBUS_CREDENTIALS_PATH,
     )
 
-# mostly for testing
-from fake_review_settings import FakeReviewSettings, network_delay
+from softwarecenter.backend.login import LoginBackend
+from softwarecenter.utils import utf8
 
 LOG = logging.getLogger(__name__)
 
@@ -80,7 +74,7 @@
         self._credentials = None
         self.proxy.find_credentials(self.appname, self._get_params())
 
-    def login(self, username=None, password=None):
+    def login(self):
         LOG.debug("login()")
         self._credentials = None
         self.proxy.login(self.appname, self._get_params())
@@ -121,78 +115,3 @@
             return
         self.cancel_login()
         self.emit("login-canceled")
-
-
-class LoginBackendDbusSSOFake(LoginBackend):
-
-    def __init__(self, window_id, appname, help_text):
-        super(LoginBackendDbusSSOFake, self).__init__()
-        self.appname = appname
-        self.help_text = help_text
-        self._window_id = window_id
-        self._fake_settings = FakeReviewSettings()
-
-    @network_delay
-    def login(self, username=None, password=None):
-        response = self._fake_settings.get_setting('login_response')
-
-        if response == "successful":
-            self.emit("login-successful", self._return_credentials())
-        elif response == "failed":
-            self.emit("login-failed")
-        elif response == "denied":
-            self.cancel_login()
-
-        return
-
-    def login_or_register(self):
-        #fake functionality for this is no different to fake login()
-        self.login()
-        return
-
-    def _random_unicode_string(self, length):
-        retval = ''
-        for i in range(0, length):
-            retval = retval + random.choice(string.letters + string.digits)
-        return retval.decode('utf-8')
-
-    def _return_credentials(self):
-        c = dbus.Dictionary(
-            {
-              dbus.String(u'consumer_secret'): dbus.String(
-                self._random_unicode_string(30)),
-              dbus.String(u'token'): dbus.String(
-                self._random_unicode_string(50)),
-              dbus.String(u'consumer_key'): dbus.String(
-                self._random_unicode_string(7)),
-              dbus.String(u'name'): dbus.String('Ubuntu Software Center @ ' +
-                self._random_unicode_string(6)),
-              dbus.String(u'token_secret'): dbus.String(
-                self._random_unicode_string(50))
-             },
-             signature=dbus.Signature('ss')
-             )
-        return c
-
-
-def get_sso_backend(window_id, appname, help_text):
-    """
-    factory that returns an sso loader singelton
-    """
-    if "SOFTWARE_CENTER_FAKE_REVIEW_API" in os.environ:
-        sso_class = LoginBackendDbusSSOFake(window_id, appname, help_text)
-        LOG.warn('Using fake login SSO functionality. Only meant for '
-            'testing purposes')
-    else:
-        sso_class = LoginBackendDbusSSO(window_id, appname, help_text)
-    return sso_class
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.DEBUG)
-
-    from softwarecenter.enums import SOFTWARE_CENTER_NAME_KEYRING
-    login = get_sso_backend(0, SOFTWARE_CENTER_NAME_KEYRING, "login-text")
-    login.login()
-
-    from gi.repository import Gtk
-    Gtk.main()

=== modified file 'softwarecenter/backend/oneconfhandler/core.py'
--- softwarecenter/backend/oneconfhandler/core.py	2012-03-19 21:01:41 +0000
+++ softwarecenter/backend/oneconfhandler/core.py	2012-09-14 14:02:22 +0000
@@ -20,7 +20,7 @@
 from oneconf.dbusconnect import DbusConnect
 from oneconf.enums import MIN_TIME_WITHOUT_ACTIVITY
 
-from softwarecenter.backend.login_sso import get_sso_backend
+from softwarecenter.backend.login import get_login_backend
 from softwarecenter.backend.ubuntusso import get_ubuntu_sso_backend
 from softwarecenter.enums import SOFTWARE_CENTER_NAME_KEYRING
 
@@ -167,7 +167,7 @@
                       "their inventories online to compare the software "
                       "installed on each\nNo-one else will be able to see "
                       "what you have installed.")
-        self.sso = get_sso_backend(
+        self.sso = get_login_backend(
             0, SOFTWARE_CENTER_NAME_KEYRING, help_text)
         self.sso.connect("login-successful", self._maybe_login_successful)
         self.sso.connect("login-canceled", self._login_canceled)

=== modified file 'softwarecenter/backend/ubuntusso.py'
--- softwarecenter/backend/ubuntusso.py	2012-09-14 14:02:22 +0000
+++ softwarecenter/backend/ubuntusso.py	2012-09-14 14:02:22 +0000
@@ -36,7 +36,7 @@
 from fake_review_settings import FakeReviewSettings, network_delay
 from spawn_helper import SpawnHelper
 from softwarecenter.config import get_config
-from softwarecenter.backend.login_sso import get_sso_backend
+from softwarecenter.backend.login import get_login_backend
 
 from softwarecenter.backend.piston.ubuntusso_pristine import (
     UbuntuSsoAPI as PristineUbuntuSsoAPI,
@@ -123,8 +123,8 @@
     def clear_token(self):
         clear_token_from_ubuntu_sso_sync(SOFTWARE_CENTER_NAME_KEYRING)
 
-    def _get_sso_backend_and_connect(self):
-        sso = get_sso_backend(
+    def _get_login_backend_and_connect(self):
+        sso = get_login_backend(
             self.xid,
             SOFTWARE_CENTER_NAME_KEYRING,
             _(SOFTWARE_CENTER_SSO_DESCRIPTION))
@@ -135,14 +135,14 @@
 
     def find_oauth_token_sync(self):
         self.oauth = None
-        sso = self. _get_sso_backend_and_connect()
+        sso = self. _get_login_backend_and_connect()
         sso.find_credentials()
         self.loop.run()
         return self.oauth
 
     def get_oauth_token_sync(self):
         self.oauth = None
-        sso = self. _get_sso_backend_and_connect()
+        sso = self. _get_login_backend_and_connect()
         sso.login_or_register()
         self.loop.run()
         return self.oauth
@@ -252,7 +252,7 @@
     logging.basicConfig(level=logging.DEBUG)
     softwarecenter.paths.datadir = "./data"
 
-    backend = get_sso_backend("", "appname", "help_text")
+    backend = get_login_backend("", "appname", "help_text")
     backend.connect("login-successful", _dbus_maybe_login_successful)
     backend.login_or_register()
     Gtk.main()

=== modified file 'softwarecenter/ui/gtk3/app.py'
--- softwarecenter/ui/gtk3/app.py	2012-09-14 14:02:22 +0000
+++ softwarecenter/ui/gtk3/app.py	2012-09-14 14:02:22 +0000
@@ -121,7 +121,7 @@
 
 from softwarecenter.config import get_config
 from softwarecenter.backend import get_install_backend
-from softwarecenter.backend.login_sso import get_sso_backend
+from softwarecenter.backend.login import get_login_backend
 from softwarecenter.backend.recagent import RecommenderAgent
 
 from softwarecenter.backend.channel import AllInstalledChannel
@@ -625,9 +625,6 @@
         if Gtk.main_level() == 0:
             LOG.info("closing before the regular main loop was run")
             sys.exit(0)
-        # this is the case when it regularly runs
-        if hasattr(self, "glaunchpad"):
-            self.glaunchpad.shutdown()
         self.save_state()
         self.destroy()
 
@@ -737,13 +734,6 @@
             if self.menuitem_go_forward.get_sensitive():
                 self.menuitem_go_forward.activate()
 
-    def _on_lp_login(self, lp, token):
-        self._lp_login_successful = True
-        private_archives = self.glaunchpad.get_subscribed_archives()
-        channel_manager = self.view_switcher.get_model().channel_manager
-        channel_manager.feed_in_private_sources_list_entries(
-            private_archives)
-
     def _on_style_updated(self, widget, init_css_callback, *args):
         init_css_callback(widget, *args)
 
@@ -819,14 +809,6 @@
         # return False to ensure that a possible GObject.timeout_add ends
         return False
 
-    def on_menuitem_launchpad_private_ppas_activate(self, menuitem):
-        from backend.launchpad import GLaunchpad
-        self.glaunchpad = GLaunchpad()
-        self.glaunchpad.connect("login-successful", self._on_lp_login)
-        from view.logindialog import LoginDialog
-        d = LoginDialog(self.glaunchpad, self.datadir, parent=self.window_main)
-        d.login()
-
     def _on_reinstall_purchased_login(self, sso, oauth_result):
         self._sso_login_successful = True
         # appmanager needs to know about the oauth token for the reinstall
@@ -870,7 +852,7 @@
             #window = self.window_main.get_window()
             #xid = self.get_window().xid
             xid = 0
-            self.sso = get_sso_backend(xid, appname, help_text)
+            self.sso = get_login_backend(xid, appname, help_text)
             self.sso.connect(
                 "login-successful", self._on_reinstall_purchased_login)
             self.sso.login()

=== modified file 'softwarecenter/ui/gtk3/review_gui_helper.py'
--- softwarecenter/ui/gtk3/review_gui_helper.py	2012-08-07 10:19:55 +0000
+++ softwarecenter/ui/gtk3/review_gui_helper.py	2012-09-14 14:02:22 +0000
@@ -51,7 +51,7 @@
 from softwarecenter.enums import Icons, SOFTWARE_CENTER_NAME_KEYRING
 from softwarecenter.config import get_config
 from softwarecenter.distro import get_distro, get_current_arch
-from softwarecenter.backend.login_sso import get_sso_backend
+from softwarecenter.backend.login import get_login_backend
 from softwarecenter.backend.reviews import Review
 from softwarecenter.db.database import Application
 from softwarecenter.gwibber_helper import GwibberHelper, GwibberHelperMock
@@ -449,7 +449,7 @@
         login_window_xid = self._get_parent_xid_for_login_window()
         help_text = _("To review software or to report abuse you need to "
                       "sign in to a Ubuntu Single Sign-On account.")
-        self.sso = get_sso_backend(login_window_xid,
+        self.sso = get_login_backend(login_window_xid,
                                    SOFTWARE_CENTER_NAME_KEYRING, help_text)
         self.sso.connect("login-successful", self._maybe_login_successful)
         self.sso.connect("login-canceled", self._login_canceled)

=== modified file 'softwarecenter/ui/gtk3/widgets/recommendations.py'
--- softwarecenter/ui/gtk3/widgets/recommendations.py	2012-09-11 14:44:17 +0000
+++ softwarecenter/ui/gtk3/widgets/recommendations.py	2012-09-14 14:02:22 +0000
@@ -30,7 +30,7 @@
                                           AppRecommendationsCategory)
 from softwarecenter.backend import get_install_backend
 from softwarecenter.backend.recagent import RecommenderAgent
-from softwarecenter.backend.login_sso import get_sso_backend
+from softwarecenter.backend.login import get_login_backend
 from softwarecenter.backend.ubuntusso import get_ubuntu_sso_backend
 from softwarecenter.enums import (
     LOBBY_RECOMMENDATIONS_CAROUSEL_LIMIT,
@@ -316,7 +316,7 @@
         #        we simply reuse the opt-in text from the panel since we
         #        are well past string freeze
         self.spinner_notebook.show_spinner()
-        self.sso = get_sso_backend(get_parent_xid(self),
+        self.sso = get_login_backend(get_parent_xid(self),
                                    SOFTWARE_CENTER_NAME_KEYRING,
                                    self.RECOMMENDATIONS_OPT_IN_TEXT)
         self.sso.connect("login-successful", self._maybe_login_successful)

=== removed file 'tests/disabled_test_launchpad.py'
--- tests/disabled_test_launchpad.py	2012-08-14 15:10:19 +0000
+++ tests/disabled_test_launchpad.py	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-import unittest
-
-from tests.utils import (
-    do_events,
-    setup_test_env,
-)
-setup_test_env()
-from softwarecenter.backend.launchpad import GLaunchpad
-
-
-class TestUbuntuSSO(unittest.TestCase):
-
-    def _cb_login_successful(self, lp, token):
-        self._login_successful = True
-
-    def test_launchpad_login(self):
-        lp = GLaunchpad()
-        lp.connect("login-successful", self._cb_login_successful)
-        # monkey patch
-        lp.login = lambda u,p: True
-        lp.login("user", "password")
-        lp.emit("login-successful", None)
-        do_events()
-        self.assertTrue(self._login_successful)
-
-    def _monkey_get_subscribed_archives(self):
-        return ["deb http://foo:[e-mail]/ main"]
-
-    def test_launchpad_get_subscribed_archives(self):
-        lp = GLaunchpad()
-        lp.get_subscribed_archives = self._monkey_get_subscribed_archives
-        archives = lp.get_subscribed_archives()
-        self.assertEqual(archives, ["deb http://foo:[e-mail]/ main"])
-
-if __name__ == "__main__":
-    unittest.main()

=== modified file 'tests/gtk3/test_catview.py'
--- tests/gtk3/test_catview.py	2012-09-11 14:33:50 +0000
+++ tests/gtk3/test_catview.py	2012-09-14 14:02:22 +0000
@@ -116,7 +116,7 @@
     
     # we need to use a custom setUp method for the recommendations test cases
     # so that everything gets configured properly
-    @patch('softwarecenter.ui.gtk3.widgets.recommendations.get_sso_backend')
+    @patch('softwarecenter.ui.gtk3.widgets.recommendations.get_login_backend')
     @patch('softwarecenter.ui.gtk3.widgets.recommendations.RecommenderAgent'
            '.is_opted_in')
     # patch out the agent query method to avoid making the actual server call

=== modified file 'tests/test_login_backend.py'
--- tests/test_login_backend.py	2012-05-30 18:39:55 +0000
+++ tests/test_login_backend.py	2012-09-14 14:02:22 +0000
@@ -5,9 +5,13 @@
     setup_test_env,
 )
 setup_test_env()
-from softwarecenter.backend.login_sso import (get_sso_backend,
-                                              LoginBackendDbusSSO,
-                                              LoginBackendDbusSSOFake)
+from softwarecenter.backend.login import get_login_backend
+from softwarecenter.backend.login_impl.login_sso import (
+    LoginBackendDbusSSO)
+from softwarecenter.backend.login_impl.login_fake import (
+    LoginBackendDbusSSOFake,
+    )
+
 
 class TestLoginBackend(unittest.TestCase):
     """ tests the login backend stuff """
@@ -21,13 +25,13 @@
             set([x for x in dir(login_real) if not x.startswith("_")]),
             set([x for x in dir(login_fake) if not x.startswith("_")]))
 
-    def test_get_sso_backend(self):
+    def test_get_login_backend(self):
         # test that we get the real one
-        self.assertEqual(type(get_sso_backend(None, None, None)),
+        self.assertEqual(type(get_login_backend(None, None, None)),
                          LoginBackendDbusSSO)
         # test that we get the fake one
         os.environ["SOFTWARE_CENTER_FAKE_REVIEW_API"] = "1"
-        self.assertEqual(type(get_sso_backend(None, None, None)),
+        self.assertEqual(type(get_login_backend(None, None, None)),
                          LoginBackendDbusSSOFake)
         # clean the environment
         del os.environ["SOFTWARE_CENTER_FAKE_REVIEW_API"]