Merge lp:~mvo/software-center/replace-restfulclient-with-piston into lp:software-center

[Michael Vogt]

This branch removes the need for lazr.restfulclient by replacing it with a piston-mini-client based helper.

It also cleansup the use of the piston-mini-client helpers and unifies most of them into the piston_generic_helper.

[Kiwinote (kiwinote)]

in line 118 of backend/scagent.py we want 'exhibits' rather than 'exhiits'

[Gary Lasker (gary-lasker)]

Hi mvo! So I made the fix that kiwinote mentioned above, plus some small fixes that I *think* are needed to make Ubuntu SSO work, and finally some pyflakes cleanup. I pushed this to:

  lp:~gary-lasker/software-center/replace-restfulclient-with-piston-tweaks

Please take a look at the SSO changes in particular as I want to be sure these are correct.

I think that if these small changes look rigfht to you, we are good to go for this branch. Let's talk tomorrow if you like, to make sure everything's just right.

=== added symlink 'data/piston_generic_helper.py'
=== target is u'../utils/piston-helpers/piston_generic_helper.py'
=== removed symlink 'data/piston_get_review_stats_helper.py'
=== target was u'../utils/piston-helpers/piston_get_review_stats_helper.py'
=== removed symlink 'data/piston_get_scagent_available_apps.py'
=== target was u'../utils/piston-helpers/piston_get_scagent_available_apps.py'
=== removed symlink 'data/piston_get_useful_votes_helper.py'
=== target was u'../utils/piston-helpers/piston_get_useful_votes_helper.py'
=== modified file 'debian/control'
--- debian/control	2011-12-06 14:22:20 +0000
+++ debian/control	2012-01-05 15:32:23 +0000
@@ -40,7 +40,6 @@
          policykit-1,
          policykit-1-gnome | policykit-1-kde,
          python-xdg,
-	 python-lazr.restfulclient,
          ubuntu-sso-client (>= 0.99.6),
          python-piston-mini-client (>= 0.1+bzr29),
          oneconf (>= 0.2.6),
 
=== modified file 'softwarecenter/backend/login.py'
--- softwarecenter/backend/login.py	2011-09-15 14:24:14 +0000
+++ softwarecenter/backend/login.py	2012-01-05 15:32:23 +0000
@@ -49,10 +49,3 @@
         raise NotImplemented
     def cancel_login(self):
         self.emit("login-canceled")
-    @property
-    def new_account_url(self):
-        return self.NEW_ACCOUNT_URL
-    @property
-    def forgoten_password_url(self):
-        return self.FORGOT_PASSWORD_URL
-    
 
=== modified file 'softwarecenter/backend/oneconfhandler/core.py'
--- softwarecenter/backend/oneconfhandler/core.py	2011-10-26 12:01:19 +0000
+++ softwarecenter/backend/oneconfhandler/core.py	2012-01-05 15:32:23 +0000
@@ -22,7 +22,7 @@
 from oneconf.enums import MIN_TIME_WITHOUT_ACTIVITY
 
 from softwarecenter.backend.login_sso import get_sso_backend
-from softwarecenter.backend.restfulclient import get_ubuntu_sso_backend
+from softwarecenter.backend.ubuntusso import get_ubuntu_sso_backend
 from softwarecenter.utils import clear_token_from_ubuntu_sso
 
 import datetime
@@ -172,10 +172,11 @@
     def _maybe_login_successful(self, sso, oauth_result):
         """ called after we have the token, then we go and figure out our name """
         logging.debug("_maybe_login_successful")
-        token = oauth_result
-        self.ssoapi = get_ubuntu_sso_backend(token)
+        self.ssoapi = get_ubuntu_sso_backend()
         self.ssoapi.connect("whoami", self._whoami_done)
         self.ssoapi.connect("error", self._whoami_error)
+        # this will automatically verify the keyring token and retrigger 
+        # login (once) if its expired
         self.ssoapi.whoami()
 
     def _whoami_done(self, ssologin, result):
@@ -184,13 +185,5 @@
 
     def _whoami_error(self, ssologin, e):
         logging.error("whoami error '%s'" % e)
-        # HACK: clear the token from the keyring assuming that it expired
-        #       or got deauthorized by the user on the website
-        # this really should be done by ubuntu-sso-client itself
-        import lazr.restfulclient.errors
-        errortype = lazr.restfulclient.errors.HTTPError
-        if (type(e) == errortype):
-            LOG.warn("authentication error, resetting token and retrying")
-            clear_token_from_ubuntu_sso(self.appname)
-            self._share_inventory(False)
-            return
+        self._share_inventory(False)
+        return
 
=== added file 'softwarecenter/backend/piston/ubuntusso_pristine.py'
--- softwarecenter/backend/piston/ubuntusso_pristine.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/backend/piston/ubuntusso_pristine.py	2012-01-05 15:32:23 +0000
@@ -0,0 +1,22 @@
+from piston_mini_client import PistonAPI, returns_json
+from piston_mini_client.validators import oauth_protected
+
+# These are factored out as constants for if you need to work against a
+# server that doesn't support both schemes (like http-only dev servers)
+PUBLIC_API_SCHEME = 'http'
+AUTHENTICATED_API_SCHEME = 'https'
+
+
+# this is only here because:
+#  a) ubuntu-sso-client does not support verifying if the credentials
+#     are still valid
+#  b) the restful client interface is not really needed because we just
+#     need this one single call
+class UbuntuSsoAPI(PistonAPI):
+    default_service_root = 'http://localhost:8000/api/2.0'
+
+    @oauth_protected
+    @returns_json
+    def whoami(self, id=None):
+        return self._get('accounts?ws.op=me',
+                         scheme=AUTHENTICATED_API_SCHEME)
 
=== modified file 'softwarecenter/backend/reviews/__init__.py'
--- softwarecenter/backend/reviews/__init__.py	2011-11-07 10:04:33 +0000
+++ softwarecenter/backend/reviews/__init__.py	2012-01-05 15:32:23 +0000
@@ -19,6 +19,7 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 import datetime
+import json
 import logging
 import operator
 import os
@@ -107,13 +108,10 @@
             return False
         
         # run the command and add watcher
-        cmd = [os.path.join(
-                softwarecenter.paths.datadir, PistonHelpers.GET_USEFUL_VOTES),
-               "--username", user, 
-              ]
         spawn_helper = SpawnHelper()
         spawn_helper.connect("data-available", self._on_usefulness_data)
