Merge lp:~mvo/software-center/expunge-cache-5.0 into lp:software-center

[Michael Vogt]

Trivial addition to be more gently on the CPU with os.nice()

[Gary Lasker (gary-lasker)]

Just a note that I merged the lp:~mvo/software-center/expunge-cache branch, which is the one targeting trunk. Thanks!

review: Approve

Unmerged revisions

2491. By Michael Vogt on 2012-03-05

add os.nice()

2490. By Michael Vogt on 2012-02-29

merged expunge-cache branch for 5.0

2489. By Gary Lasker on 2012-01-19

    testing (LP: #918746)

2488. By Michael Vogt on 2012-01-19

* lp:~gary-lasker/software-center/staging-certs-2-for-5.0:
  - add SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK to allow QA easier
    testing

2487. By Michael Vogt on 2012-01-17

grab exhibits for the current series only (LP: #899257)

2486. By Michael Vogt on 2012-01-17

* lp:~mvo/software-center/fix-server-pagination:
  - reset server side review "page" when switching to a different
    app

2485. By Michael Vogt on 2012-01-10

* lp:~gary-lasker/software-center/fix-lp913756-for-5.0:
  - do not offer to add an icon to the Unity launcher for packages
    that do not have an Exec entry in their corresponding desktop
    file, e.g. ubuntu-restricted-extras, wine (LP: #913756)

2484. By Michael Vogt on 2012-01-10

releasing version 5.0.4

2483. By Gary Lasker on 2012-01-10

    download icons directly using the provided URL (LP: #914054)

2482. By Michael Vogt on 2012-01-09

test fixes

=== modified file 'debian/changelog'
--- debian/changelog	2012-03-01 19:53:28 +0000
+++ debian/changelog	2012-03-05 18:23:26 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 software-center (5.1.11) precise; urgency=low
 
   [ Michael Vogt ]
@@ -553,11 +554,50 @@
 
 software-center (5.0.3.2) UNRELEASED; urgency=low
 
+=======
+software-center (5.0.5) UNRELEASED; urgency=low
+
+  [ Gary Lasker ]
+  * lp:~gary-lasker/software-center/fix-lp913756-for-5.0:
+    - do not offer to add an icon to the Unity launcher for packages
+      that do not have an Exec entry in their corresponding desktop
+      file, e.g. ubuntu-restricted-extras, wine (LP: #913756)
+  * lp:~gary-lasker/software-center/staging-certs-2-for-5.0:
+    - add SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK to allow QA easier
+      testing (LP: #918746)
+  
+  [ Michael Vogt ]
+  * lp:~mvo/software-center/fix-server-pagination:
+    - reset server side review "page" when switching to a different
+      app
+
+  [ Kiwinote ]
+  * grab exhibits for the current series only (LP: #899257)
+  
+ -- Gary Lasker <[e-mail]>  Thu, 19 Jan 2012 10:54:47 -0500
+
+software-center (5.0.4) oneiric-proposed; urgency=low
+
+  [ Gary Lasker ]
+>>>>>>> MERGE-SOURCE
   * lp:~gary-lasker/software-center/fix-lp891499-for-5.0:
     - be more robust about problems reading the cataloged_times file 
       as problems here can hang the UI (LP: #891499)
-
- -- Gary Lasker <[e-mail]>  Mon, 28 Nov 2011 14:22:24 -0500
+  
+  [ Gabor Kelemen ]
+  * lp:~kelemeng/software-center/bug869935:
+    - Update help translations from Launchpad (LP: #869935)
+  * lp:~kelemeng/software-center/bug880757:
+    - Mark strings containing the “ character as Unicode, to fix 
+      their translations. LP: #880757
+
+  [ Michael Vogt ]
+  * fix cache opening to improve startup time 
+  * lp:~mvo/software-center/icon-data-for-5.0:
+    - remove the need for inline icon data from the agent, instead
+      download icons directly using the provided URL (LP: #914054)
+
+ -- Michael Vogt <[e-mail]>  Tue, 10 Jan 2012 09:52:09 +0100
 
 software-center (5.0.3.1) oneiric-proposed; urgency=low
 
 
=== modified file 'setup.py'
=== modified file 'softwarecenter/backend/scagent.py'
--- softwarecenter/backend/scagent.py	2012-01-17 15:56:14 +0000
+++ softwarecenter/backend/scagent.py	2012-03-05 18:23:26 +0000
@@ -107,6 +107,13 @@
         self.emit("available-for-me", piston_available_for_me)
 
     def query_exhibits(self):
+<<<<<<< TREE
+=======
+        cmd = self.HELPER_CMD[:]
+        cmd.append("exhibits")
+        cmd.append(get_language())
+        cmd.append(self.distro.get_codename())
+>>>>>>> MERGE-SOURCE
         spawner = SpawnHelper()
         spawner.parent_xid = self.xid
         spawner.ignore_cache = self.ignore_cache
 
=== modified file 'softwarecenter/db/update.py'
--- softwarecenter/db/update.py	2012-02-28 22:35:19 +0000
+++ softwarecenter/db/update.py	2012-03-05 18:23:26 +0000
@@ -672,6 +672,11 @@
         while context.pending():
             context.iteration()
         try:
+<<<<<<< TREE
+=======
+            # magic channel
+            entry.channel = AVAILABLE_FOR_PURCHASE_MAGIC_CHANNEL_NAME
+>>>>>>> MERGE-SOURCE
             # now the normal parser
             parser = SCAApplicationParser(entry)
             index_app_info_from_parser(parser, db, cache)
@@ -932,8 +937,166 @@
         seen.add(name)
 
         index_name(doc, name, term_generator)
+<<<<<<< TREE
 
         pkgname = doc.get_value(XapianValues.PKGNAME)
+=======
+        doc.add_value(XapianValues.APPNAME_UNTRANSLATED, untranslated_name)
+
+        # check if we should ignore this file
+        if parser.has_option_desktop("X-AppInstall-Ignore"):
+            ignore = parser.get_desktop("X-AppInstall-Ignore")
+            if ignore.strip().lower() == "true":
+                LOG.debug("X-AppInstall-Ignore found for '%s'" % parser.desktopf)
+                return
+        # architecture
+        pkgname_extension = ''
+        if parser.has_option_desktop("X-AppInstall-Architectures"):
+            arches = parser.get_desktop("X-AppInstall-Architectures")
+            doc.add_value(XapianValues.ARCHIVE_ARCH, arches)
+            native_archs = get_current_arch() in arches.split(',')
+            foreign_archs = list(set(arches.split(',')) & set(get_foreign_architectures()))
+            if not (native_archs or foreign_archs): return
+            if not native_archs and foreign_archs:
+                pkgname_extension = ':' + foreign_archs[0]
+        # package name
+        pkgname = parser.get_desktop("X-AppInstall-Package") + pkgname_extension
+        doc.add_term("AP"+pkgname)
+        if '-' in pkgname:
+            # we need this to work around xapian oddness
+            doc.add_term(pkgname.replace('-','_'))
+        doc.add_value(XapianValues.PKGNAME, pkgname)
+        doc.add_value(XapianValues.DESKTOP_FILE, parser.desktopf)
+        # display name
+        if "display_name" in axi_values:
+            doc.add_value(axi_values["display_name"], name)
+        # cataloged_times
+        if "catalogedtime" in axi_values:
+            if pkgname in cataloged_times:
+                doc.add_value(axi_values["catalogedtime"], 
+                              xapian.sortable_serialise(cataloged_times[pkgname]))
+            else:
+                # also catalog apps not found in axi (e.g. for-purchase apps)
+                doc.add_value(axi_values["catalogedtime"], 
+                              xapian.sortable_serialise(time.time()))
+        # pocket (main, restricted, ...)
+        if parser.has_option_desktop("X-AppInstall-Section"):
+            archive_section = parser.get_desktop("X-AppInstall-Section")
+            doc.add_term("AS"+archive_section)
+            doc.add_value(XapianValues.ARCHIVE_SECTION, archive_section)
+        # section (mail, base, ..)
+        if pkgname in cache and cache[pkgname].candidate:
+            section = cache[pkgname].section
+            doc.add_term("AE"+section)
+        # channel (third party stuff)
+        if parser.has_option_desktop("X-AppInstall-Channel"):
+            archive_channel = parser.get_desktop("X-AppInstall-Channel")
+            doc.add_term("AH"+archive_channel)
+            doc.add_value(XapianValues.ARCHIVE_CHANNEL, archive_channel)
+        # signing key (third party)
+        if parser.has_option_desktop("X-AppInstall-Signing-Key-Id"):
+            keyid = parser.get_desktop("X-AppInstall-Signing-Key-Id")
+            doc.add_value(XapianValues.ARCHIVE_SIGNING_KEY_ID, keyid)
+        # license (third party)
+        if parser.has_option_desktop("X-AppInstall-License"):
+            license = parser.get_desktop("X-AppInstall-License")
+            doc.add_value(XapianValues.LICENSE, license)
+        # purchased date
+        if parser.has_option_desktop("X-AppInstall-Purchased-Date"):
+            date = parser.get_desktop("X-AppInstall-Purchased-Date")
+            # strip the subseconds from the end of the date string
+            doc.add_value(XapianValues.PURCHASED_DATE, str(date).split(".")[0])
+        # deb-line (third party)
+        if parser.has_option_desktop("X-AppInstall-Deb-Line"):
+            debline = parser.get_desktop("X-AppInstall-Deb-Line")
+            doc.add_value(XapianValues.ARCHIVE_DEB_LINE, debline)
+        # license key (third party)
+        if parser.has_option_desktop("X-AppInstall-License-Key"):
+            key = parser.get_desktop("X-AppInstall-License-Key")
+            doc.add_value(XapianValues.LICENSE_KEY, key)
+        # license keypath (third party)
+        if parser.has_option_desktop("X-AppInstall-License-Key-Path"):
+            path = parser.get_desktop("X-AppInstall-License-Key-Path")
+            doc.add_value(XapianValues.LICENSE_KEY_PATH, path)
+        # PPA (third party stuff)
+        if parser.has_option_desktop("X-AppInstall-PPA"):
+            archive_ppa = parser.get_desktop("X-AppInstall-PPA")
+            doc.add_value(XapianValues.ARCHIVE_PPA, archive_ppa)
+            # add archive origin data here so that its available even if
+            # the PPA is not (yet) enabled
+            doc.add_term("XOO"+"lp-ppa-%s" % archive_ppa.replace("/", "-"))
+        # screenshot (for third party)
+        if parser.has_option_desktop("X-AppInstall-Screenshot-Url"):
+            url = parser.get_desktop("X-AppInstall-Screenshot-Url")
+            doc.add_value(XapianValues.SCREENSHOT_URL, url)
+        # thumbnail (for third party)
+        if parser.has_option_desktop("X-AppInstall-Thumbnail-Url"):
+            url = parser.get_desktop("X-AppInstall-Thumbnail-Url")
+            doc.add_value(XapianValues.THUMBNAIL_URL, url)
+        # icon (for third party)
+        if parser.has_option_desktop("X-AppInstall-Icon-Url"):
+            url = parser.get_desktop("X-AppInstall-Icon-Url")
+            doc.add_value(XapianValues.ICON_URL, url)
+            if not parser.has_option_desktop("X-AppInstall-Icon"):
+                # prefix pkgname to avoid name clashes
+                doc.add_value(XapianValues.ICON, "%s-icon-%s" % (
+                        pkgname, os.path.basename(url)))
+
+        # price (pay stuff)
+        if parser.has_option_desktop("X-AppInstall-Price"):
+            price = parser.get_desktop("X-AppInstall-Price")
+            doc.add_value(XapianValues.PRICE, price)
+            # since this is a commercial app, indicate it in the component value
+            doc.add_value(XapianValues.ARCHIVE_SECTION, "commercial")
+        # icon
+        if parser.has_option_desktop("Icon"):
+            icon = parser.get_desktop("Icon")
+            doc.add_value(XapianValues.ICON, icon)
+        # write out categories
+        for cat in parser.get_desktop_categories():
+            doc.add_term("AC"+cat.lower())
+        categories_string = ";".join(parser.get_desktop_categories())
+        doc.add_value(XapianValues.CATEGORIES, categories_string)
+        for mime in parser.get_desktop_mimetypes():
+            doc.add_term("AM"+mime.lower())
+        # get type (to distinguish between apps and packages
+        if parser.has_option_desktop("Type"):
+            type = parser.get_desktop("Type")
+            doc.add_term("AT"+type.lower())
+        # check gettext domain
+        if parser.has_option_desktop("X-Ubuntu-Gettext-Domain"):
+            domain = parser.get_desktop("X-Ubuntu-Gettext-Domain")
+            doc.add_value(XapianValues.GETTEXT_DOMAIN, domain)
+        # Description (software-center extension)
+        if parser.has_option_desktop("X-AppInstall-Description"):
+            descr = parser.get_desktop("X-AppInstall-Description")
+            doc.add_value(XapianValues.SC_DESCRIPTION, descr)
+        # popcon
+        # FIXME: popularity not only based on popcon but also
+        #        on archive section, third party app etc
+        if parser.has_option_desktop("X-AppInstall-Popcon"):
+            popcon = float(parser.get_desktop("X-AppInstall-Popcon"))
+            # sort_by_value uses string compare, so we need to pad here
+            doc.add_value(XapianValues.POPCON, 
+                          xapian.sortable_serialise(popcon))
+            global popcon_max
+            popcon_max = max(popcon_max, popcon)
+
+        # comment goes into the summary data if there is one,
+        # other wise we try GenericName and if nothing else,
+        # the summary of the package
+        if parser.has_option_desktop("Comment"):
+            s = parser.get_desktop("Comment")
+            doc.add_value(XapianValues.SUMMARY, s)
+        elif parser.has_option_desktop("GenericName"):
+            s = parser.get_desktop("GenericName")
+            if s != name:
+                doc.add_value(XapianValues.SUMMARY, s)
+        elif pkgname in cache and cache[pkgname].candidate:
+            s = cache[pkgname].candidate.summary
+            doc.add_value(XapianValues.SUMMARY, s)
+
+>>>>>>> MERGE-SOURCE
         # add packagename as meta-data too
         term_generator.index_text_without_positions(pkgname, WEIGHT_APT_PKGNAME)
 
 
=== modified file 'softwarecenter/ui/gtk3/app.py'
--- softwarecenter/ui/gtk3/app.py	2012-02-29 17:23:24 +0000
+++ softwarecenter/ui/gtk3/app.py	2012-03-05 18:23:26 +0000
@@ -387,6 +387,7 @@
             if not (options.enable_lp or och):
                 file_menu.remove(self.builder.get_object("separator_login"))
         else:
+<<<<<<< TREE
             # running the agent will trigger a db reload so we do it later
             GObject.timeout_add_seconds(30, self._run_software_center_agent)
 
@@ -394,6 +395,22 @@
         # keep the cache clean
         GObject.timeout_add_seconds(15, self._run_expunge_cache_helper)
 
+=======
+            sc_agent_update = os.path.join(
+                self.datadir, "update-software-center-agent")
+            (pid, stdin, stdout, stderr) = GObject.spawn_async(
+                [sc_agent_update, "--datadir", datadir], 
+                flags=GObject.SPAWN_DO_NOT_REAP_CHILD)
+            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"))
+            
+        # keep the cache clean
+        GObject.timeout_add_seconds(45, self._run_expunge_cache_helper)
+
+>>>>>>> MERGE-SOURCE
         # TODO: Remove the following two lines once we have remove repository
         #       support in aptdaemon (see LP: #723911)
         file_menu = self.builder.get_object("menu1")
@@ -413,6 +430,7 @@
 
 
     # helper
+<<<<<<< TREE
     def _run_software_center_agent(self):
         """ helper that triggers the update-software-center-agent helper """
         sc_agent_update = os.path.join(
@@ -433,6 +451,18 @@
              softwarecenter.paths.SOFTWARE_CENTER_CACHE_DIR,
              ])
 
+=======
+    def _run_expunge_cache_helper(self):
+        """ helper that expires the piston-mini-client cache """
+        sc_expunge_cache = os.path.join(
+            self.datadir, "expunge-cache.py")
+        (pid, stdin, stdout, stderr) = GObject.spawn_async(
+            [sc_expunge_cache, 
+             "--by-unsuccessful-http-states",
+             softwarecenter.paths.SOFTWARE_CENTER_CACHE_DIR,
+             ])
+
+>>>>>>> MERGE-SOURCE
     def _rebuild_and_reopen_local_db(self, pathname):
         """ helper that rebuilds a db and reopens it """
         from softwarecenter.db.update import rebuild_database
 
=== modified file 'softwarecenter/ui/gtk3/models/appstore2.py'
=== modified file 'softwarecenter/ui/gtk3/panes/availablepane.py'
--- softwarecenter/ui/gtk3/panes/availablepane.py	2012-02-28 13:14:06 +0000
+++ softwarecenter/ui/gtk3/panes/availablepane.py	2012-03-05 18:23:26 +0000
@@ -134,9 +134,18 @@
             #~ self.app_view._append_appcount(appcount)
         #~ liststore.connect('appcount-changed', on_appcount_changed)
         self.app_view.set_model(liststore)
-        liststore.connect(
-            "needs-refresh", lambda helper, pkgname: self.app_view.queue_draw())
-
+<<<<<<< TREE
+        liststore.connect(
+            "needs-refresh", lambda helper, pkgname: self.app_view.queue_draw())
+
+=======
+        # setup purchase stuff
+        self.app_details_view.connect("purchase-requested",
+                                      self.on_purchase_requested)
+        liststore.connect(
+            "needs-refresh", lambda helper, pkgname: self.app_view.queue_draw())
+
+>>>>>>> MERGE-SOURCE
         # purchase view
         self.purchase_view = PurchaseView()
         app_manager = get_appmanager()
 
=== modified file 'softwarecenter/ui/gtk3/panes/installedpane.py'
--- softwarecenter/ui/gtk3/panes/installedpane.py	2012-02-28 13:51:20 +0000
+++ softwarecenter/ui/gtk3/panes/installedpane.py	2012-03-05 18:23:26 +0000
@@ -156,9 +156,14 @@
         oneconftoolbar.set_orientation(Gtk.Orientation.HORIZONTAL)
         oneconfpropertymenu = Gtk.Menu()
         self.oneconfproperty = MenuButton(oneconfpropertymenu, Gtk.Image.new_from_stock(Gtk.STOCK_PROPERTIES, Gtk.IconSize.BUTTON))
+<<<<<<< TREE
         self.stopsync_label = _(u"Stop Syncing “%s”")
         stop_oneconf_share_menuitem = Gtk.MenuItem(label=self.stopsync_label % platform.node())
         stop_oneconf_share_menuitem.connect("activate", self._on_stop_oneconf_hostshare_clicked)
+=======
+        stop_oneconf_share_menuitem = Gtk.MenuItem(label=_(u"Stop Syncing “%s”") % platform.node())
+        stop_oneconf_share_menuitem.connect("activate", self._on_stop_showing_oneconf_clicked)
+>>>>>>> MERGE-SOURCE
         stop_oneconf_share_menuitem.show()
         oneconfpropertymenu.append(stop_oneconf_share_menuitem)
         self.oneconfcontrol.pack_start(oneconftoolbar, False, False, 1)
@@ -433,9 +438,15 @@
             L = len(enq.matches)
 
             if L:
+<<<<<<< TREE
                 cat_title = utf8(ngettext(u'%(amount)s item on “%(machine)s” not on this computer',
                                           u'%(amount)s items on “%(machine)s” not on this computer',
                                           L)) % { 'amount' : L, 'machine': utf8(self.current_hostname)}
+=======
+                cat_title = ngettext(u'%(amount)s item on “%(machine)s” not on this computer',
+                                     u'%(amount)s items on “%(machine)s” not on this computer',
+                                     L) % { 'amount' : L, 'machine': self.current_hostname}
+>>>>>>> MERGE-SOURCE
                 i += L
                 docs = enq.get_documents()
                 self.cat_docid_map["missingpkg"] = set([doc.get_docid() for doc in docs])
@@ -455,9 +466,15 @@
 
             L = len(enq.matches)
             if L:
+<<<<<<< TREE
                 cat_title = utf8(ngettext(u'%(amount)s item on this computer not on “%(machine)s”',
                                           '%(amount)s items on this computer not on “%(machine)s”',
                                           L)) % { 'amount' : L, 'machine': utf8(self.current_hostname)}
+=======
+                cat_title = ngettext(u'%(amount)s item on this computer not on “%(machine)s”',
+                                     u'%(amount)s items on this computer not on “%(machine)s”',
+                                     L) % { 'amount' : L, 'machine': self.current_hostname}
+>>>>>>> MERGE-SOURCE
                 i += L
                 docs = enq.get_documents()
                 self.cat_docid_map["additionalpkg"] = set([doc.get_docid() for doc in docs])
 
=== modified file 'softwarecenter/ui/gtk3/panes/softwarepane.py'
--- softwarecenter/ui/gtk3/panes/softwarepane.py	2012-02-28 13:51:20 +0000
+++ softwarecenter/ui/gtk3/panes/softwarepane.py	2012-03-05 18:23:26 +0000
@@ -34,7 +34,8 @@
 
 from softwarecenter.utils import (ExecutionTime,
                                   wait_for_apt_cache_ready,
-                                  utf8
+                                  utf8,
+                                  get_exec_line_from_desktop
                                   )
 
 from softwarecenter.ui.gtk3.session.viewmanager import get_viewmanager
@@ -43,8 +44,15 @@
 from softwarecenter.ui.gtk3.widgets.searchaid import SearchAid
 
 from softwarecenter.ui.gtk3.views.appview import AppView
+<<<<<<< TREE
 from softwarecenter.ui.gtk3.views.appdetailsview import AppDetailsView
 
+=======
+from softwarecenter.ui.gtk3.views.appdetailsview_gtk import (
+                                                AppDetailsViewGtk as
+                                                AppDetailsView)
+
+>>>>>>> MERGE-SOURCE
 from basepane import BasePane
 
 LOG = logging.getLogger(__name__)
@@ -283,6 +291,87 @@
         vm = get_viewmanager()
         vm.nav_forward()
 
+<<<<<<< TREE
+=======
+    def on_transaction_started(self, backend, pkgname, appname, trans_id, 
+                               trans_type):
+        self._register_unity_launcher_transaction_started(
+            backend, pkgname, appname, trans_id, trans_type)
+
+        
+    def _get_onscreen_icon_details_for_launcher_service(self, app):
+        if self.is_app_details_view_showing():
+            return self.app_details_view.get_app_icon_details()
+        else:
+            # TODO: implement the app list view case once it has been specified
+            return (0, 0, 0)
+       
+    def _register_unity_launcher_transaction_started(self, backend, pkgname, 
+                                                     appname, trans_id, 
+                                                     trans_type):
+        # mvo: use use softwarecenter.utils explictely so that we can monkey
+        #      patch it in the test
+        if not softwarecenter.utils.is_unity_running():
+            return
+        # add to launcher only applies in the details view currently
+        if not self.is_app_details_view_showing():
+            return
+        # we only care about getting the launcher information on an install
+        if not trans_type == TransactionTypes.INSTALL:
+            if pkgname in self.unity_launcher_items:
+                self.unity_launcher_items.pop(pkgname)
+                self.action_bar.clear()
+            return
+        # gather details for this transaction and create the launcher_info object
+        app = Application(pkgname=pkgname, appname=appname)
+        appdetails = app.get_details(self.db)
+        (icon_size, icon_x, icon_y) = self._get_onscreen_icon_details_for_launcher_service(app)
+        launcher_info = UnityLauncherInfo(app.name,
+                                          appdetails.icon,
+                                          "",        # we set the icon_file_path value *after* install
+                                          icon_x,
+                                          icon_y,
+                                          icon_size,
+                                          appdetails.desktop_file,
+                                          "",        # we set the installed_desktop_file_path *after* install
+                                          trans_id)
+        self.unity_launcher_items[app.pkgname] = launcher_info
+        self.show_add_to_launcher_panel(backend, pkgname, appname, app, appdetails, trans_id, trans_type)
+                
+    def show_add_to_launcher_panel(self, backend, pkgname, appname, app, appdetails, trans_id, trans_type):
+        """
+        if Unity is currently running, display a panel to allow the user
+        the choose whether to add a newly-installed application to the
+        launcher
+        """
+        # TODO: handle local deb install case
+        # TODO: implement the list view case (once it is specified)
+        # only show the panel if unity is running and this is a package install
+        #
+        # we only show the prompt for apps with a desktop file
+        if not appdetails.desktop_file:
+            return
+        # do not add apps that have no Exec entry in their desktop file
+        # (e.g. wine, see LP: #848437 or ubuntu-restricted-extras,
+        # see LP: #913756)
+        if (os.path.exists(appdetails.desktop_file) and
+            not get_exec_line_from_desktop(appdetails.desktop_file)):
+            return
+            
+        self.action_bar.add_button(ActionButtons.CANCEL_ADD_TO_LAUNCHER,
+                                    _("Not Now"), 
+                                    self.on_cancel_add_to_launcher, 
+                                    pkgname)
+        self.action_bar.add_button(ActionButtons.ADD_TO_LAUNCHER,
+                                   _("Add to Launcher"),
+                                   self.on_add_to_launcher,
+                                   pkgname,
+                                   app,
+                                   appdetails,
+                                   trans_id)
+        self.action_bar.set_label(utf8(_("Add %s to the launcher?")) % utf8(app.name))
+
+>>>>>>> MERGE-SOURCE
     def on_query_complete(self, enquirer):
         self.emit("app-list-changed", len(enquirer.matches))
         self.app_view.display_matches(enquirer.matches,
 
=== modified file 'softwarecenter/ui/gtk3/views/appdetailsview.py'
=== modified file 'softwarecenter/ui/gtk3/views/purchaseview.py'
--- softwarecenter/ui/gtk3/views/purchaseview.py	2012-02-09 10:34:40 +0000
+++ softwarecenter/ui/gtk3/views/purchaseview.py	2012-03-05 18:23:26 +0000
@@ -20,14 +20,21 @@
 from gi.repository import GObject
 from gi.repository import Gtk
 from gi.repository import Gdk
+<<<<<<< TREE
 from gi.repository import Pango
+=======
+from gi.repository import WebKit as webkit
+>>>>>>> MERGE-SOURCE
 import logging
 import os
 import json
 import sys
 import urllib
+<<<<<<< TREE
 import urlparse
 from gi.repository import WebKit as webkit
+=======
+>>>>>>> MERGE-SOURCE
 
 from gettext import gettext as _
 
@@ -36,6 +43,16 @@
 
 LOG = logging.getLogger(__name__)
 
+# enable certificates validation in webkit views unless specified otherwise
+if not "SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK" in os.environ:
+    session = webkit.get_default_session()
+    session.set_property("ssl-ca-file", "/etc/ssl/certs/ca-certificates.crt")
+else:
+    # WARN the user!! Do not remove this
+    LOG.warning("SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK " +
+                "has been specified, all purchase transactions " + 
+                "are now INSECURE and UNENCRYPTED!!")
+
 class LocaleAwareWebView(webkit.WebView):
     
     def __init__(self):
 
=== modified file 'softwarecenter/ui/gtk3/widgets/buttons.py'
--- softwarecenter/ui/gtk3/widgets/buttons.py	2012-02-20 15:59:17 +0000
+++ softwarecenter/ui/gtk3/widgets/buttons.py	2012-03-05 18:23:26 +0000
@@ -186,8 +186,13 @@
         label = helper.get_appname(doc)
         icon = helper.get_icon_at_size(doc, icon_size, icon_size)
         stats = helper.get_review_stats(doc)
+<<<<<<< TREE
         helper.update_availability(doc)
         helper.connect("needs-refresh", self._on_needs_refresh, doc, icon_size)
+=======
+        doc.installed = doc.available = None
+        helper.connect("needs-refresh", self._on_needs_refresh, doc, icon_size)
+>>>>>>> MERGE-SOURCE
         self.is_installed = helper.is_installed(doc)
         self._overlay = helper.icons.load_icon(Icons.INSTALLED_OVERLAY,
                                                self.INSTALLED_OVERLAY_SIZE,
 
=== modified file 'test/test_database.py'
--- test/test_database.py	2012-02-28 22:35:19 +0000
+++ test/test_database.py	2012-03-05 18:23:26 +0000
@@ -150,12 +150,16 @@
                             ppa.count("/") == 1,
                             "ARCHIVE_PPA value incorrect, got '%s'" % ppa)
             self.assertTrue(
+<<<<<<< TREE
                 "-icon-" in doc.get_value(XapianValues.ICON))
             # check support url in the DB
             url=doc.get_value(XapianValues.SUPPORT_SITE_URL)
             if url:
                 self.assertTrue(url.startswith("http") or
                                 url.startswith("mailto:"))
+=======
+                "-icon-" in doc.get_value(XapianValues.ICON))
+>>>>>>> MERGE-SOURCE
 
     def test_license_string_data_from_software_center_agent(self):
         #os.environ["SOFTWARE_CENTER_DEBUG_HTTP"] = "1"
 
=== modified file 'test/test_utils.py'
--- test/test_utils.py	2012-03-01 11:32:37 +0000
+++ test/test_utils.py	2012-03-05 18:23:26 +0000
@@ -161,6 +161,45 @@
         self.assertTrue(os.path.exists(os.path.join(dirname, "foo-random")))
 
 
+class TestExpungeCache(unittest.TestCase):
+
+    def test_expunge_cache(self):
+        import subprocess
+        import tempfile
+        dirname = tempfile.mkdtemp('s-c-testsuite')
+        for name, content in [ ("foo-301", "status: 301"),
+                               ("foo-200", "status: 200"),
+                               ("foo-random", "random"),
+                             ]:
+            fullpath = os.path.join(dirname, name)
+            open(fullpath, "w").write(content)
+            # set to 1970+1s time to ensure the cleaner finds it
+            os.utime(fullpath, (1,1))
+        res = subprocess.call(["../utils/expunge-cache.py", dirname])
+        # no arguments
+        self.assertEqual(res, 1)
+        # by status
+        res = subprocess.call(["../utils/expunge-cache.py",
+                               "--debug",
+                               "--by-unsuccessful-http-states",
+                               dirname])
+        self.assertFalse(os.path.exists(os.path.join(dirname, "foo-301")))
+        self.assertTrue(os.path.exists(os.path.join(dirname, "foo-200")))
+        self.assertTrue(os.path.exists(os.path.join(dirname, "foo-random")))
+
+        # by time 
+        res = subprocess.call(["../utils/expunge-cache.py",
+                               "--debug",
+                               "--by-days", "1",
+                               dirname])
+        # now we expect the old file to be gone but the unknown one not to
+        # be touched
+        self.assertFalse(os.path.exists(os.path.join(dirname, "foo-200")))
+        self.assertTrue(os.path.exists(os.path.join(dirname, "foo-random")))
+
+
+
+
 if __name__ == "__main__":
     import logging
     logging.basicConfig(level=logging.DEBUG)
 
=== modified file 'utils/expunge-cache.py'
--- utils/expunge-cache.py	2012-02-29 17:14:43 +0000
+++ utils/expunge-cache.py	2012-03-05 18:23:26 +0000
@@ -1,80 +1,166 @@
-#!/usr/bin/python
-
-"""
-Expunge httplib2 caches
-"""
-
-import argparse
-import logging
-import os
-import time
-import sys
-
-class ExpungeCache(object):
-    def __init__(self, dirs, args):
-        self.dirs = dirs
-        # days to keep data in the cache (0 == disabled)
-        self.keep_time = 60*60*24* args.by_days
-        self.keep_only_http200 = args.by_unsuccessful_http_states
-        self.dry_run = args.dry_run
-
-    def _rm(self, f):
-        if self.dry_run:
-            print "Would delete: %s" % f
-        else:
-            logging.debug("Deleting: %s" % f)
-            os.unlink(f)
-
-    def clean(self):
-        # go over the directories
-        now = time.time()
-        for d in self.dirs:
-            for root, dirs, files in os.walk(d):
-                for f in files:
-                    fullpath = os.path.join(root, f)
-                    header = open(fullpath).readline().strip()
-                    if not header.startswith("status:"):
-                        logging.debug(
-                            "Skipping files with unknown header: '%s'" % f)
-                        continue
-                    if self.keep_only_http200 and header != "status: 200":
-                        self._rm(fullpath)
-                    if self.keep_time:
-                        mtime = os.path.getmtime(fullpath)
-                        logging.debug("mtime of '%s': '%s" % (f, mtime))
-                        if (mtime + self.keep_time) < now:
-                            self._rm(fullpath)
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description='clean software-center httplib2 cache')
-    parser.add_argument(
-        '--debug', action="store_true",
-        help='show debug output')
-    parser.add_argument(
-        '--dry-run', action="store_true",
-        help='do not act, just show what would be done')
-    parser.add_argument(
-        'directories', metavar='directory', nargs='+', type=str,
-        help='directories to be checked')
-    parser.add_argument(
-        '--by-days', type=int, default=0,
-        help='expire everything older than N days')
-    parser.add_argument(
-        '--by-unsuccessful-http-states', action="store_true",
-        help='expire any non 200 status responses')
-    args = parser.parse_args()
-
-    if args.debug:
-        logging.basicConfig(level=logging.DEBUG)
-    else:
-        logging.basicConfig(level=logging.INFO)
-
-    # sanity checking
-    if args.by_days == 0 and not args.by_unsuccessful_http_states:
-        print "Need either --by-days or --by-unsuccessful-http-states argument"
-        sys.exit(1)
-
-    # do it
-    cleaner = ExpungeCache(args.directories, args)
-    cleaner.clean()
+<<<<<<< TREE
+#!/usr/bin/python
+
+"""
+Expunge httplib2 caches
+"""
+
+import argparse
+import logging
+import os
+import time
+import sys
+
+class ExpungeCache(object):
+    def __init__(self, dirs, args):
+        self.dirs = dirs
+        # days to keep data in the cache (0 == disabled)
+        self.keep_time = 60*60*24* args.by_days
+        self.keep_only_http200 = args.by_unsuccessful_http_states
+        self.dry_run = args.dry_run
+
+    def _rm(self, f):
+        if self.dry_run:
+            print "Would delete: %s" % f
+        else:
+            logging.debug("Deleting: %s" % f)
+            os.unlink(f)
+
+    def clean(self):
+        # go over the directories
+        now = time.time()
+        for d in self.dirs:
+            for root, dirs, files in os.walk(d):
+                for f in files:
+                    fullpath = os.path.join(root, f)
+                    header = open(fullpath).readline().strip()
+                    if not header.startswith("status:"):
+                        logging.debug(
+                            "Skipping files with unknown header: '%s'" % f)
+                        continue
+                    if self.keep_only_http200 and header != "status: 200":
+                        self._rm(fullpath)
+                    if self.keep_time:
+                        mtime = os.path.getmtime(fullpath)
+                        logging.debug("mtime of '%s': '%s" % (f, mtime))
+                        if (mtime + self.keep_time) < now:
+                            self._rm(fullpath)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description='clean software-center httplib2 cache')
+    parser.add_argument(
+        '--debug', action="store_true",
+        help='show debug output')
+    parser.add_argument(
+        '--dry-run', action="store_true",
+        help='do not act, just show what would be done')
+    parser.add_argument(
+        'directories', metavar='directory', nargs='+', type=str,
+        help='directories to be checked')
+    parser.add_argument(
+        '--by-days', type=int, default=0,
+        help='expire everything older than N days')
+    parser.add_argument(
+        '--by-unsuccessful-http-states', action="store_true",
+        help='expire any non 200 status responses')
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.INFO)
+
+    # sanity checking
+    if args.by_days == 0 and not args.by_unsuccessful_http_states:
+        print "Need either --by-days or --by-unsuccessful-http-states argument"
+        sys.exit(1)
+
+    # do it
+    cleaner = ExpungeCache(args.directories, args)
+    cleaner.clean()
+=======
+#!/usr/bin/python
+
+"""
+Expunge httplib2 caches
+"""
+
+import argparse
+import logging
+import os
+import time
+import sys
+
+class ExpungeCache(object):
+    def __init__(self, dirs, args):
+        self.dirs = dirs
+        # days to keep data in the cache (0 == disabled)
+        self.keep_time = 60*60*24* args.by_days
+        self.keep_only_http200 = args.by_unsuccessful_http_states
+        self.dry_run = args.dry_run
+
+    def _rm(self, f):
+        if self.dry_run:
+            print "Would delete: %s" % f
+        else:
+            logging.debug("Deleting: %s" % f)
+            os.unlink(f)
+
+    def clean(self):
+        # go over the directories
+        now = time.time()
+        for d in self.dirs:
+            for root, dirs, files in os.walk(d):
+                for f in files:
+                    fullpath = os.path.join(root, f)
+                    header = open(fullpath).readline().strip()
+                    if not header.startswith("status:"):
+                        logging.debug(
+                            "Skipping files with unknown header: '%s'" % f)
+                        continue
+                    if self.keep_only_http200 and header != "status: 200":
+                        self._rm(fullpath)
+                    if self.keep_time:
+                        mtime = os.path.getmtime(fullpath)
+                        logging.debug("mtime of '%s': '%s" % (f, mtime))
+                        if (mtime + self.keep_time) < now:
+                            self._rm(fullpath)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description='clean software-center httplib2 cache')
+    parser.add_argument(
+        '--debug', action="store_true",
+        help='show debug output')
+    parser.add_argument(
+        '--dry-run', action="store_true",
+        help='do not act, just show what would be done')
+    parser.add_argument(
+        'directories', metavar='directory', nargs='+', type=str,
+        help='directories to be checked')
+    parser.add_argument(
+        '--by-days', type=int, default=0,
+        help='expire everything older than N days')
+    parser.add_argument(
+        '--by-unsuccessful-http-states', action="store_true",
+        help='expire any non 200 status responses')
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.INFO)
+
+    # sanity checking
+    if args.by_days == 0 and not args.by_unsuccessful_http_states:
+        print "Need either --by-days or --by-unsuccessful-http-states argument"
+        sys.exit(1)
+
+    # be nice
+    os.nice(19)
+
+    # do it
+    cleaner = ExpungeCache(args.directories, args)
+    cleaner.clean()
+>>>>>>> MERGE-SOURCE
 
=== added file 'utils/piston-helpers/piston_get_scagent_available_apps.py.OTHER'
--- utils/piston-helpers/piston_get_scagent_available_apps.py.OTHER	1970-01-01 00:00:00 +0000
+++ utils/piston-helpers/piston_get_scagent_available_apps.py.OTHER	2012-03-05 18:23:26 +0000
@@ -0,0 +1,194 @@
+#!/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):
+        self.oauth = oauth_result
+        # FIXME: actually verify the token against ubuntu SSO
+        self.loop.quit()
+
+    def verify_token(self, 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()
+        # 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