Merge lp:~glatzor/software-center/portability into lp:software-center

[Sebastian Heinlein]

This branch allows to run software-center on non-Ubuntu systems, e.g. Debian! It makes some components optionally (oneconf, ratings, reviews, purchases ...)

[lp:~glatzor/software-center/portability]

2553. By Sebastian Heinlein on 2011-10-26

Fix a copy and paste error in the Debian supported query

2554. By Sebastian Heinlein on 2011-10-27

Store the lsb_info in the Distro class

2555. By Sebastian Heinlein on 2011-10-27

Add maintenance status information for Debian packages

It is based on the suite/archive and comp of the Release file

2556. By Sebastian Heinlein on 2011-10-27

Remove obsolete get_maintenace_status method

2557. By Sebastian Heinlein on 2011-10-27

Mention the DFSG in the license information

2558. By Sebastian Heinlein on 2011-10-27

Don't hardcode Ubuntu for the component detection

=== modified file 'data/ui/gtk3/SoftwareCenter.ui'
--- data/ui/gtk3/SoftwareCenter.ui	2011-10-08 17:15:20 +0000
+++ data/ui/gtk3/SoftwareCenter.ui	2011-10-27 07:59:24 +0000
@@ -470,7 +470,7 @@
                       </object>
                     </child>
                     <child>
-                      <object class="GtkSeparatorMenuItem" id="menuitem3">
+                      <object class="GtkSeparatorMenuItem" id="separator_developer">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                       </object>

=== modified file 'softwarecenter/backend/channel_impl/aptchannels.py'
--- softwarecenter/backend/channel_impl/aptchannels.py	2011-10-11 18:44:41 +0000
+++ softwarecenter/backend/channel_impl/aptchannels.py	2011-10-27 07:59:24 +0000
@@ -266,7 +266,7 @@
                                                       installed_only=installed_only))
 
         # always display the partner channel, even if its source is not enabled                                                       