-        spawn_helper.run(cmd)
+        spawn_helper.run_generic_piston_helper(
+            "RatingsAndReviewsAPI", "get_usefulness", username=user)
 
     def _on_usefulness_data(self, spawn_helper, results):
         '''called if usefulness retrieved from server'''
 
=== modified file 'softwarecenter/backend/reviews/rnr.py'
--- softwarecenter/backend/reviews/rnr.py	2011-11-07 08:26:13 +0000
+++ softwarecenter/backend/reviews/rnr.py	2012-01-05 15:32:23 +0000
@@ -128,22 +128,20 @@
         except OSError:
             days_delta = 0
         LOG.debug("refresh with days_delta: %s" % days_delta)
+        # FIXME: the server currently has bug (#757695) so we
+        #        can not turn this on just yet and need to use
+        #        the old "catch-all" review-stats for now
         #origin = "any"
         #distroseries = self.distro.get_codename()
-        cmd = [os.path.join(
-                softwarecenter.paths.datadir, PistonHelpers.GET_REVIEW_STATS),
-               # FIXME: the server currently has bug (#757695) so we
-               #        can not turn this on just yet and need to use
-               #        the old "catch-all" review-stats for now
-               #"--origin", origin, 
-               #"--distroseries", distroseries, 
-              ]
+        spawn_helper = SpawnHelper()
+        spawn_helper.connect("data-available", self._on_review_stats_data, callback)
         if days_delta:
-            cmd += ["--days-delta", str(days_delta)]
-        spawn_helper = SpawnHelper()
-        spawn_helper.connect("data-available", self._on_review_stats_data, callback)
-        spawn_helper.run(cmd)
-
+            spawn_helper.run_generic_piston_helper(
+                "RatingsAndReviewsAPI", "review_stats", days=days_delta)
+        else:
+            spawn_helper.run_generic_piston_helper(
+                "RatingsAndReviewsAPI", "review_stats")
+                                                              
     def _on_review_stats_data(self, spawn_helper, piston_review_stats, callback):
         """ process stdout from the helper """
         review_stats = self.REVIEW_STATS_CACHE
 
=== modified file 'softwarecenter/backend/scagent.py'
--- softwarecenter/backend/scagent.py	2012-01-03 15:20:56 +0000
+++ softwarecenter/backend/scagent.py	2012-01-05 15:32:23 +0000
@@ -20,6 +20,7 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 from gi.repository import GObject
+import json
 import logging
 import os
 
@@ -56,14 +57,7 @@
         GObject.GObject.__init__(self)
         self.distro = get_distro()
         self.ignore_cache = ignore_cache
-        binary = os.path.join(
-            softwarecenter.paths.datadir, PistonHelpers.SOFTWARE_CENTER_AGENT)
-        self.HELPER_CMD = [binary]
-        if self.ignore_cache:
-            self.HELPER_CMD.append("--ignore-cache")
-        if xid:
-            self.HELPER_CMD.append("--parent-xid")
-            self.HELPER_CMD.append(str(xid))
+        self.xid = xid
 
     def query_available(self, series_name=None, arch_tag=None):
         self._query_available(series_name, arch_tag, for_qa=False)
@@ -78,41 +72,52 @@
         if not arch_tag:
             arch_tag = get_current_arch()
         # build the command
-        cmd = self.HELPER_CMD[:]
+        spawner = SpawnHelper()
+        spawner.parent_xid = self.xid
+        spawner.ignore_cache = self.ignore_cache
+        spawner.connect("data-available", self._on_query_available_data)
+        spawner.connect("error", lambda spawner, err: self.emit("error", err))
         if for_qa:
-            cmd.append("available_apps_qa")
+            spawner.needs_auth = True
+            spawner.run_generic_piston_helper(
+                "SoftwareCenterAgentAPI",
+                "available_apps_qa",
+                lang=get_langugage(),
+                series=series_name,
+                arch=arch_tag)
         else:
-            cmd.append("available_apps")
-        cmd += [language,
-                series_name,
-                arch_tag,
-                ]
-        spawner = SpawnHelper()
-        spawner.connect("data-available", self._on_query_available_data)
-        spawner.connect("error", lambda spawner, err: self.emit("error", err))
-        spawner.run(cmd)
+            spawner.run_generic_piston_helper(
+                "SoftwareCenterAgentAPI",
+                "available_apps",
+                lang=get_language(),
+                series=series_name,
+                arch=arch_tag)
+
     def _on_query_available_data(self, spawner, piston_available):
         self.emit("available", piston_available)
 
     def query_available_for_me(self, oauth_token, openid_identifier):
-        cmd = self.HELPER_CMD[:]
-        cmd.append("subscriptions_for_me")
         spawner = SpawnHelper()
+        spawner.parent_xid = self.xid
+        spawner.ignore_cache = self.ignore_cache
         spawner.connect("data-available", self._on_query_available_for_me_data)
         spawner.connect("error", lambda spawner, err: self.emit("error", err))
-        spawner.run(cmd)
+        spawner.needs_auth = True
+        spawner.run_generic_piston_helper(
+            "SoftwareCenterAgentAPI", "subscriptions_for_me")
     def _on_query_available_for_me_data(self, spawner, piston_available_for_me):
         self.emit("available-for-me", piston_available_for_me)
 
     def query_exhibits(self):
-        cmd = self.HELPER_CMD[:]
-        cmd.append("exhibits")
-        cmd.append(get_language())
-        cmd.append(self.distro.get_codename())
         spawner = SpawnHelper()
+        spawner.parent_xid = self.xid
+        spawner.ignore_cache = self.ignore_cache
         spawner.connect("data-available", self._on_exhibits_data_available)
         spawner.connect("error", lambda spawner, err: self.emit("error", err))
-        spawner.run(cmd)
+        spawner.run_generic_piston_helper(
+            "SoftwareCenterAgentAPI", "exhiits", 
+            lang=get_language(), series=self.distro.get_codename())
+
     def _on_exhibits_data_available(self, spawner, exhibits):
         for exhibit in exhibits:
             # special case, if there is no title provided by the server
 
=== modified file 'softwarecenter/backend/spawn_helper.py'
--- softwarecenter/backend/spawn_helper.py	2011-09-15 14:24:14 +0000
+++ softwarecenter/backend/spawn_helper.py	2012-01-05 15:32:23 +0000
@@ -30,6 +30,9 @@
 import os
 import json
 
+import softwarecenter.paths
+from softwarecenter.paths import PistonHelpers
+
 from gi.repository import GObject
 
 LOG = logging.getLogger(__name__)
@@ -59,6 +62,27 @@
         self._io_watch = None
         self._child_watch = None
         self._cmd = None
+        self.needs_auth = False
+        self.ignore_cache = False
+        self.parent_xid = None
+
+    def run_generic_piston_helper(self, klass, func, **kwargs):
+        binary = os.path.join(
+            softwarecenter.paths.datadir, PistonHelpers.GENERIC_HELPER)
+        cmd = [binary]
+        cmd += ["--datadir", softwarecenter.paths.datadir]
+        if self.needs_auth:
+            cmd.append("--needs-auth")
+        if self.ignore_cache:
+            cmd.append("--ignore-cache")
+        if self.parent_xid:
+            cmd.append("--parent-xid")
+            cmd.append(str(xid))
+        cmd += [klass, func]
+        if kwargs:
+            cmd.append(json.dumps(kwargs))
+        LOG.debug("run_generic_piston_helper()")
+        self.run(cmd)
 
     def run(self, cmd):
         self._cmd = cmd
 
=== renamed file 'softwarecenter/backend/restfulclient.py' => 'softwarecenter/backend/ubuntusso.py'
--- softwarecenter/backend/restfulclient.py	2012-01-05 09:53:52 +0000
+++ softwarecenter/backend/ubuntusso.py	2012-01-05 15:32:23 +0000
@@ -19,134 +19,29 @@
 # 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 logging
-import threading
-
-from softwarecenter.enums import BUY_SOMETHING_HOST
-
-# possible workaround for bug #599332 is to try to import lazr.restful
-# import lazr.restful
-# import lazr.restfulclient
-
-from lazr.restfulclient.resource import ServiceRoot
-from lazr.restfulclient.authorize import BasicHttpAuthorizer
-from lazr.restfulclient.authorize.oauth import OAuthAuthorizer
-from oauth.oauth import OAuthToken
-
-from softwarecenter.paths import SOFTWARE_CENTER_CACHE_DIR
-from Queue import Queue
+import os
+
+import softwarecenter.paths
+from softwarecenter.paths import PistonHelpers
+
+import piston_mini_client.auth
 
 # mostly for testing
 from fake_review_settings import FakeReviewSettings, network_delay
-
-from login import LoginBackend
+from spawn_helper import SpawnHelper
+
+from softwarecenter.utils import clear_token_from_ubuntu_sso
+
+from gettext import gettext as _
 
 LOG = logging.getLogger(__name__)
 
-UBUNTU_SSO_SERVICE = os.environ.get(
-    "USSOC_SERVICE_URL", "https://login.ubuntu.com/api/1.0")
-UBUNTU_SOFTWARE_CENTER_AGENT_SERVICE = BUY_SOMETHING_HOST+"/api/1.0"
-
-class AttributesObject(object):
-    """ convinient object to hold attributes """
-    MAX_REPR_STRING_SIZE = 30
-
-    def __repr__(self):
-        s = "<'%s': " % self.__class__.__name__
-        for key in vars(self):
-            value = str(getattr(self, key))
-            if len(value) > self.MAX_REPR_STRING_SIZE:
-                value = "%s..." % value[:self.MAX_REPR_STRING_SIZE]
-            s += "%s='%s';" % (key, value)
-        s += ">"
-        return s
-
-
-def restful_collection_to_real_python(restful_list):
-    """ take a restful and convert it to a python list with real python
-        objects
-    """
-    l = []
-    for entry in restful_list:
-        o = AttributesObject()
-        for attr in entry.lp_attributes:
-            setattr(o, attr, getattr(entry, attr))
-        l.append(o)
-    return l
-
-class RestfulClientWorker(threading.Thread):
-    """ a generic worker thread for a lazr.restfulclient """
-
-    def __init__(self, authorizer, service_root):
-        """ init the thread """
-        threading.Thread.__init__(self)
-        self._service_root_url = service_root
-        self._authorizer = authorizer
-        self._pending_requests = Queue()
-        self._shutdown = False
-        self.daemon = True
-        self.error = None
-        self._cachedir = os.path.join(SOFTWARE_CENTER_CACHE_DIR,
-                                      "restfulclient")
-
-    def run(self):
-        """
-        Main thread run interface, logs into launchpad
-        """
-        LOG.debug("lp worker thread run")
-        try:
-            self.service = ServiceRoot(self._authorizer, 
-                                       self._service_root_url,
-                                       self._cachedir)
-        except:
-            logging.exception("worker thread can not connect to service root")
-            self.error = "ERROR_SERVICE_ROOT"
-            self._shutdown = True
-            return
-        # loop
-        self._wait_for_commands()
-
-    def shutdown(self):
-        """Request shutdown"""
-        self._shutdown = True
-
-    def queue_request(self, func, args, kwargs, result_callback, error_callback):
-        """
-        queue a (remote) command for execution, the result_callback will
-        call with the result_list when done (that function will be
-        called async)
-        """
-        self._pending_requests.put((func, args, kwargs, result_callback, error_callback))
-
-    def _wait_for_commands(self):
-        """internal helper that waits for commands"""
-        while True:
-            while not self._pending_requests.empty():
-                LOG.debug("found pending request")
-                (func_str, args, kwargs, result_callback, error_callback) = self._pending_requests.get()
-                # run func async
-                try:
-                    func = self.service
-                    for part in func_str.split("."):
-                        func = getattr(func, part)
-                    res = func(*args, **kwargs)
-                except Exception ,e:
-                    error_callback(e)
-                else:
-                    result_callback(res)
-                self._pending_requests.task_done()
-            # wait a bit
-            import time
-            time.sleep(0.1)
-            if (self._shutdown and
-                self._pending_requests.empty()):
-                return
-
 class UbuntuSSOAPI(GObject.GObject):