-        if not partner_channel:
+        if not partner_channel and distro_channel_name == "Ubuntu":
             partner_channel = SoftwareChannel("Partner archive",
                                               "Canonical",
                                               "partner", 
@@ -285,7 +285,8 @@
             channels.append(dist_channel)
         if partner_channel is not None:
             channels.append(partner_channel)
-        channels.append(for_purchase_channel)
+        if get_distro().PURCHASE_APP_URL:
+            channels.append(for_purchase_channel)
         if new_apps_channel is not None:
             channels.append(new_apps_channel)
         channels.extend(ppa_channels)

=== added directory 'softwarecenter/backend/oneconfhandler'
=== removed file 'softwarecenter/backend/oneconfhandler.py'
--- softwarecenter/backend/oneconfhandler.py	2011-09-26 14:34:05 +0000
+++ softwarecenter/backend/oneconfhandler.py	1970-01-01 00:00:00 +0000
@@ -1,206 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (C) 2011 Canonical
-#
-# Authors:
-#  Didier Roche
-#
-# 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
-
-
-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.restfulclient import get_ubuntu_sso_backend
-from softwarecenter.utils import clear_token_from_ubuntu_sso
-
-import datetime
-from gi.repository import GObject
-import logging
-
-from gettext import gettext as _
-
-LOG = logging.getLogger(__name__)
-
-class OneConfHandler(GObject.GObject):
-
-    __gsignals__ = {
-        "show-oneconf-changed" : (GObject.SIGNAL_RUN_LAST,
-                                  GObject.TYPE_NONE,
-                                  (GObject.TYPE_PYOBJECT,),
-                                 ),
-        "last-time-sync-changed" : (GObject.SIGNAL_RUN_LAST,
-                                    GObject.TYPE_NONE,
-                                    (GObject.TYPE_PYOBJECT,),
-                                   ),
-        }
-        
-        
-    def __init__(self, oneconfviewpickler):
-        '''Controller of the installed pane'''
-    
-        LOG.debug("OneConf Handler init")
-        super(OneConfHandler, self).__init__()
-        
-        # FIXME: should be an enum common to OneConf and here
-        self.appname = "Ubuntu Software Center"
-        
-        # OneConf stuff
-        self.oneconf = DbusConnect()
-        self.oneconf.hosts_dbus_object.connect_to_signal('hostlist_changed',
-                                                         self.refresh_hosts)
-        self.oneconf.hosts_dbus_object.connect_to_signal('packagelist_changed',
-                                                         self._on_store_packagelist_changed)
-        self.oneconf.hosts_dbus_object.connect_to_signal('latestsync_changed',
-                                                          self.on_new_latest_oneconf_sync_timestamp)
-        self.already_registered_hostids = []
-        self.is_current_registered = False
-        
-        self.oneconfviewpickler = oneconfviewpickler
-        
-        # refresh host list
-        self._refreshing_hosts = False
-        GObject.timeout_add_seconds(MIN_TIME_WITHOUT_ACTIVITY, self.get_latest_oneconf_sync)
-        GObject.idle_add(self.refresh_hosts)
-
-    def refresh_hosts(self):
-        """refresh hosts list in the panel view"""
-        LOG.debug('oneconf: refresh hosts')
-
-        # this function can be called in different threads
-        if self._refreshing_hosts:
-            return
-        self._refreshing_hosts = True
-
-        #view_switcher = self.app.view_switcher
-        #model = view_switcher.get_model()
-        #previous_iter = model.installed_iter
-
-        all_hosts = self.oneconf.get_all_hosts()
-        for hostid in all_hosts:
-            current, hostname, share_inventory = all_hosts[hostid]
-            if not hostid in self.already_registered_hostids and not current:
-                self.oneconfviewpickler.register_computer(hostid, hostname)
-                self.already_registered_hostids.append(hostid)
-            if current:
-                is_current_registered = share_inventory
-        
-        # ensure we are logged to ubuntu sso to activate the view
-        if self.is_current_registered != is_current_registered:
-            self.sync_between_computers(is_current_registered)
-        
-        self._refreshing_hosts = False
-
-    def get_latest_oneconf_sync(self):
-        '''Get latest sync state in OneConf.
-        
-        This function is also the "ping" letting OneConf service alive'''
-        LOG.debug("get latest sync state")
-        timestamp = self.oneconf.get_last_sync_date()
-        self.on_new_latest_oneconf_sync_timestamp(timestamp)
-        return True
-        
-    def on_new_latest_oneconf_sync_timestamp(self, timestamp):
-        '''Callback computing the right message for latest sync time'''
-        try:
-            last_sync = datetime.datetime.fromtimestamp(float(timestamp))
-            today = datetime.datetime.strptime(str(datetime.date.today()), '%Y-%m-%d')
-            the_daybefore = today - datetime.timedelta(days=1)
-
-            if last_sync > today:
-                msg = _("Last sync %s") % last_sync.strftime('%H:%M')
-            elif last_sync < today and last_sync > the_daybefore:
-                msg = _("Last sync yesterday %s") % last_sync.strftime('%H:%M')
-            else:
-                msg = _("Last sync %s") % last_sync.strftime('%Y-%m-%d  %H:%M')                    
-        except (TypeError, ValueError):
-            msg = _("To sync with another computer, choose “Sync Between Computers” from that computer.")
-        self.emit("last-time-sync-changed", msg)
-
-    def _share_inventory(self, share_inventory):
-        '''set oneconf state and emit signal for installed view to show or not oneconf'''
-
-        if share_inventory == self.is_current_registered:
-            return
-        self.is_current_registered = share_inventory
-        LOG.debug("change share inventory state to %s", share_inventory)        
-        self.oneconf.set_share_inventory(share_inventory)
-        self.get_latest_oneconf_sync()
-        self.emit("show-oneconf-changed", share_inventory)
-
-    def sync_between_computers(self, sync_on):
-        '''toggle the sync on and off if needed between computers'''
-        LOG.debug("Toggle sync between computers: %s", sync_on)
-        
-        if sync_on:
-            self._try_login()
-        else:
-            self._share_inventory(False)
-            
-    def _on_store_packagelist_changed(self, hostid):
-        '''pass the message to the view controller'''
-        self.oneconfviewpickler.store_packagelist_changed(hostid)
-    
-
-    # SSO login part    
-        
-    def _try_login(self):
-        '''Try to get the credential or login on ubuntu sso'''
-        logging.debug("OneConf login()")
-        help_text = _("With multiple Ubuntu computers, you can publish their inventories online to compare the software installed on each\n"
-                      "No-one else will be able to see what you have installed.")
-        self.sso = get_sso_backend(0,
-                                   self.appname, help_text)
-        self.sso.connect("login-successful", self._maybe_login_successful)
-        self.sso.connect("login-canceled", self._login_canceled)
-        self.sso.login_or_register()
-        
-    def _login_canceled(self, sso):
-        self._share_inventory(False)
-        
-    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.connect("whoami", self._whoami_done)
-        self.ssoapi.connect("error", self._whoami_error)
-        self.ssoapi.whoami()
-
-    def _whoami_done(self, ssologin, result):
-        logging.debug("_whoami_done")
-        self._share_inventory(True)
-
-    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
-
-
-# singleton
-oneconf_handler = None
-def get_oneconf_handler(oneconfviewpickler = None):
-    global oneconf_handler
-    if oneconf_handler is None and oneconfviewpickler:
-        oneconf_handler = OneConfHandler(oneconfviewpickler)
-    return oneconf_handler
-

=== added file 'softwarecenter/backend/oneconfhandler/__init__.py'
--- softwarecenter/backend/oneconfhandler/__init__.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/backend/oneconfhandler/__init__.py	2011-10-27 07:59:24 +0000
@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Canonical
+#
+# Authors:
+#  Didier Roche
+#
+# 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
+
+
+# singleton
+oneconf_handler = None
+def get_oneconf_handler(oneconfviewpickler = None):
+    global oneconf_handler
+    try:
+        from softwarecenter.backend.oneconfhandler.core import OnceConfHandler
+    except ImportError:
+        return None
+    if oneconf_handler is None and oneconfviewpickler:
+        oneconf_handler = OneConfHandler(oneconfviewpickler)
+    return oneconf_handler
+

=== added file 'softwarecenter/backend/oneconfhandler/core.py'
--- softwarecenter/backend/oneconfhandler/core.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/backend/oneconfhandler/core.py	2011-10-27 07:59:24 +0000
@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Canonical
+#
+# Authors:
+#  Didier Roche
+#
+# 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
+
+
+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.restfulclient import get_ubuntu_sso_backend
+from softwarecenter.utils import clear_token_from_ubuntu_sso
+
+import datetime
+from gi.repository import GObject
+import logging
+
+from gettext import gettext as _
+
+LOG = logging.getLogger(__name__)
+
+class OneConfHandler(GObject.GObject):
+
+    __gsignals__ = {
+        "show-oneconf-changed" : (GObject.SIGNAL_RUN_LAST,
+                                  GObject.TYPE_NONE,
+                                  (GObject.TYPE_PYOBJECT,),
+                                 ),
+        "last-time-sync-changed" : (GObject.SIGNAL_RUN_LAST,
+                                    GObject.TYPE_NONE,
+                                    (GObject.TYPE_PYOBJECT,),
+                                   ),
+        }
+        
+        
+    def __init__(self, oneconfviewpickler):
+        '''Controller of the installed pane'''
+    
+        LOG.debug("OneConf Handler init")
+        super(OneConfHandler, self).__init__()
+        
+        # FIXME: should be an enum common to OneConf and here
+        self.appname = "Ubuntu Software Center"
+        
+        # OneConf stuff
+        self.oneconf = DbusConnect()
+        self.oneconf.hosts_dbus_object.connect_to_signal('hostlist_changed',
+                                                         self.refresh_hosts)
+        self.oneconf.hosts_dbus_object.connect_to_signal('packagelist_changed',
+                                                         self._on_store_packagelist_changed)
+        self.oneconf.hosts_dbus_object.connect_to_signal('latestsync_changed',
+                                                          self.on_new_latest_oneconf_sync_timestamp)
+        self.already_registered_hostids = []
+        self.is_current_registered = False
+        
+        self.oneconfviewpickler = oneconfviewpickler
+        
+        # refresh host list
+        self._refreshing_hosts = False
+        GObject.timeout_add_seconds(MIN_TIME_WITHOUT_ACTIVITY, self.get_latest_oneconf_sync)
+        GObject.idle_add(self.refresh_hosts)
+
+    def refresh_hosts(self):
+        """refresh hosts list in the panel view"""
+        LOG.debug('oneconf: refresh hosts')
+
+        # this function can be called in different threads
+        if self._refreshing_hosts:
+            return
+        self._refreshing_hosts = True
+
+        #view_switcher = self.app.view_switcher
+        #model = view_switcher.get_model()
+        #previous_iter = model.installed_iter
+
+        all_hosts = self.oneconf.get_all_hosts()
+        for hostid in all_hosts:
+            current, hostname, share_inventory = all_hosts[hostid]
+            if not hostid in self.already_registered_hostids and not current:
+                self.oneconfviewpickler.register_computer(hostid, hostname)
+                self.already_registered_hostids.append(hostid)
+            if current:
+                is_current_registered = share_inventory
+        
+        # ensure we are logged to ubuntu sso to activate the view
+        if self.is_current_registered != is_current_registered:
+            self.sync_between_computers(is_current_registered)
+        
+        self._refreshing_hosts = False
+
+    def get_latest_oneconf_sync(self):
+        '''Get latest sync state in OneConf.
+        
+        This function is also the "ping" letting OneConf service alive'''
+        LOG.debug("get latest sync state")
+        timestamp = self.oneconf.get_last_sync_date()
+        self.on_new_latest_oneconf_sync_timestamp(timestamp)
+        return True
+        
+    def on_new_latest_oneconf_sync_timestamp(self, timestamp):
+        '''Callback computing the right message for latest sync time'''
+        try:
+            last_sync = datetime.datetime.fromtimestamp(float(timestamp))
+            today = datetime.datetime.strptime(str(datetime.date.today()), '%Y-%m-%d')
+            the_daybefore = today - datetime.timedelta(days=1)
+
+            if last_sync > today:
+                msg = _("Last sync %s") % last_sync.strftime('%H:%M')
+            elif last_sync < today and last_sync > the_daybefore:
+                msg = _("Last sync yesterday %s") % last_sync.strftime('%H:%M')
+            else:
+                msg = _("Last sync %s") % last_sync.strftime('%Y-%m-%d  %H:%M')                    
+        except (TypeError, ValueError):
+            msg = _("To sync with another computer, choose “Sync Between Computers” from that computer.")
+        self.emit("last-time-sync-changed", msg)
+
+    def _share_inventory(self, share_inventory):
+        '''set oneconf state and emit signal for installed view to show or not oneconf'''
+
+        if share_inventory == self.is_current_registered:
+            return
+        self.is_current_registered = share_inventory
+        LOG.debug("change share inventory state to %s", share_inventory)        
+        self.oneconf.set_share_inventory(share_inventory)
+        self.get_latest_oneconf_sync()
+        self.emit("show-oneconf-changed", share_inventory)
+
+    def sync_between_computers(self, sync_on):
+        '''toggle the sync on and off if needed between computers'''
+        LOG.debug("Toggle sync between computers: %s", sync_on)
+        
+        if sync_on:
+            self._try_login()
+        else:
+            self._share_inventory(False)
+            
+    def _on_store_packagelist_changed(self, hostid):
+        '''pass the message to the view controller'''
+        self.oneconfviewpickler.store_packagelist_changed(hostid)
+    
+
+    # SSO login part    
+        
+    def _try_login(self):
+        '''Try to get the credential or login on ubuntu sso'''
+        logging.debug("OneConf login()")
+        help_text = _("With multiple Ubuntu computers, you can publish their inventories online to compare the software installed on each\n"
+                      "No-one else will be able to see what you have installed.")
+        self.sso = get_sso_backend(0,
+                                   self.appname, help_text)
+        self.sso.connect("login-successful", self._maybe_login_successful)
+        self.sso.connect("login-canceled", self._login_canceled)
+        self.sso.login_or_register()
+        
+    def _login_canceled(self, sso):
+        self._share_inventory(False)
+        
+    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.connect("whoami", self._whoami_done)
+        self.ssoapi.connect("error", self._whoami_error)
+        self.ssoapi.whoami()
+
+    def _whoami_done(self, ssologin, result):
+        logging.debug("_whoami_done")
+        self._share_inventory(True)
+
+    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

=== modified file 'softwarecenter/backend/piston/rnrclient.py'
--- softwarecenter/backend/piston/rnrclient.py	2011-08-09 08:47:43 +0000
+++ softwarecenter/backend/piston/rnrclient.py	2011-10-27 07:59:24 +0000
@@ -52,7 +52,7 @@
     LOG.error("need python-piston-mini client\n"
               "available in natty or from:\n"
               "   ppa:software-store-developers/daily-build ")
-    sys.exit(1)
+    raise
 
 
 if __name__ == "__main__":

=== added directory 'softwarecenter/backend/reviews'
=== renamed file 'softwarecenter/backend/reviews.py' => 'softwarecenter/backend/reviews/__init__.py'
--- softwarecenter/backend/reviews.py	2011-10-13 13:39:21 +0000
+++ softwarecenter/backend/reviews/__init__.py	2011-10-27 07:59:24 +0000
@@ -53,8 +53,6 @@
     from StringIO import StringIO
     from urllib import quote_plus
 
-from softwarecenter.backend.piston.rnrclient import RatingsAndReviewsAPI
-from softwarecenter.backend.piston.rnrclient_pristine import ReviewDetails
 from softwarecenter.db.categories import CategoriesParser
 from softwarecenter.db.database import Application, StoreDatabase
 import softwarecenter.distro
@@ -77,7 +75,7 @@
 
 from softwarecenter.netstatus import network_state_is_connected
 
-from spawn_helper import SpawnHelper
+from softwarecenter.backend.spawn_helper import SpawnHelper
 
 LOG = logging.getLogger(__name__)
 
@@ -100,7 +98,7 @@
     USEFULNESS_CACHE = {}
     
     def __init__(self, try_server=False):
-        self.rnrclient = RatingsAndReviewsAPI()
+        #self.rnrclient = RatingsAndReviewsAPI()
         fname = "usefulness.p"
         self.USEFULNESS_CACHE_FILE = os.path.join(SOFTWARE_CENTER_CACHE_DIR,
                                                     fname)
@@ -438,43 +436,12 @@
             applist.append(db.get_pkgname(doc))
         return applist
 
-    # writing new reviews spawns external helper
-    # FIXME: instead of the callback we should add proper gobject signals
     def spawn_write_new_review_ui(self, translated_app, version, iconname, 
                                   origin, parent_xid, datadir, callback):
-        """ this spawns the UI for writing a new review and
-            adds it automatically to the reviews DB """
-        app = translated_app.get_untranslated_app(self.db)
-        cmd = [os.path.join(datadir, RNRApps.SUBMIT_REVIEW), 
-               "--pkgname", app.pkgname,
-               "--iconname", iconname,
-               "--parent-xid", "%s" % parent_xid,
-               "--version", version,
-               "--origin", origin,
-               "--datadir", datadir,
-               ]
-        if app.appname:
-            # needs to be (utf8 encoded) str, otherwise call fails
-            cmd += ["--appname", utf8(app.appname)]
-        spawn_helper = SpawnHelper(format="json")
-        spawn_helper.connect(
-            "data-available", self._on_submit_review_data, app, callback)
-        spawn_helper.run(cmd)
-
-    def _on_submit_review_data(self, spawn_helper, review_json, app, callback):
-        """ called when submit_review finished, when the review was send
-            successfully the callback is triggered with the new reviews
+        """Spawn the UI for writing a new review and adds it automatically
+        to the reviews DB.
         """
-        LOG.debug("_on_submit_review_data")
-        # read stdout from submit_review
-        review = ReviewDetails.from_dict(review_json)
-        # FIXME: ideally this would be stored in ubuntu-sso-client
-        #        but it dosn't so we store it here
-        save_person_to_config(review.reviewer_username)
-        if not app in self._reviews: 
-            self._reviews[app] = []
-        self._reviews[app].insert(0, Review.from_piston_mini_client(review))
-        callback(app, self._reviews[app])
+        pass
 
     def spawn_report_abuse_ui(self, review_id, parent_xid, datadir, callback):
         """ this spawns the UI for reporting a review as inappropriate
@@ -482,296 +449,20 @@
             operation is complete it will call callback with the updated
             review list
         """
-        cmd = [os.path.join(datadir, RNRApps.REPORT_REVIEW), 
-               "--review-id", review_id,
-               "--parent-xid", "%s" % parent_xid,
-               "--datadir", datadir,
-              ]
-        spawn_helper = SpawnHelper("json")
-        spawn_helper.connect("exited", 
-                             self._on_report_abuse_finished, 
-                             review_id, callback)
-        spawn_helper.run(cmd)
-
-    def _on_report_abuse_finished(self, spawn_helper, exitcode, review_id, callback):
-        """ called when report_absuse finished """
-        LOG.debug("hide id %s " % review_id)
-        if exitcode == 0:
-            for (app, reviews) in self._reviews.items():
-                for review in reviews:
-                    if str(review.id) == str(review_id):
-                        # remove the one we don't want to see anymore
-                        self._reviews[app].remove(review)
-                        callback(app, self._reviews[app], None, 'remove', review)
-                        break
-
+        pass
 
     def spawn_submit_usefulness_ui(self, review_id, is_useful, parent_xid, datadir, callback):
-        cmd = [os.path.join(datadir, RNRApps.SUBMIT_USEFULNESS), 
-               "--review-id", "%s" % review_id,
-               "--is-useful", "%s" % int(is_useful),
-               "--parent-xid", "%s" % parent_xid,
-               "--datadir", datadir,
-              ]
-        spawn_helper = SpawnHelper(format="none")
-        spawn_helper.connect("exited", 
-                             self._on_submit_usefulness_finished, 
-                             review_id, is_useful, callback)
-        spawn_helper.connect("error",
-                             self._on_submit_usefulness_error,
-                             review_id, callback)
-        spawn_helper.run(cmd)
-
-    def _on_submit_usefulness_finished(self, spawn_helper, res, review_id, is_useful, callback):
-        """ called when report_usefulness finished """
-        # "Created", "Updated", "Not modified" - 
-        # once lp:~mvo/rnr-server/submit-usefulness-result-strings makes it
-        response = spawn_helper._stdout
-        if response == '"Not modified"':
-            self._on_submit_usefulness_error(spawn_helper, response, review_id, callback)
-            return
-
-        LOG.debug("usefulness id %s " % review_id)
-        useful_votes = UsefulnessCache()
-        useful_votes.add_usefulness_vote(review_id, is_useful)
-        for (app, reviews) in self._reviews.items():
-            for review in reviews:
-                if str(review.id) == str(review_id):
-                    # update usefulness, older servers do not send
-                    # usefulness_{total,favorable} so we use getattr
-                    review.usefulness_total = getattr(review, "usefulness_total", 0) + 1
-                    if is_useful:
-                        review.usefulness_favorable = getattr(review, "usefulness_favorable", 0) + 1
-                        callback(app, self._reviews[app], useful_votes, 'replace', review)
-                        break
-
-    def _on_submit_usefulness_error(self, spawn_helper, error_str, review_id, callback):
-            LOG.warn("submit usefulness id=%s failed with error: %s" %
-                     (review_id, error_str))
-            for (app, reviews) in self._reviews.items():
-                for review in reviews:
-                    if str(review.id) == str(review_id):
-                        review.usefulness_submit_error = True
-                        callback(app, self._reviews[app], None, 'replace', review)
-                        break
+        """Spawn a helper to submit a usefulness vote."""
+        pass
 
     def spawn_delete_review_ui(self, review_id, parent_xid, datadir, callback):
-        cmd = [os.path.join(datadir, RNRApps.DELETE_REVIEW), 
-               "--review-id", "%s" % review_id,
-               "--parent-xid", "%s" % parent_xid,
-               "--datadir", datadir,
-              ]
-        spawn_helper = SpawnHelper(format="none")
-        spawn_helper.connect("exited", 
-                             self._on_delete_review_finished, 
-                             review_id, callback)
-        spawn_helper.connect("error", self._on_delete_review_error,
-                             review_id, callback)
-        spawn_helper.run(cmd)
-
-    def _on_delete_review_finished(self, spawn_helper, res, review_id, callback):
-        """ called when delete_review finished"""
-        LOG.debug("delete id %s " % review_id)
-        for (app, reviews) in self._reviews.items():
-            for review in reviews:
-                if str(review.id) == str(review_id):
-                    # remove the one we don't want to see anymore
-                    self._reviews[app].remove(review)
-                    callback(app, self._reviews[app], None, 'remove', review)
-                    break                    
-
-    def _on_delete_review_error(self, spawn_helper, error_str, review_id, callback):
-        """called if delete review errors"""
-        LOG.warn("delete review id=%s failed with error: %s" % (review_id, error_str))
-        for (app, reviews) in self._reviews.items():
-            for review in reviews:
-                if str(review.id) == str(review_id):
-                    review.delete_error = True
-                    callback(app, self._reviews[app], action='replace', 
-                             single_review=review)
-                    break
-
-    
+        """Spawn a helper to delete a review."""
+        pass
+
     def spawn_modify_review_ui(self, parent_xid, iconname, datadir, review_id, callback):
-        """ this spawns the UI for writing a new review and
-            adds it automatically to the reviews DB """
-        cmd = [os.path.join(datadir, RNRApps.MODIFY_REVIEW), 
-               "--parent-xid", "%s" % parent_xid,
-               "--iconname", iconname,
-               "--datadir", "%s" % datadir,
-               "--review-id", "%s" % review_id,
-               ]
-        spawn_helper = SpawnHelper(format="json")
-        spawn_helper.connect("data-available", 
-                             self._on_modify_review_finished, 
-                             review_id, callback)
-        spawn_helper.connect("error", self._on_modify_review_error,
-                             review_id, callback)
-        spawn_helper.run(cmd)
-
-    def _on_modify_review_finished(self, spawn_helper, review_json, review_id, callback):
-        """called when modify_review finished"""
-        LOG.debug("_on_modify_review_finished")
-        #review_json = spawn_helper._stdout
-        mod_review = ReviewDetails.from_dict(review_json)
-        for (app, reviews) in self._reviews.items():
-            for review in reviews:
-                if str(review.id) == str(review_id):
-                    # remove the one we don't want to see anymore
-                    self._reviews[app].remove(review)
-                    new_review = Review.from_piston_mini_client(mod_review)
-                    self._reviews[app].insert(0, new_review)
-                    callback(app, self._reviews[app], action='replace', 
-                             single_review=new_review)
-                    break
-                    
-    def _on_modify_review_error(self, spawn_helper, error_str, review_id, callback):
-        """called if modify review errors"""
-        LOG.debug("modify review id=%s failed with error: %s" % (review_id, error_str))
-        for (app, reviews) in self._reviews.items():
-            for review in reviews:
-                if str(review.id) == str(review_id):
-                    review.modify_error = True
-                    callback(app, self._reviews[app], action='replace', 
-                             single_review=review)
-                    break
-
-
-# this code had several incernations: 
-# - python threads, slow and full of latency (GIL)
-# - python multiprocesing, crashed when accessibility was turned on, 
-#                          does not work in the quest session (#743020)
-# - GObject.spawn_async() looks good so far (using the SpawnHelper code)
-class ReviewLoaderSpawningRNRClient(ReviewLoader):
-    """ loader that uses multiprocessing to call rnrclient and
-        a glib timeout watcher that polls periodically for the
-        data 
-    """
-
-    def __init__(self, cache, db, distro=None):
-        super(ReviewLoaderSpawningRNRClient, self).__init__(cache, db, distro)
-        cachedir = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "rnrclient")
-        self.rnrclient = RatingsAndReviewsAPI(cachedir=cachedir)
-        cachedir = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "rnrclient")
-        self.rnrclient = RatingsAndReviewsAPI(cachedir=cachedir)
-        self._reviews = {}
-
-    def _update_rnrclient_offline_state(self):
-        # this needs the lp:~mvo/piston-mini-client/offline-mode branch
-        self.rnrclient._offline_mode = not network_state_is_connected()
-
-    # reviews
-    def get_reviews(self, translated_app, callback, page=1, 
-                    language=None, sort=0):
-        """ public api, triggers fetching a review and calls callback
-            when its ready
-        """
-        # its fine to use the translated appname here, we only submit the
-        # pkgname to the server
-        app = translated_app
-        self._update_rnrclient_offline_state()
-        sort_method = self._review_sort_methods[sort]
-        if language is None:
-            language = self.language
-        # gather args for the helper
-        try:
-            origin = self.cache.get_origin(app.pkgname)
-        except:
-            # this can happen if e.g. the app has multiple origins, this
-            # will be handled later
-            origin = None
-        # special case for not-enabled PPAs
-        if not origin and self.db:
-            details = app.get_details(self.db)
-            ppa = details.ppaname
-            if ppa:
-                origin = "lp-ppa-%s" % ppa.replace("/", "-")
-        # if there is no origin, there is nothing to do
-        if not origin:
-            callback(app, [])
-            return
-        distroseries = self.distro.get_codename()
-        # run the command and add watcher
-        cmd = [os.path.join(softwarecenter.paths.datadir, PistonHelpers.GET_REVIEWS),
-               "--language", language, 
-               "--origin", origin, 
-               "--distroseries", distroseries, 
-               "--pkgname", str(app.pkgname), # ensure its str, not unicode
-               "--page", str(page),
-               "--sort", sort_method,
-              ]
-        spawn_helper = SpawnHelper()
-        spawn_helper.connect(
-            "data-available", self._on_reviews_helper_data, app, callback)
-        spawn_helper.run(cmd)
-
-    def _on_reviews_helper_data(self, spawn_helper, piston_reviews, app, callback):
-        # convert into our review objects
-        reviews = []
-        for r in piston_reviews:
-            reviews.append(Review.from_piston_mini_client(r))
-        # add to our dicts and run callback
-        self._reviews[app] = reviews
-        callback(app, self._reviews[app])
-        return False
-
-    # stats
-    def refresh_review_stats(self, callback):
-        """ public api, refresh the available statistics """
-        try:
-            mtime = os.path.getmtime(self.REVIEW_STATS_CACHE_FILE)
-            days_delta = int((time.time() - mtime) // (24*60*60))
-            days_delta += 1
-        except OSError:
-            days_delta = 0
-        LOG.debug("refresh with days_delta: %s" % days_delta)
-        #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, 
-              ]
-        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)
-
-    def _on_review_stats_data(self, spawn_helper, piston_review_stats, callback):
-        """ process stdout from the helper """
-        review_stats = self.REVIEW_STATS_CACHE
-
-        if self._cache_version_old and self._server_has_histogram(piston_review_stats):
-            self.REVIEW_STATS_CACHE = {}
-            self.save_review_stats_cache_file()
-            self.refresh_review_stats(callback)
-            return
-        
-        # convert to the format that s-c uses
-        for r in piston_review_stats:
-            s = ReviewStats(Application("", r.package_name))
-            s.ratings_average = float(r.ratings_average)
-            s.ratings_total = float(r.ratings_total)
-            if r.histogram:
-                s.rating_spread = json.loads(r.histogram)
-            else:
-                s.rating_spread = [0,0,0,0,0]
-            s.dampened_rating = calc_dr(s.rating_spread)
-            review_stats[s.app] = s
-        self.REVIEW_STATS_CACHE = review_stats
-        callback(review_stats)
-        self.save_review_stats_cache_file()
-    
-    def _server_has_histogram(self, piston_review_stats):
-        '''check response from server to see if histogram is supported'''
-        supported = getattr(piston_review_stats[0], "histogram", False)
-        if not supported:
-            return False
-        return True
+        """Spawn a helper to modify a review."""
+        pass
+
 
 class ReviewLoaderJsonAsync(ReviewLoader):
     """ get json (or gzip compressed json) """
@@ -871,7 +562,7 @@
         return random.choice(self.LOREM.split("\n\n"))
     def _random_summary(self):
         return random.choice(self.SUMMARIES)
-    def get_reviews(self, application, callback, page=1, language=None):
+    def get_reviews(self, application, callback, page=1, language=None, sort=0):
         if not application in self._review_stats_cache:
             self.get_review_stats(application)
         stats = self._review_stats_cache[application]
@@ -1034,6 +725,26 @@
 et ea rebum stet clita kasd gubergren no sea takimata sanctus est lorem
 ipsum dolor sit amet"""
 
+
+class ReviewLoaderNull(ReviewLoader):
+
+    """A dummy review loader which just returns empty results."""
+
+    def __init__(self, cache, db):
+        self._review_stats_cache = {}
+        self._reviews_cache = {}
+
+    def get_reviews(self, application, callback, page=1, language=None, sort=0):
+        callback(application, [])
+
+    def get_review_stats(self, application):
+        return None
+
+    def refresh_review_stats(self, callback):
+        review_stats = []
+        callback(review_stats)
+
+
 review_loader = None
 def get_review_loader(cache, db=None):
     """ 
@@ -1050,7 +761,12 @@
         elif "SOFTWARE_CENTER_GIO_REVIEWS" in os.environ:
             review_loader = ReviewLoaderJsonAsync(cache, db)
         else:
-            review_loader = ReviewLoaderSpawningRNRClient(cache, db)
+            try:
+                from softwarecenter.backend.reviews.rnr import ReviewLoaderSpawningRNRClient
+            except ImportError:
+                review_loader = ReviewLoaderNull(cache, db)
+            else:
+                review_loader = ReviewLoaderSpawningRNRClient(cache, db)
     return review_loader
 
 if __name__ == "__main__":

=== added file 'softwarecenter/backend/reviews/rnr.py'
--- softwarecenter/backend/reviews/rnr.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/backend/reviews/rnr.py	2011-10-27 07:59:24 +0000
@@ -0,0 +1,376 @@
+# -*- 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 gzip
+import logging
+import os
+import json
+import time
+
+from softwarecenter.backend.spawn_helper import SpawnHelper
+from softwarecenter.backend.reviews import ReviewLoader, Review, ReviewStats
+from softwarecenter.backend.piston.rnrclient import RatingsAndReviewsAPI
+from softwarecenter.backend.piston.rnrclient_pristine import ReviewDetails
+from softwarecenter.db.database import Application
+import softwarecenter.distro
+from softwarecenter.netstatus import network_state_is_connected
+from softwarecenter.paths import (SOFTWARE_CENTER_CACHE_DIR,
+                                  PistonHelpers,
+                                  RNRApps,
+                                  )
+from softwarecenter.utils import calc_dr
+
+LOG = logging.getLogger(__name__)
+
+
+# this code had several incernations: 
+# - python threads, slow and full of latency (GIL)
+# - python multiprocesing, crashed when accessibility was turned on, 
+#                          does not work in the quest session (#743020)
+# - GObject.spawn_async() looks good so far (using the SpawnHelper code)
+class ReviewLoaderSpawningRNRClient(ReviewLoader):
+    """ loader that uses multiprocessing to call rnrclient and
+        a glib timeout watcher that polls periodically for the
+        data 
+    """
+
+    def __init__(self, cache, db, distro=None):
+        super(ReviewLoaderSpawningRNRClient, self).__init__(cache, db, distro)
+        cachedir = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "rnrclient")
+        self.rnrclient = RatingsAndReviewsAPI(cachedir=cachedir)
+        cachedir = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "rnrclient")
+        self.rnrclient = RatingsAndReviewsAPI(cachedir=cachedir)
+        self._reviews = {}
+
+    def _update_rnrclient_offline_state(self):
+        # this needs the lp:~mvo/piston-mini-client/offline-mode branch
+        self.rnrclient._offline_mode = not network_state_is_connected()
+
+    # reviews
+    def get_reviews(self, translated_app, callback, page=1, 
+                    language=None, sort=0):
+        """ public api, triggers fetching a review and calls callback
+            when its ready
+        """
+        # its fine to use the translated appname here, we only submit the
+        # pkgname to the server
+        app = translated_app
+        self._update_rnrclient_offline_state()
+        sort_method = self._review_sort_methods[sort]
+        if language is None:
+            language = self.language
+        # gather args for the helper
+        try:
+            origin = self.cache.get_origin(app.pkgname)
+        except:
+            # this can happen if e.g. the app has multiple origins, this
+            # will be handled later
+            origin = None
+        # special case for not-enabled PPAs
+        if not origin and self.db:
+            details = app.get_details(self.db)
+            ppa = details.ppaname
+            if ppa:
+                origin = "lp-ppa-%s" % ppa.replace("/", "-")
+        # if there is no origin, there is nothing to do
+        if not origin:
+            callback(app, [])
+            return
+        distroseries = self.distro.get_codename()
+        # run the command and add watcher
+        cmd = [os.path.join(softwarecenter.paths.datadir, PistonHelpers.GET_REVIEWS),
+               "--language", language, 
+               "--origin", origin, 
+               "--distroseries", distroseries, 
+               "--pkgname", str(app.pkgname), # ensure its str, not unicode
+               "--page", str(page),
+               "--sort", sort_method,
+              ]
+        spawn_helper = SpawnHelper()
+        spawn_helper.connect(
+            "data-available", self._on_reviews_helper_data, app, callback)
+        spawn_helper.run(cmd)
+
+    def _on_reviews_helper_data(self, spawn_helper, piston_reviews, app, callback):
+        # convert into our review objects
+        reviews = []
+        for r in piston_reviews:
+            reviews.append(Review.from_piston_mini_client(r))
+        # add to our dicts and run callback
+        self._reviews[app] = reviews
+        callback(app, self._reviews[app])
+        return False
+
+    # stats
+    def refresh_review_stats(self, callback):
+        """ public api, refresh the available statistics """
+        try:
+            mtime = os.path.getmtime(self.REVIEW_STATS_CACHE_FILE)
+            days_delta = int((time.time() - mtime) // (24*60*60))
+            days_delta += 1
+        except OSError:
+            days_delta = 0
+        LOG.debug("refresh with days_delta: %s" % days_delta)
+        #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, 
+              ]
+        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)
+
+    def _on_review_stats_data(self, spawn_helper, piston_review_stats, callback):
+        """ process stdout from the helper """
+        review_stats = self.REVIEW_STATS_CACHE
+
+        if self._cache_version_old and self._server_has_histogram(piston_review_stats):
+            self.REVIEW_STATS_CACHE = {}
+            self.save_review_stats_cache_file()
+            self.refresh_review_stats(callback)
+            return
+
+        # convert to the format that s-c uses
+        for r in piston_review_stats:
+            s = ReviewStats(Application("", r.package_name))
+            s.ratings_average = float(r.ratings_average)
+            s.ratings_total = float(r.ratings_total)
+            if r.histogram:
+                s.rating_spread = json.loads(r.histogram)
+            else:
+                s.rating_spread = [0,0,0,0,0]
+            s.dampened_rating = calc_dr(s.rating_spread)
+            review_stats[s.app] = s
+        self.REVIEW_STATS_CACHE = review_stats
+        callback(review_stats)
+        self.save_review_stats_cache_file()
+
+    def _server_has_histogram(self, piston_review_stats):
+        '''check response from server to see if histogram is supported'''
+        supported = getattr(piston_review_stats[0], "histogram", False)
+        if not supported:
+            return False
+        return True
+
+    # writing new reviews spawns external helper
+    # FIXME: instead of the callback we should add proper gobject signals
+    def spawn_write_new_review_ui(self, translated_app, version, iconname, 
+                                  origin, parent_xid, datadir, callback):
+        """ this spawns the UI for writing a new review and
+            adds it automatically to the reviews DB """
+        app = translated_app.get_untranslated_app(self.db)
+        cmd = [os.path.join(datadir, RNRApps.SUBMIT_REVIEW), 
+               "--pkgname", app.pkgname,
+               "--iconname", iconname,
+               "--parent-xid", "%s" % parent_xid,
+               "--version", version,
+               "--origin", origin,
+               "--datadir", datadir,
+               ]
+        if app.appname:
+            # needs to be (utf8 encoded) str, otherwise call fails
+            cmd += ["--appname", utf8(app.appname)]
+        spawn_helper = SpawnHelper(format="json")
+        spawn_helper.connect(
+            "data-available", self._on_submit_review_data, app, callback)
+        spawn_helper.run(cmd)
+
+    def _on_submit_review_data(self, spawn_helper, review_json, app, callback):
+        """ called when submit_review finished, when the review was send
+            successfully the callback is triggered with the new reviews
+        """
+        LOG.debug("_on_submit_review_data")
+        return
+        # read stdout from submit_review
+        review = ReviewDetails.from_dict(review_json)
+        # FIXME: ideally this would be stored in ubuntu-sso-client
+        #        but it dosn't so we store it here
+        save_person_to_config(review.reviewer_username)
+        if not app in self._reviews: 
+            self._reviews[app] = []
+        self._reviews[app].insert(0, Review.from_piston_mini_client(review))
+        callback(app, self._reviews[app])
+
+    def spawn_report_abuse_ui(self, review_id, parent_xid, datadir, callback):
+        """ this spawns the UI for reporting a review as inappropriate
+            and adds the review-id to the internal hide list. once the
+            operation is complete it will call callback with the updated
+            review list
+        """
+        cmd = [os.path.join(datadir, RNRApps.REPORT_REVIEW), 
+               "--review-id", review_id,
+               "--parent-xid", "%s" % parent_xid,
+               "--datadir", datadir,
+              ]
+        spawn_helper = SpawnHelper("json")
+        spawn_helper.connect("exited", 
+                             self._on_report_abuse_finished, 
+                             review_id, callback)
+        spawn_helper.run(cmd)
+
+    def _on_report_abuse_finished(self, spawn_helper, exitcode, review_id, callback):
+        """ called when report_absuse finished """
+        LOG.debug("hide id %s " % review_id)
+        if exitcode == 0:
+            for (app, reviews) in self._reviews.items():
+                for review in reviews:
+                    if str(review.id) == str(review_id):
+                        # remove the one we don't want to see anymore
+                        self._reviews[app].remove(review)
+                        callback(app, self._reviews[app], None, 'remove', review)
+                        break
+
+
+    def spawn_submit_usefulness_ui(self, review_id, is_useful, parent_xid, datadir, callback):
+        cmd = [os.path.join(datadir, RNRApps.SUBMIT_USEFULNESS), 
+               "--review-id", "%s" % review_id,
+               "--is-useful", "%s" % int(is_useful),
+               "--parent-xid", "%s" % parent_xid,
+               "--datadir", datadir,
+              ]
+        spawn_helper = SpawnHelper(format="none")
+        spawn_helper.connect("exited", 
+                             self._on_submit_usefulness_finished, 
+                             review_id, is_useful, callback)
+        spawn_helper.connect("error",
+                             self._on_submit_usefulness_error,
+                             review_id, callback)
+        spawn_helper.run(cmd)
+
+    def _on_submit_usefulness_finished(self, spawn_helper, res, review_id, is_useful, callback):
+        """ called when report_usefulness finished """
+        # "Created", "Updated", "Not modified" - 
+        # once lp:~mvo/rnr-server/submit-usefulness-result-strings makes it
+        response = spawn_helper._stdout
+        if response == '"Not modified"':
+            self._on_submit_usefulness_error(spawn_helper, response, review_id, callback)
+            return
+
+        LOG.debug("usefulness id %s " % review_id)
+        useful_votes = UsefulnessCache()
+        useful_votes.add_usefulness_vote(review_id, is_useful)
+        for (app, reviews) in self._reviews.items():
+            for review in reviews:
+                if str(review.id) == str(review_id):
+                    # update usefulness, older servers do not send
+                    # usefulness_{total,favorable} so we use getattr
+                    review.usefulness_total = getattr(review, "usefulness_total", 0) + 1
+                    if is_useful:
+                        review.usefulness_favorable = getattr(review, "usefulness_favorable", 0) + 1
+                        callback(app, self._reviews[app], useful_votes, 'replace', review)
+                        break
+
+    def _on_submit_usefulness_error(self, spawn_helper, error_str, review_id, callback):
+            LOG.warn("submit usefulness id=%s failed with error: %s" %
+                     (review_id, error_str))
+            for (app, reviews) in self._reviews.items():
+                for review in reviews:
+                    if str(review.id) == str(review_id):
+                        review.usefulness_submit_error = True
+                        callback(app, self._reviews[app], None, 'replace', review)
+                        break
+
+    def spawn_delete_review_ui(self, review_id, parent_xid, datadir, callback):
+        cmd = [os.path.join(datadir, RNRApps.DELETE_REVIEW), 
+               "--review-id", "%s" % review_id,
+               "--parent-xid", "%s" % parent_xid,
+               "--datadir", datadir,
+              ]
+        spawn_helper = SpawnHelper(format="none")
+        spawn_helper.connect("exited", 
+                             self._on_delete_review_finished, 
+                             review_id, callback)
+        spawn_helper.connect("error", self._on_delete_review_error,
+                             review_id, callback)
+        spawn_helper.run(cmd)
+
+    def _on_delete_review_finished(self, spawn_helper, res, review_id, callback):
+        """ called when delete_review finished"""
+        LOG.debug("delete id %s " % review_id)
+        for (app, reviews) in self._reviews.items():
+            for review in reviews:
+                if str(review.id) == str(review_id):
+                    # remove the one we don't want to see anymore
+                    self._reviews[app].remove(review)
+                    callback(app, self._reviews[app], None, 'remove', review)
+                    break                    
+
+    def _on_delete_review_error(self, spawn_helper, error_str, review_id, callback):
+        """called if delete review errors"""
+        LOG.warn("delete review id=%s failed with error: %s" % (review_id, error_str))
+        for (app, reviews) in self._reviews.items():
+            for review in reviews:
+                if str(review.id) == str(review_id):
+                    review.delete_error = True
+                    callback(app, self._reviews[app], action='replace', 
+                             single_review=review)
+                    break
+
+    def spawn_modify_review_ui(self, parent_xid, iconname, datadir, review_id, callback):
+        """ this spawns the UI for writing a new review and
+            adds it automatically to the reviews DB """
+        cmd = [os.path.join(datadir, RNRApps.MODIFY_REVIEW), 
+               "--parent-xid", "%s" % parent_xid,
+               "--iconname", iconname,
+               "--datadir", "%s" % datadir,
+               "--review-id", "%s" % review_id,
+               ]
+        spawn_helper = SpawnHelper(format="json")
+        spawn_helper.connect("data-available", 
+                             self._on_modify_review_finished, 
+                             review_id, callback)
+        spawn_helper.connect("error", self._on_modify_review_error,
+                             review_id, callback)
+        spawn_helper.run(cmd)
+
+    def _on_modify_review_finished(self, spawn_helper, review_json, review_id, callback):
+        """called when modify_review finished"""
+        LOG.debug("_on_modify_review_finished")
+        return
+        #review_json = spawn_helper._stdout
+        mod_review = ReviewDetails.from_dict(review_json)
+        for (app, reviews) in self._reviews.items():
+            for review in reviews:
+                if str(review.id) == str(review_id):
+                    # remove the one we don't want to see anymore
+                    self._reviews[app].remove(review)
+                    new_review = Review.from_piston_mini_client(mod_review)
+                    self._reviews[app].insert(0, new_review)
+                    callback(app, self._reviews[app], action='replace', 
+                             single_review=new_review)
+                    break
+
+    def _on_modify_review_error(self, spawn_helper, error_str, review_id, callback):
+        """called if modify review errors"""
+        LOG.debug("modify review id=%s failed with error: %s" % (review_id, error_str))
+        for (app, reviews) in self._reviews.items():
+            for review in reviews:
+                if str(review.id) == str(review_id):
+                    review.modify_error = True
+                    callback(app, self._reviews[app], action='replace', 
+                             single_review=review)
+                    break

=== modified file 'softwarecenter/db/application.py'
--- softwarecenter/db/application.py	2011-10-25 18:38:08 +0000
+++ softwarecenter/db/application.py	2011-10-27 07:59:24 +0000
@@ -252,7 +252,8 @@
         # try apt first
         if self._pkg:
             for origin in self._pkg.candidate.origins:
-                if (origin.origin == "Ubuntu" and origin.trusted and origin.component):
+                if (origin.origin == get_distro().get_distro_channel_name() and
+                    origin.trusted and origin.component):
                     return origin.component
         # then xapian
         elif self._doc:

=== modified file 'softwarecenter/db/update.py'
--- softwarecenter/db/update.py	2011-10-18 00:48:28 +0000
+++ softwarecenter/db/update.py	2011-10-27 07:59:24 +0000
@@ -401,7 +401,7 @@
     except ImportError:
         return False
     if not listsdir:
-        listsdir = apt_pkg.Config.find_dir("Dir::State::lists")
+        listsdir = apt_pkg.config.find_dir("Dir::State::lists")
     context = GObject.main_context_default()
     for appinfo in glob("%s/*AppInfo" % listsdir):
         LOG.debug("processing %s" % appinfo)

=== modified file 'softwarecenter/distro/Debian.py'
--- softwarecenter/distro/Debian.py	2011-09-21 15:15:28 +0000
+++ softwarecenter/distro/Debian.py	2011-10-27 07:59:24 +0000
@@ -31,6 +31,10 @@
     SCREENSHOT_THUMB_URL =  "http://screenshots.debian.net/thumbnail/%(pkgname)s"
     SCREENSHOT_LARGE_URL = "http://screenshots.debian.net/screenshot/%(pkgname)s"
 
+    REVIEWS_SERVER = ""
+
+    DEVELOPER_URL = "http://www.debian.org/devel/"
+
     def get_distro_channel_name(self):
         """ The name in the Release file """
         return "Debian"
@@ -68,19 +72,20 @@
         
     def get_license_text(self, component):
         if component in ("main",):
-            return _("Open source")
+            return _("Meets the Debian Free Software Guidelines")
         elif component == "contrib":
-            return _("Open source, with proprietary parts")
-        elif component == "restricted":
-            return _("Proprietary")
-
-    def get_maintenance_status(self, cache, appname, pkgname, component, channel):
-        return ""
+            return _("Meets the Debian Free Software Guidelines itself "
+                     "but requires additional non-free software to work")
+        elif component == "non-free":
+            return _("Non-free since it is either restricted "
+                     "in use, redistribution or modification.")
 
     def get_architecture(self):
         return apt.apt_pkg.config.find("Apt::Architecture")
 
     def get_foreign_architectures(self):
+        return []
+        # Not yet in unstable
         import subprocess
         out = subprocess.Popen(['dpkg', '--print-foreign-architectures'],
               stdout=subprocess.PIPE).communicate()[0].rstrip('\n')
@@ -88,6 +93,63 @@
             return out.split(' ')
         return []
 
+    def is_supported(self, cache, doc, pkgname):
+        # the doc does not by definition contain correct data regarding the
+        # section. Looking up in the cache seems just as fast/slow.
+        if pkgname in cache and cache[pkgname].candidate:
+            for origin in cache[pkgname].candidate.origins:
+                if (origin.origin == "Debian" and
+                    origin.trusted and
+                    origin.component == "main"):
+                    return True
+        return False
+
+    def get_maintenance_status(self, cache, appname, pkgname, component, channelname):
+        """Return the maintenance status of a package."""
+        if not hasattr(cache, '_cache') or not pkgname:
+            return
+        try:
+            origins = cache[pkgname].candidate.origins
+        except KeyError, AttributeError:
+            return
+        else:
+            for origin in origins:
+                if (origin.origin == "Debian" and origin.trusted):
+                    pkg_comp = origin.component
+                    pkg_archive = origin.archive
+                    break
+            else:
+                return
+        if pkg_comp in ("contrib", "non-free"):
+            if pkg_archive == "oldstable":
+                return _("Debian does not provide critical updates.")
+            else:
+                return _("Debian does not provide critical updates. "
+                         "Some updates may be provided by the developers "
+                         "of %s and redistributed by Debian.") % appname
+        elif pkg_comp == "main":
+            if pkg_archive == "stable":
+                return _("Debian provides critical updates for %s.") % appname
+            elif pkg_archive == "oldstable":
+                return _("Debian only provides updates for %s during "
+                         "a transition phase. "
+                         "Please consider upgrading to a later stable "
+                         "release of Debian.") % appname
+            elif pkg_archive == "testing":
+                return _("Debian provides critical updates for %s. But "
+                         "updates could be delayed or skipped.") % appname
+            elif pkg_archive == "unstable":
+                return _("Debian doens't provides critical updates "
+                         "for %s") % appname
+        return
+
+    def get_supported_query(self):
+        import xapian
+        query1 = xapian.Query("XOL"+"Debian")
+        query2 = xapian.Query("XOC"+"main")
+        return xapian.Query(xapian.Query.OP_AND, query1, query2)
+
+
 if __name__ == "__main__":
     cache = apt.Cache()
     print(cache.get_maintenance_status(cache, "synaptic app", "synaptic", "main", None))

=== modified file 'softwarecenter/distro/Ubuntu.py'
--- softwarecenter/distro/Ubuntu.py	2011-10-05 00:58:57 +0000
+++ softwarecenter/distro/Ubuntu.py	2011-10-27 07:59:24 +0000
@@ -56,6 +56,9 @@
     # FIXME: does that make sense?!?
     REVIEW_STATS_URL = REVIEWS_SERVER+"/review-stats"
 
+    # Starting point for Ubuntu app developers
+    DEVELOPER_URL = "http://developer.ubuntu.com/"
+
     def get_app_name(self):
         return _("Ubuntu Software Center")
 
@@ -128,6 +131,9 @@
         query2 = xapian.Query(xapian.Query.OP_OR, query2a, query2b)
         return xapian.Query(xapian.Query.OP_AND, query1, query2)
 
+    def get_supported_filter_name(self):
+        return _("Canonical-Maintained Software")
+
     def get_maintenance_status(self, cache, appname, pkgname, component, channelname):
         # try to figure out the support dates of the release and make
         # sure to look only for stuff in "Ubuntu" and "distro_codename"

=== modified file 'softwarecenter/distro/__init__.py'
--- softwarecenter/distro/__init__.py	2011-10-25 18:38:08 +0000
+++ softwarecenter/distro/__init__.py	2011-10-27 07:59:24 +0000
@@ -19,12 +19,15 @@
 
 import logging
 import os
-import subprocess
 
 from gettext import gettext as _
+import lsb_release
 
 from softwarecenter.utils import UnimplementedError, utf8
 
+log = logging.getLogger(__name__)
+
+
 class Distro(object):
     """ abstract base class for a distribution """
 
@@ -37,6 +40,16 @@
     REVIEW_SUMMARY_STARS_BASE_PATH = "/usr/share/software-center/images/review-summary"
     REVIEWS_SERVER = os.environ.get("SOFTWARE_CENTER_REVIEWS_HOST") or "http://localhost:8000"
 
+    # You need to set this var to enable purchases
+    PURCHASE_APP_URL = ""
+
+    # Point developers to a web page
+    DEVELOPER_URL = ""
+
+    def __init__(self, lsb_info):
+        """Return a new generic Distro instance."""
+        self.lsb_info = lsb_info
+
     def get_app_name(self):
         """ 
         The name of the application (as displayed in the main window and 
@@ -66,9 +79,8 @@
             return os.environ["SOFTWARE_CENTER_DISTRO_CODENAME"]
         # normal behavior
         if not hasattr(self, "_distro_code_name"):
-            self._distro_code_name = subprocess.Popen(
-                ["lsb_release","-c","-s"], 
-                stdout=subprocess.PIPE).communicate()[0].strip()
+            self._distro_code_name = \
+                    lsb_release.get_distro_information()["CODENAME"]
         return self._distro_code_name
 
     def get_maintenance_status(self, cache, appname, pkgname, component, channelname):
@@ -89,6 +101,9 @@
         import xapian
         return xapian.Query()
 
+    def get_supported_filter_name(self):
+        return _("Supported Software")
+
     def get_install_warning_text(self, cache, pkg, appname, depends):
         primary = utf8(_("To install %s, these items must be removed:")) % utf8(appname)
         button_text = _("Install Anyway")
@@ -140,15 +155,14 @@
 
 
 def _get_distro():
-    distro_id = subprocess.Popen(["lsb_release","-i","-s"], 
-                                 stdout=subprocess.PIPE).communicate()[0]
-    distro_id = distro_id.strip().replace(' ', '')
-    logging.getLogger("softwarecenter.distro").debug("get_distro: '%s'" % distro_id)
+    lsb_info = lsb_release.get_distro_information()
+    distro_id = lsb_info["ID"]
+    log.debug("get_distro: '%s'", distro_id)
     # start with a import, this gives us only a softwarecenter module
     module =  __import__(distro_id, globals(), locals(), [], -1)
     # get the right class and instanciate it
     distro_class = getattr(module, distro_id)
-    instance = distro_class()
+    instance = distro_class(lsb_info)
     return instance
 
 def get_distro():

=== modified file 'softwarecenter/ui/gtk3/app.py'
--- softwarecenter/ui/gtk3/app.py	2011-10-20 01:52:42 +0000
+++ softwarecenter/ui/gtk3/app.py	2011-10-27 07:59:24 +0000
@@ -342,10 +342,28 @@
         self.config = get_config()
         self.restore_state()
 
+        # Adapt menu entries
+        supported_menuitem = self.builder.get_object("menuitem_view_supported_only")
+        supported_menuitem.set_label(self.distro.get_supported_filter_name())
+        file_menu = self.builder.get_object("menu1")
+
+        if not self.distro.DEVELOPER_URL:
+            help_menu = self.builder.get_object("menu_help")
+            developer_separator = self.builder.get_object("separator_developer")
+            help_menu.remove(developer_separator)
+            developer_menuitem = self.builder.get_object("menuitem_developer")
+            help_menu.remove(developer_menuitem)
+
+        # Check if oneconf is available
+        och = get_oneconf_handler()
+        if not och:
+            file_menu.remove(self.builder.get_object("menuitem_sync_between_computers"))
+
         # run s-c-agent update
-        if options.disable_buy:
-            file_menu = self.builder.get_object("menu1")
+        if options.disable_buy or not self.distro.PURCHASE_APP_URL:
             file_menu.remove(self.builder.get_object("menuitem_reinstall_purchases"))
+            if not (options.enable_lp or och):
+                file_menu.remove(self.builder.get_object("separator_login"))
         else:
             sc_agent_update = os.path.join(
                 self.datadir, "update-software-center-agent")
@@ -355,9 +373,6 @@
             GObject.child_watch_add(
                 pid, self._on_update_software_center_agent_finished)
 
-        if options.disable_buy and not options.enable_lp:
-            file_menu.remove(self.builder.get_object("separator_login"))
-            
         # TODO: Remove the following two lines once we have remove repository
         #       support in aptdaemon (see LP: #723911)
         file_menu = self.builder.get_object("menu1")
@@ -1031,8 +1046,8 @@
         GObject.timeout_add_seconds(1, lambda p: p.poll() == None, p)
 
     def on_menuitem_developer_activate(self, menuitem):
-        webbrowser.open("http://developer.ubuntu.com/")
-            
+        webbrowser.open(self.distro.DEVELOPER_URL)
+
     def _ask_and_repair_broken_cache(self):
         # wait until the window window is available
         if self.window_main.props.visible == False:

=== modified file 'softwarecenter/ui/gtk3/panes/installedpane.py'
--- softwarecenter/ui/gtk3/panes/installedpane.py	2011-10-06 02:35:27 +0000
+++ softwarecenter/ui/gtk3/panes/installedpane.py	2011-10-27 07:59:24 +0000
@@ -132,8 +132,9 @@
         
         # Start OneConf
         self.oneconf_handler = get_oneconf_handler(self.oneconf_viewpickler)
-        self.oneconf_handler.connect('show-oneconf-changed', self._show_oneconf_changed)
-        self.oneconf_handler.connect('last-time-sync-changed', self._last_time_sync_oneconf_changed)
+        if self.oneconf_handler:
+            self.oneconf_handler.connect('show-oneconf-changed', self._show_oneconf_changed)
+            self.oneconf_handler.connect('last-time-sync-changed', self._last_time_sync_oneconf_changed)
         
         # OneConf pane
         self.computerpane = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)

=== modified file 'softwarecenter/ui/gtk3/views/appdetailsview_gtk.py'
--- softwarecenter/ui/gtk3/views/appdetailsview_gtk.py	2011-10-20 16:08:23 +0000
+++ softwarecenter/ui/gtk3/views/appdetailsview_gtk.py	2011-10-27 07:59:24 +0000
@@ -1051,7 +1051,8 @@
         self.reviews.connect("more-reviews-clicked", self._on_more_reviews_clicked)
         self.reviews.connect("different-review-language-clicked", self._on_reviews_in_different_language_clicked)
         self.reviews.connect("review-sort-changed", self._on_review_sort_method_changed)
-        vb.pack_start(self.reviews, False, False, 0)
+        if get_distro().REVIEWS_SERVER:
+            vb.pack_start(self.reviews, False, False, 0)
 
         self.show_all()