+    """ Ubuntu SSO interface using the oauth token from the keyring """
 
     __gsignals__ = {
         "whoami" : (GObject.SIGNAL_RUN_LAST,
@@ -160,52 +55,27 @@
 
         }
        
-    def __init__(self, token):
+    def __init__(self):
         GObject.GObject.__init__(self)
-        self._whoami = None
-        self._error = None
-        self.service = UBUNTU_SSO_SERVICE
-        self.token = token
-        token = OAuthToken(self.token["token"], self.token["token_secret"])
-        authorizer = OAuthAuthorizer(self.token["consumer_key"],
-                                     self.token["consumer_secret"],
-                                     access_token=token)
-        # we need to init the GObject.init_threads()
-        #  - if we do it globally s-c will crash on exit (LP: #907568)
-        #  - if we don't do it, s-c will hang in worker_thread.start()
-        #    (even though threads_init is deprecated and according to the
-        #     docs is run automatically nowdays)
-        #  - if we do it here some apps will still crash
-        self.worker_thread =  RestfulClientWorker(authorizer, self.service)
-        self.worker_thread.start()
-        GObject.timeout_add(200, self._monitor_thread)
-
-    def _monitor_thread(self):
-        # glib bit of the threading, runs in the main thread
-        if self._whoami is not None:
-            self.emit("whoami", self._whoami)
-            self._whoami = None
-        if self._error is not None:
-            self.emit("error", self._error)
-            self._error = None
-        return True
-
-    def _thread_whoami_done(self, result):
-        self._whoami = result
-
-    def _thread_whoami_error(self, e):
-        self._error = e
+        
+    def _on_whoami_data(self, spawner, piston_whoami):
+        self.emit("whoami", piston_whoami)
 
     def whoami(self):
+        """ trigger request for the getting account information, this
+            will also verify if the current token is valid and if not
+            trigger a cleanup/re-authenticate
+        """
         LOG.debug("whoami called")
-        self.worker_thread.queue_request("accounts.me", (), {},
-                                         self._thread_whoami_done,
-                                         self._thread_whoami_error)
-
+        spawner = SpawnHelper()
+        spawner.connect("data-available", self._on_whoami_data)
+        spawner.connect("error", lambda spawner, err: self.emit("error", err))
+        spawner.needs_auth = True
+        spawner.run_generic_piston_helper("UbuntuSsoAPI", "whoami")
 
 class UbuntuSSOAPIFake(UbuntuSSOAPI):
 
-    def __init__(self, token):
+    def __init__(self):
         GObject.GObject.__init__(self)
         self._fake_settings = FakeReviewSettings()
 
@@ -231,83 +101,18 @@
     def _make_error():
         return 'HTTP Error 401: Unauthorized'
 
-def get_ubuntu_sso_backend(token):
+def get_ubuntu_sso_backend():
     """ 
     factory that returns an ubuntu sso loader singelton
     """
     if "SOFTWARE_CENTER_FAKE_REVIEW_API" in os.environ:
-        ubuntu_sso_class = UbuntuSSOAPIFake(token)
+        ubuntu_sso_class = UbuntuSSOAPIFake()
         LOG.warn('Using fake Ubuntu SSO API. Only meant for testing purposes')
     else:
-        ubuntu_sso_class = UbuntuSSOAPI(token)
+        ubuntu_sso_class = UbuntuSSOAPI()
     return ubuntu_sso_class
 
 
-class UbuntuSSOlogin(LoginBackend):
-
-    NEW_ACCOUNT_URL = "https://login.launchpad.net/+standalone-login"
-    FORGOT_PASSWORD_URL = "https://login.ubuntu.com/+forgot_password"
-
-    SSO_AUTHENTICATE_FUNC = "authentications.authenticate"
-
-    def __init__(self):
-        LoginBackend.__init__(self)
-        self.service = UBUNTU_SSO_SERVICE
-        # we get a dict here with the following keys:
-        #  token
-        #  consumer_key (also the openid identifier)
-        #  consumer_secret
-        #  token_secret
-        #  name (that is just 'software-center')
-        self.oauth_credentials = None
-        self._oauth_credentials = None
-        self._login_failure = None
-        self.worker_thread = None
-
-    def shutdown(self):
-        self.worker_thread.shutdown()
-
-    def login(self, username=None, password=None):
-        if not username or not password:
-            self.emit("need-username-password")
-            return
-        authorizer = BasicHttpAuthorizer(username, password)
-        self.worker_thread =  RestfulClientWorker(authorizer, self.service)
-        self.worker_thread.start()
-        kwargs = { "token_name" : "software-center", 
-                 }
-        self.worker_thread.queue_request(self.SSO_AUTHENTICATE_FUNC, (), kwargs,
-                                         self._thread_authentication_done,
-                                         self._thread_authentication_error)
-        GObject.timeout_add(200, self._monitor_thread)
-
-    def _monitor_thread(self):
-        # glib bit of the threading, runs in the main thread
-        if self._oauth_credentials:
-            self.emit("login-successful", self._oauth_credentials)
-            self.oauth_credentials = self._oauth_credentials
-            self._oauth_credentials = None
-        if self._login_failure:
-            self.emit("login-failed")
-            self._login_failure = None
-        return True
-
-    def _thread_authentication_done(self, result):
-        # runs in the thread context, can not touch gui or glib
-        #print "_authentication_done", result
-        self._oauth_credentials = result
-
-    def _thread_authentication_error(self, e):
-        # runs in the thread context, can not touch gui or glib
-        #print "_authentication_error", type(e)
-        self._login_failure = e
-
-    def __del__(self):
-        #print "del"
-        if self.worker_thread:
-            self.worker_thread.shutdown()
-
-
 # test code
 def _login_success(lp, token):
     print "success", lp, token
@@ -323,40 +128,30 @@
     password = sys.stdin.readline().strip()
     sso.login(user, password)
 
-def _error(scaagent, errormsg):
-    print "_error:", errormsg
-def _whoami(sso, whoami):
-    print "whoami: ", whoami
-
 # interactive test code
 if __name__ == "__main__":
+    def _whoami(sso, result):
+        print "res: ", result
+        Gtk.main_quit()
+    def _error(sso, result):
+        print "err: ", result
+        Gtk.main_quit()
+    def _dbus_maybe_login_successful(ssologin, oauth_result):
+        print "got token, verify it now"
+        sso = UbuntuSSOAPI()
+        sso.connect("whoami", _whoami)
+        sso.connect("error", _error)
+        sso.whoami()
+
+    from gi.repository import Gtk
     import sys
     logging.basicConfig(level=logging.DEBUG)
-
-    if len(sys.argv) < 2:
-        print "need an argument, one of: 'sso', 'ssologin'"
-        sys.exit(1)
-
-    elif sys.argv[1] == "sso":
-        def _dbus_maybe_login_successful(ssologin, oauth_result):
-            sso = UbuntuSSOAPI(oauth_result)
-            sso.connect("whoami", _whoami)
-            sso.connect("error", _error)
-            sso.whoami()
-        from login_sso import get_sso_backend
-        backend = get_sso_backend("", "appname", "help_text")
-        backend.connect("login-successful", _dbus_maybe_login_successful)
-        backend.login_or_register()
-
-    elif sys.argv[1] == "ssologin":
-        ssologin = UbuntuSSOlogin()
-        ssologin.connect("login-successful", _login_success)
-        ssologin.connect("login-failed", _login_failed)
-        ssologin.connect("need-username-password", _login_need_user_and_password)
-        ssologin.login()
-        
-    else:
-        print "unknown option"
-        sys.exit(1)
+    softwarecenter.paths.datadir = "./data"
+
+    from login_sso import get_sso_backend
+    backend = get_sso_backend("", "appname", "help_text")
+    backend.connect("login-successful", _dbus_maybe_login_successful)
+    backend.login_or_register()
+    Gtk.main()
 
 
 
=== modified file 'softwarecenter/enums.py'
--- softwarecenter/enums.py	2011-12-16 12:50:18 +0000
+++ softwarecenter/enums.py	2012-01-05 15:32:23 +0000
@@ -34,6 +34,11 @@
 BUY_SOMETHING_HOST = os.environ.get("SOFTWARE_CENTER_BUY_HOST") or "https://software-center.ubuntu.com"
 BUY_SOMETHING_HOST_ANONYMOUS = os.environ.get("SOFTWARE_CENTER_BUY_HOST") or "http://software-center.ubuntu.com"
 
+# for the sso login
+UBUNTU_SSO_SERVICE = os.environ.get(
+    "USSOC_SERVICE_URL", "https://login.ubuntu.com/")
+SSO_LOGIN_HOST = UBUNTU_SSO_SERVICE
+
 # version of the database, every time something gets added (like 
 # terms for mime-type) increase this (but keep as a string!)
 DB_SCHEMA_VERSION = "6"
 
=== modified file 'softwarecenter/paths.py'
--- softwarecenter/paths.py	2011-09-13 12:45:56 +0000
+++ softwarecenter/paths.py	2012-01-05 15:32:23 +0000
@@ -86,9 +86,7 @@
 # piston helpers
 class PistonHelpers:
     GET_REVIEWS = "piston_get_reviews_helper.py"
-    GET_REVIEW_STATS = "piston_get_review_stats_helper.py"
-    GET_USEFUL_VOTES = "piston_get_useful_votes_helper.py"
-    SOFTWARE_CENTER_AGENT = "piston_get_scagent_available_apps.py"
+    GENERIC_HELPER = "piston_generic_helper.py"
 
 X2GO_HELPER = "x2go_helper.py"
 
 
=== modified file 'test/gtk3/test_views.py'
--- test/gtk3/test_views.py	2011-11-15 10:54:54 +0000
+++ test/gtk3/test_views.py	2012-01-05 15:32:23 +0000
@@ -13,6 +13,8 @@
 
 import softwarecenter.paths
 softwarecenter.paths.datadir = "../data"
+import os
+os.environ["PYTHONPATH"] = "../"
 
 class TestViews(unittest.TestCase):
 
 
=== modified file 'test/test_reviews.py'
--- test/test_reviews.py	2011-11-04 14:52:52 +0000
+++ test/test_reviews.py	2012-01-05 15:32:23 +0000
@@ -11,6 +11,7 @@
 
 import softwarecenter.paths
 softwarecenter.paths.SOFTWARE_CENTER_CACHE_DIR = tempfile.mkdtemp()
+softwarecenter.paths.datadir = "../data"
 
 from softwarecenter.backend.reviews.rnr import (
     ReviewLoaderSpawningRNRClient as ReviewLoader)
@@ -51,6 +52,6 @@
             main_loop.iteration()
 
 if __name__ == "__main__":
-    #import logging
-    #logging.basicConfig(level=logging.DEBUG)
+    import logging
+    logging.basicConfig(level=logging.DEBUG)
     unittest.main()
 
=== modified file 'test/test_ubuntu_sso_api.py'
--- test/test_ubuntu_sso_api.py	2011-06-11 07:59:59 +0000
+++ test/test_ubuntu_sso_api.py	2012-01-05 15:32:23 +0000
@@ -6,10 +6,10 @@
 
 import os
 import unittest
-from softwarecenter.backend.restfulclient import (UbuntuSSOAPIFake,
-                                                  UbuntuSSOAPI,
-                                                  get_ubuntu_sso_backend,
-                                                  )
+from softwarecenter.backend.ubuntusso import (UbuntuSSOAPIFake,
+                                              UbuntuSSOAPI,
+                                              get_ubuntu_sso_backend,
+                                              )
 
 class TestSSOAPI(unittest.TestCase):
     """ tests the ubuntu sso backend stuff """
@@ -24,17 +24,12 @@
             set([x for x in dir(sso_fake) if not x.startswith("_")]))
 
     def test_get_ubuntu_backend(self):
-        token = { 'token' : 'tokenvalue',
-                  'token_secret' : 'tokensecretvalue',
-                  'consumer_key' : 'consumerkeyvalue',
-                  'consumer_secret' : 'consumersecretvalue',
-                  }
         # test that we get the real one
-        self.assertEqual(type(get_ubuntu_sso_backend(token)),
+        self.assertEqual(type(get_ubuntu_sso_backend()),
                          UbuntuSSOAPI)
         # test that we get the fake one
         os.environ["SOFTWARE_CENTER_FAKE_REVIEW_API"] = "1"
-        self.assertEqual(type(get_ubuntu_sso_backend(token)),
+        self.assertEqual(type(get_ubuntu_sso_backend()),
                          UbuntuSSOAPIFake)
         # clean the environment
         del os.environ["SOFTWARE_CENTER_FAKE_REVIEW_API"]
 
=== added file 'utils/piston-helpers/piston_generic_helper.py'
--- utils/piston-helpers/piston_generic_helper.py	1970-01-01 00:00:00 +0000
+++ utils/piston-helpers/piston_generic_helper.py	2012-01-05 15:32:23 +0000
@@ -0,0 +1,209 @@
+#!/usr/bin/python
+# Copyright (C) 2011 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 argparse
+import logging
+import os
+import json
+import pickle
+import sys
+
+from gi.repository import GObject
+
+# useful for debugging
+if "SOFTWARE_CENTER_DEBUG_HTTP" in os.environ:
+    import httplib2
+    httplib2.debuglevel = 1
+
+import piston_mini_client.auth
+
+try:
+    import softwarecenter
+except ImportError:
+    if os.path.exists("../softwarecenter"):
+        sys.path.insert(0, "../")
+    else:
+        sys.path.insert(0, "/usr/share/software-center")
+
+import softwarecenter.paths
+from softwarecenter.paths import SOFTWARE_CENTER_CACHE_DIR
+from softwarecenter.backend.login_sso import get_sso_backend
+
+from softwarecenter.enums import (SOFTWARE_CENTER_NAME_KEYRING,
+                                  SOFTWARE_CENTER_SSO_DESCRIPTION,
+                                  )
+
+# the piston import
+from softwarecenter.backend.piston.ubuntusso_pristine import UbuntuSsoAPI
+from softwarecenter.backend.piston.rnrclient import RatingsAndReviewsAPI
+from softwarecenter.backend.piston.scaclient import SoftwareCenterAgentAPI
+
+RatingsAndReviewsAPI # pyflakes
+UbuntuSsoAPI # pyflakes
+SoftwareCenterAgentAPI # pyflakes
+
+# patch default_service_root to the one we use
+from softwarecenter.enums import SSO_LOGIN_HOST
+UbuntuSsoAPI.default_service_root = SSO_LOGIN_HOST+"/api/1.0"
+
+from gettext import gettext as _
+
+# helper that is only used to verify that the token is ok
+# and trigger cleanup if not
+class SSOLoginHelper(object):
+
+    def __init__(self, xid=0):
+        self.oauth = None
+        self.xid = xid
+        self.loop = GObject.MainLoop(GObject.main_context_default())
+    
+    def _login_successful(self, sso_backend, oauth_result):
+        LOG.debug("_login_successful")
+        self.oauth = oauth_result
+        # FIXME: actually verify the token against ubuntu SSO
+        self.loop.quit()
+
+    def verify_token_sync(self, token):
+        LOG.debug("verify_token")
+        auth = piston_mini_client.auth.OAuthAuthorizer(token["token"],
+                                                       token["token_secret"],
+                                                       token["consumer_key"],
+                                                       token["consumer_secret"])
+        api = UbuntuSsoAPI(auth=auth)
+        try:
+            res = api.whoami()
+        except:
+            LOG.exception("api.whoami failed")
+            return None
+        return res
+
+    def clear_token(self):
+        clear_token_from_ubuntu_sso(SOFTWARE_CENTER_NAME_KEYRING)
+
+    def get_oauth_token_sync(self):
+        self.oauth = None
+        sso = get_sso_backend(
+            self.xid, 
+            SOFTWARE_CENTER_NAME_KEYRING,
+            _(SOFTWARE_CENTER_SSO_DESCRIPTION))
+        sso.connect("login-successful", self._login_successful)
+        sso.connect("login-failed", lambda s: self.loop.quit())
+        sso.connect("login-canceled", lambda s: self.loop.quit())
+        sso.login_or_register()
+        self.loop.run()
+        return self.oauth
+
+    def get_oauth_token_and_verify_sync(self):
+        token = self.get_oauth_token_sync()
+        # check if the token is valid and reset it if it is not
+        if token and not self.verify_token_sync(token):
+            self.clear_token()
+            # re-trigger login
+            token = self.get_oauth_token_sync()
+        return token
+
+
+
+LOG = logging.getLogger(__name__)
+
+if __name__ == "__main__":
+    logging.basicConfig()
+
+    # command line parser
+    parser = argparse.ArgumentParser(
+        description="Backend helper for piston-mini-client based APIs")
+    parser.add_argument("--debug", action="store_true", default=False,
+                        help="enable debug output")
+    parser.add_argument("--datadir", default="/usr/share/software-center",
+                        help="setup alternative datadir")
+    parser.add_argument("--ignore-cache", action="store_true", default=False,
+                        help="force ignore cache")
+    parser.add_argument("--needs-auth", default=False, action="store_true",
+                        help="need oauth credentials")
+    parser.add_argument("--output", default="pickle",
+                        help="output result as [pickle|json|text]")
+    parser.add_argument("--parent-xid", default=0,
+                        help="xid of the parent window")
+    parser.add_argument('klass', help='class to use')
+    parser.add_argument('function', help='function to call')
+    parser.add_argument('kwargs', nargs="?",
+                        help='kwargs for the function call as json')
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+        LOG.setLevel(logging.DEBUG)
+
+    if args.ignore_cache:
+        cachedir = None
+    else:
+        cachedir = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "piston-helper")
+        
+    # check what we need to call
+    klass = globals()[args.klass]
+    func = args.function
+    kwargs = json.loads(args.kwargs or '{}')
+
+    softwarecenter.paths.datadir = args.datadir
+
+    if args.needs_auth:
+        helper = SSOLoginHelper(args.parent_xid)
+        token = helper.get_oauth_token_and_verify_sync()
+        # if we don't have a token, error here
+        if not token:
+            sys.stderr.write("ERROR: can not obtain a oauth token\n")
+            sys.exit(1)
+
+        auth = piston_mini_client.auth.OAuthAuthorizer(token["token"],
+                                                       token["token_secret"],
+                                                       token["consumer_key"],
+                                                       token["consumer_secret"])
+        api = klass(cachedir=cachedir, auth=auth)
+    else:
+        api = klass()
+        
+    piston_reply = None
+    # handle the args
+    f = getattr(api, func)
+    try:
+        piston_reply = f(**kwargs)
+    except:
+        LOG.exception("urclient_apps")
+        sys.exit(1)
+
+    # print to stdout where its consumed by the parent
+    if piston_reply is None:
+        LOG.warn("no data")
+        sys.exit(0)
+
+    # check what format to use
+    if args.output == "pickle":
+        res = pickle.dumps(piston_reply)
+    elif args.output == "json":
+        res = json.dumps(piston_reply)
+    elif args.output == "text":
+        res = piston_reply
+
+    # and output it
+    try:
+        print res
+    except IOError:
+        # this can happen if the parent gets killed, no need to trigger
+        # apport for this
+        pass
 
=== removed file 'utils/piston-helpers/piston_get_review_stats_helper.py'
--- utils/piston-helpers/piston_get_review_stats_helper.py	2011-07-13 14:25:55 +0000
+++ utils/piston-helpers/piston_get_review_stats_helper.py	1970-01-01 00:00:00 +0000
@@ -1,65 +0,0 @@
-#!/usr/bin/python
-
-import os
-import pickle
-import logging
-import sys
-
-from optparse import OptionParser
-
-from softwarecenter.paths import SOFTWARE_CENTER_CACHE_DIR
-from softwarecenter.backend.piston.rnrclient import RatingsAndReviewsAPI
-
-LOG = logging.getLogger(__name__)
-
-if __name__ == "__main__":
-    logging.basicConfig()
-
-    # common options for optparse go here
-    parser = OptionParser()
-
-    # check options
-    parser.add_option("--origin", default="any")
-    parser.add_option("--distroseries", default="any")
-    parser.add_option("--days-delta", default=None)
-    parser.add_option("--debug",
-                      action="store_true", default=False)
-    parser.add_option("--no-pickle",
-                      action="store_true", default=False)
-    (options, args) = parser.parse_args()
-
-    if options.debug:
-        LOG.setLevel(logging.DEBUG)
-
-    cachedir = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "rnrclient")
-    rnrclient = RatingsAndReviewsAPI(cachedir=cachedir)
-
-    kwargs = {"origin": options.origin,
-              "distroseries": options.distroseries,
-             }
-    if options.days_delta:
-        kwargs["days"] = int(options.days_delta)
-
-    # depending on the time delta, use a different call
-    piston_review_stats = []
-    try:
-        piston_review_stats = rnrclient.review_stats(**kwargs)
-    except:
-        LOG.exception("get_review_stats")
-        sys.exit(1)
-
-    # useful for debugging
-    if options.no_pickle:
-        print "\n".join(["pkgname=%s total=%s avg=%s" % (s.package_name, 
-                                                         s.ratings_total, 
-                                                         s.ratings_average)
-                         for s in piston_review_stats])
-    else:
-        # print to stdout where its consumed by the parent
-        try:
-            print pickle.dumps(piston_review_stats)
-        except IOError:
-            # this can happen if the parent gets killed, no need to trigger
-            # apport for this
-            sys.exit(1)
-
 
=== removed file 'utils/piston-helpers/piston_get_scagent_available_apps.py'
--- utils/piston-helpers/piston_get_scagent_available_apps.py	2012-01-05 09:53:52 +0000
+++ utils/piston-helpers/piston_get_scagent_available_apps.py	1970-01-01 00:00:00 +0000
@@ -1,197 +0,0 @@
-#!/usr/bin/python
-
-from gi.repository import GObject
-
-import argparse
-import logging
-import os
-import pickle
-import sys
-
-import piston_mini_client.auth
-
-from softwarecenter.enums import (SOFTWARE_CENTER_NAME_KEYRING,
-                                  SOFTWARE_CENTER_SSO_DESCRIPTION,
-                                  )
-from softwarecenter.paths import SOFTWARE_CENTER_CACHE_DIR
-from softwarecenter.backend.piston.scaclient import SoftwareCenterAgentAPI
-from softwarecenter.backend.login_sso import get_sso_backend
-from softwarecenter.backend.restfulclient import UbuntuSSOAPI
-from softwarecenter.utils import clear_token_from_ubuntu_sso
-
-from gettext import gettext as _
-
-LOG = logging.getLogger(__name__)
-
-class SSOLoginHelper(object):
-    def __init__(self, xid=0):
-        self.oauth = None
-        self.xid = xid
-        self.loop = GObject.MainLoop(GObject.main_context_default())
-    
-    def _login_successful(self, sso_backend, oauth_result):
-        LOG.debug("_login_successful")
-        self.oauth = oauth_result
-        # FIXME: actually verify the token against ubuntu SSO
-        self.loop.quit()
-
-    def verify_token(self, token):
-        LOG.debug("verify_token")
-        def _whoami_done(sso, me):
-            self._whoami = me
-            self.loop.quit()
-        self._whoami = None
-        sso = UbuntuSSOAPI(token)
-        sso.connect("whoami", _whoami_done)
-        sso.connect("error", lambda sso, err: self.loop.quit())
-        sso.whoami()
-        self.loop.run()
-        LOG.debug("verify_token finished")
-        # check if the token is valid
-        if self._whoami is None:
-            return False
-        else:
-            return True
-
-    def clear_token(self):
-        clear_token_from_ubuntu_sso(SOFTWARE_CENTER_NAME_KEYRING)
-
-    def get_oauth_token_sync(self):
-        self.oauth = None
-        sso = get_sso_backend(
-            self.xid, 
-            SOFTWARE_CENTER_NAME_KEYRING,
-            _(SOFTWARE_CENTER_SSO_DESCRIPTION))
-        sso.connect("login-successful", self._login_successful)
-        sso.connect("login-failed", lambda s: self.loop.quit())
-        sso.connect("login-canceled", lambda s: self.loop.quit())
-        sso.login_or_register()
-        self.loop.run()
-        return self.oauth
-
-if __name__ == "__main__":
-    logging.basicConfig()
-
-    # command line parser
-    parser = argparse.ArgumentParser(description="Helper for software-center-agent")
-    parser.add_argument("--debug", action="store_true", default=False,
-                        help="enable debug output")
-    parser.add_argument("--ignore-cache", action="store_true", default=False,
-                        help="force ignore cache")
-    parser.add_argument("--parent-xid", default=0,
-                        help="xid of the parent window")
-
-    subparser = parser.add_subparsers(title="Commands")
-    # available_apps
-    command = subparser.add_parser("available_apps")
-    command.add_argument("lang")
-    command.add_argument("series")
-    command.add_argument("arch")
-    command.set_defaults(command="available_apps")
-
-    # available_apps_qa
-    command = subparser.add_parser("available_apps_qa")
-    command.add_argument("lang")
-    command.add_argument("series")
-    command.add_argument("arch")
-    command.set_defaults(command="available_apps_qa")
-    # subscriptions
-    command = subparser.add_parser("subscriptions_for_me")
-    command.set_defaults(command="subscriptions_for_me")
-    # exhibits
-    command = subparser.add_parser("exhibits")
-    command.add_argument("lang")
-    command.add_argument("series")
-    command.set_defaults(command="exhibits")
-
-    args = parser.parse_args()
-
-    if args.debug:
-        LOG.setLevel(logging.DEBUG)
-
-    if args.ignore_cache:
-        cachedir = None
-    else:
-        cachedir = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "scaclient")
-
-
-    # check if auth is required
-    if args.command in ("available_apps_qa", "subscriptions_for_me"):
-        helper = SSOLoginHelper(args.parent_xid)
-        token = helper.get_oauth_token_sync()
-        # check if the token is valid and reset it if it is not
-        if token and not helper.verify_token(token):
-            helper.clear_token()
-            # re-trigger login
-            token = helper.get_oauth_token_sync()
-        # if we don't have a token, error here
-        if not token:
-            sys.stderr.write("ERROR: can not obtain a oauth token\n")
-            sys.exit(1)
-        
-        auth = piston_mini_client.auth.OAuthAuthorizer(token["token"],
-                                                       token["token_secret"],
-                                                       token["consumer_key"],
-                                                       token["consumer_secret"])
-        scaclient = SoftwareCenterAgentAPI(cachedir=cachedir, auth=auth)
-    else:
-        scaclient = SoftwareCenterAgentAPI(cachedir=cachedir)
-        
-    piston_reply = None
-
-    # common kwargs
-    if args.command in ("available_apps", "available_apps_qa"):
-        kwargs = {"lang": args.lang,
-                  "series": args.series,
-                  "arch": args.arch
-                  }
-
-    # handle the args
-    if args.command == "available_apps":
-        try:
-            piston_reply = scaclient.available_apps(**kwargs)
-        except:
-            LOG.exception("available_apps")
-            sys.exit(1)
-
-    elif args.command == "available_apps_qa":
-        try:
-            piston_reply = scaclient.available_apps_qa(**kwargs)
-        except:
-            LOG.exception("available_apps_qa")
-            sys.exit(1)
-    elif args.command == "subscriptions_for_me":
-        try:
-            piston_reply = scaclient.subscriptions_for_me(complete_only=True)
-            # the new piston API send the data in a nasty format, most
-            # interessting stuff is in the "application" dict, move it
-            # back int othe main object here so that the parser understands it
-            for item in piston_reply:
-                for k, v in item.application.iteritems():
-                    setattr(item, k, v)
-        except:
-            LOG.exception("subscriptions_for_me")
-            sys.exit(1)
-    if args.command == "exhibits":
-        try:
-            piston_reply = scaclient.exhibits(lang=args.lang, series=args.series)
-        except:
-            LOG.exception("exhibits")
-            sys.exit(1)
-
-    if args.debug:
-        LOG.debug("reply: %s" % piston_reply)
-        for item in piston_reply:
-            for var in vars(item):
-                print "%s: %s" % (var, getattr(item, var))
-            print "\n\n"
-
-
-    # print to stdout where its consumed by the parent
-    if piston_reply is not None:
-        try:
-            print pickle.dumps(piston_reply)
-        except IOError:
-            # this can happen if the parent gets killed, no need to trigger
-            # apport for this
-            pass
 
=== removed file 'utils/piston-helpers/piston_get_useful_votes_helper.py'
--- utils/piston-helpers/piston_get_useful_votes_helper.py	2011-08-19 11:25:58 +0000
+++ utils/piston-helpers/piston_get_useful_votes_helper.py	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-#!/usr/bin/python
-
-import pickle
-import logging
-import sys
-
-from optparse import OptionParser
-from softwarecenter.backend.piston.rnrclient import RatingsAndReviewsAPI
-from piston_mini_client import APIError
-
-LOG = logging.getLogger(__name__)
-
-if __name__ == "__main__":
-    logging.basicConfig()
-
-    # common options for optparse go here
-    parser = OptionParser()
-
-    # check options
-    parser.add_option("--username", default=None)
-    (options, args) = parser.parse_args()
-
-    rnrclient = RatingsAndReviewsAPI()
-            
-    useful_votes = []
-    
-    if options.username:
-        try:
-            useful_votes = rnrclient.get_usefulness(username=options.username)
-        except ValueError as e:
-            LOG.error("failed to parse '%s'" % e.doc)
-        except APIError, e:
-            LOG.warn("_get_useful_votes_helper: no usefulness able to be retrieved for username: %s" % (options.username))
-            LOG.debug("_get_reviews_threaded: no reviews able to be retrieved: %s" % e)
-        except:
-            LOG.exception("_get_useful_votes_helper")
-            sys.exit(1)
-
-    # print to stdout where its consumed by the parent
-    try:
-        print pickle.dumps(useful_votes)
-    except IOError:
-        # this can happen if the parent gets killed, no need to trigger
-        # apport for this
-        pass
-
 
=== modified file 'utils/submit_review_gtk3.py'
--- utils/submit_review_gtk3.py	2011-10-24 07:49:37 +0000
+++ utils/submit_review_gtk3.py	2012-01-05 15:32:23 +0000
@@ -50,7 +50,7 @@
 from gettext import gettext as _
 from optparse import OptionParser
 
-from softwarecenter.backend.restfulclient import get_ubuntu_sso_backend
+from softwarecenter.backend.ubuntusso import get_ubuntu_sso_backend
 
 import piston_mini_client
 
@@ -490,6 +490,8 @@
         self.ssoapi = get_ubuntu_sso_backend(self.token)
         self.ssoapi.connect("whoami", self._whoami_done)
         self.ssoapi.connect("error", self._whoami_error)
+        # this will automatically verify the token and retrigger login 
+        # if its expired
         self.ssoapi.whoami()
 
     def _whoami_done(self, ssologin, result):
@@ -500,22 +502,6 @@
 
     def _whoami_error(self, ssologin, e):
         logging.error("whoami error '%s'" % e)
-        # HACK: clear the token from the keyring assuming that it expired
-        #       or got deauthorized by the user on the website
-        # this really should be done by ubuntu-sso-client itself
-        import lazr.restfulclient.errors
-        # compat  with maverick, it does not have Unauthorized yet
-        if hasattr(lazr.restfulclient.errors, "Unauthorized"):
-            errortype = lazr.restfulclient.errors.Unauthorized
-        else:
-            errortype = lazr.restfulclient.errors.HTTPError
-        if (type(e) == errortype and
-            self._whoami_token_reset_nr == 0):
-            logging.warn("authentication error, reseting token and retrying")
-            clear_token_from_ubuntu_sso(self.appname)
-            self._whoami_token_reset_nr += 1
-            self.login(show_register=False)
-            return
         # show error
         self.status_spinner.hide()
         self.login_status_label.set_markup('<b><big>%s</big></b>' % _("Failed to log in"))