Merge lp:~mvo/software-center/size-calculation-via-aptdaemon into lp:software-center

[Michael Vogt]

This moves the size calculation code outside of software-center into aptdaemon. This improves
responsiveness and fixes the issues described in bug #988854.

[James Westby (james-w)]

review: Approve

=== modified file 'softwarecenter/db/pkginfo.py'
--- softwarecenter/db/pkginfo.py	2012-03-15 03:52:56 +0000
+++ softwarecenter/db/pkginfo.py	2012-08-20 10:09:26 +0000
@@ -121,6 +121,10 @@
                     'cache-broken': (GObject.SIGNAL_RUN_FIRST,
                                       GObject.TYPE_NONE,
                                       ()),
+                    'query-total-size-on-install-done': (
+                                      GObject.SIGNAL_RUN_FIRST,
+                                      GObject.TYPE_NONE,
+                                      (int, int)),
                     }
 
     def __getitem__(self, k):
@@ -201,15 +205,18 @@
         which will be removed if the package is installed."""
         return []
 
-    def get_total_size_on_install(self, pkgname,
+    def query_total_size_on_install(self, pkgname,
                                   addons_install=None, addons_remove=None,
                                   archive_suite=None):
-        """ Returns a tuple (download_size, installed_size)
+        """ Query for download and installed size
         with disk size in KB calculated for pkgname installation
         plus addons change and a (optional) archive_suite that the
         package comes from
+
+        This will emit a "query-total-size-on-install-done" signal
+        with the parameters (download_size, required_space_on_disk)
         """
-        return (0, 0)
+        self.emit("query-total-size-on-install-done", 0, 0)
 
     def open(self):
         """

=== modified file 'softwarecenter/db/pkginfo_impl/aptcache.py'
--- softwarecenter/db/pkginfo_impl/aptcache.py	2012-08-07 13:15:08 +0000
+++ softwarecenter/db/pkginfo_impl/aptcache.py	2012-08-20 10:09:26 +0000
@@ -26,6 +26,9 @@
 from gi.repository import GObject
 from gi.repository import Gio
 
+# we need this to get the size calculation done asyncronously and reliable
+from aptdaemon.client import AptClient
+
 from softwarecenter.db.pkginfo import PackageInfo, _Version
 from softwarecenter.enums import PkgStates
 from softwarecenter.utils import ExecutionTime
@@ -135,6 +138,9 @@
             "changed", self._on_apt_finished_stamp_changed)
         # this is fast, so ok
         self._language_packages = self._read_language_pkgs()
+        # query the totalize on install using aptdaemon
+        self.aptd_client = AptClient()
+        self._aptd_trans = None
 
     @staticmethod
     def version_compare(a, b):
@@ -569,84 +575,53 @@
             pkg._pkg, version._cand, archive_suite)
         return res
 
-    def get_total_size_on_install(self, pkgname,
-                                  addons_install=None, addons_remove=None,
-                                  archive_suite=None):
-        pkgs_to_install = []
-        pkgs_to_remove = []
-        total_download_size = 0  # in kB
-        total_install_size = 0  # in kB
-
+    # space calulcation stuff
+    def _on_total_size_calculation_done(self, trans, space):
+        self.emit(
+            "query-total-size-on-install-done", trans.download, trans.space)
+
+    def _on_trans_simulate_error(self, error):
+        LOG.exception("simulate failed")
+
+    def _on_trans_commit_packages_ready(self, trans):
+        trans.connect("space-changed", self._on_total_size_calculation_done)
+        try:
+            trans.simulate(reply_handler=lambda: True,
+                           error_handler=self._on_trans_simulate_error)
+        except:
+            LOG.exception("simulate failed")
+
+    def query_total_size_on_install(self, pkgname,
+                                    addons_install=[], addons_remove=[],
+                                    archive_suite=""):
         if not pkgname in self._cache:
-            return (0, 0)
-
-        pkg = self._cache[pkgname]
-        version = pkg.installed
-
-        all_install = []
-        if addons_install is not None:
-            all_install += addons_install
-
-        if version is None:
-            # its important that its the first pkg as the depcache will
-            # get cleared for each pkg and that will means that the
-            # set_candidate_release is lost again
-            all_install.append(pkgname)
-
-        for p in all_install:
-            # ensure that the archive_suite is set if needed, this needs to
-            # be in the loop as the cache is cleared in each loop iteration
-            if archive_suite:
-                self._set_candidate_release(pkg, archive_suite)
-            # now get the right version
-            version = self._cache[p].candidate
-            # this can happen on e.g. deb packages that are not in the cache
-            # testcase: software-center google-chrome-stable_current_amd64.deb
-            if not version:
-                continue
-            pkgs_to_install.append(version)
-            # now do it
-            deps_inst = self._try_install_and_get_all_deps_installed(
-                self._cache[p])
-            for dep in deps_inst:
-                if self._cache[dep].installed is None:
-                    dep_version = self._cache[dep].candidate
-                    pkgs_to_install.append(dep_version)
-            deps_remove = self._try_install_and_get_all_deps_removed(
-                self._cache[p])
-            for dep in deps_remove:
-                if self._cache[dep].is_installed:
-                    dep_version = self._cache[dep].installed
-                    pkgs_to_remove.append(dep_version)
-
-        all_remove = [] if addons_remove is None else addons_remove
-        for p in all_remove:
-            version = self._cache[p].installed
-            pkgs_to_remove.append(version)
-            deps_inst = self._try_install_and_get_all_deps_installed(
-                self._cache[p])
-            for dep in deps_inst:
-                if self._cache[dep].installed is None:
-                    version = self._cache[dep].candidate
-                    pkgs_to_install.append(version)
-            deps_remove = self._try_install_and_get_all_deps_removed(
-                self._cache[p])
-            for dep in deps_remove:
-                if self._cache[dep].installed is not None:
-                    version = self._cache[dep].installed
-                    pkgs_to_remove.append(version)
-
-        pkgs_to_install = list(set(pkgs_to_install))
-        pkgs_to_remove = list(set(pkgs_to_remove))
-
-        for pkg in pkgs_to_install:
-            if not pkg_downloaded(pkg) and not pkg.package.installed:
-                total_download_size += pkg.size
-            total_install_size += pkg.installed_size
-        for pkg in pkgs_to_remove:
-            total_install_size -= pkg.installed_size
-
-        return (total_download_size, total_install_size)
+            self.emit("query-total-size-on-install-done", 0, 0)
+
+        # ensure the syntax is right
+        if archive_suite:
+            pkgname = pkgname + "/" + archive_suite
+
+        # and simulate the install/remove via aptdaemon
+        install = [pkgname] + addons_install
+        remove = addons_remove
+        reinstall = purge = upgrade = downgrade = []
+
+        if self._aptd_trans:
+            self._aptd_trans.cancel()
+            self._aptd_trans = None
+
+        # do this async
+        try:
+            self.aptd_client.commit_packages(
+                install, reinstall, remove, purge, upgrade, downgrade,
+                # wait
+                False,
+                # reply and error handlers
+                self._on_trans_commit_packages_ready,
+                self._on_trans_simulate_error)
+        except:
+            LOG.exception(
+                "getting commit_packages trans failed for '%s'" % pkgname)
 
     def get_all_deps_upgrading(self, pkg):
         # note: this seems not to be used anywhere

=== modified file 'softwarecenter/db/pkginfo_impl/packagekit.py'
--- softwarecenter/db/pkginfo_impl/packagekit.py	2012-03-07 20:08:53 +0000
+++ softwarecenter/db/pkginfo_impl/packagekit.py	2012-08-20 10:09:26 +0000
@@ -264,20 +264,24 @@
                 if (p.get_name() != pkg.name)
                 and p.get_info() == packagekit.InfoEnum.INSTALLED]
 
-    def get_total_size_on_install(self, pkgname,
+    def query_total_size_on_install(self, pkgname,
                                   addons_install=None, addons_remove=None,
                                   archive_suite=None):
-        """ Returns a tuple (download_size, installed_size)
+        """ emit query-total-size-on-install-done signal
         with disk size in KB calculated for pkgname installation
         plus addons change.
         """
         # FIXME: support archive_suite here too
 
         # FIXME: PackageKit reports only one size at a time
+        download_size = 0
+        install_size = 0
         if self.is_installed(pkgname):
-            return (0, self.get_size(pkgname))
+            install_size = self.get_size(pkgname)
         else:
-            return (self.get_size(pkgname), 0)
+            download_size = self.get_size(pkgname)
+        self.emit(
+            "query-total-size-on-install-done", download_size, install_size)
 
     @property
     def ready(self):

=== modified file 'softwarecenter/ui/gtk3/views/appdetailsview.py'
--- softwarecenter/ui/gtk3/views/appdetailsview.py	2012-08-17 08:56:26 +0000
+++ softwarecenter/ui/gtk3/views/appdetailsview.py	2012-08-20 10:09:26 +0000
@@ -762,8 +762,7 @@
             if addon in self.addons_to_install:
                 self.addons_to_install.remove(addon)
         self.status_bar.configure()
-        GObject.idle_add(self.view.update_totalsize,
-                         priority=GObject.PRIORITY_LOW)
+        self.view.update_totalsize()
 
     def configure(self, pkgname, update_addons=True):
         self.addons_to_install = []
@@ -780,8 +779,7 @@
         self.addons_to_install = []
         self.addons_to_remove = []
         self.configure(self.view.app.pkgname)
-        GObject.idle_add(self.view.update_totalsize,
-                         priority=GObject.PRIORITY_LOW)
+        self.view.update_totalsize()
 
 
 _asset_cache = {}
@@ -814,6 +812,8 @@
         self.distro = distro
         self.icons = icons
         self.cache = cache
+        self.cache.connect("query-total-size-on-install-done",
+                           self._on_query_total_size_on_install_done)
         self.backend = get_install_backend()
         self.cache.connect("cache-ready", self._on_cache_ready)
         self.connect("destroy", self._on_destroy)
@@ -1496,8 +1496,7 @@
             self.addons_manager.configure(app_details.pkgname)
 
         # Update total size label
-        self.totalsize_info.set_value(_("Calculating..."))
-        GObject.timeout_add(500, self.update_totalsize)
+        self.update_totalsize()
 
         # Update addons state bar
         self.addons_statusbar.configure()
@@ -1545,9 +1544,7 @@
             self.addon_view.hide()
             if self.addon_view.get_parent():
                 self.info_vb.remove(self.addon_view)
-            self.totalsize_info.set_value(_("Calculating..."))
-            GObject.idle_add(self.update_totalsize,
-                             priority=GObject.PRIORITY_LOW)
+            self.update_totalsize()
         self._update_recommendations(app_details.pkgname)
         self._update_reviews(app_details)
 
@@ -2004,18 +2001,25 @@
         if not self.totalsize_info.get_property('visible'):
             return False
 
+        self.totalsize_info.set_value(_("Calculating..."))
+
         while Gtk.events_pending():
             Gtk.main_iteration()
 
-        label_string = ""
-
-        res = self.cache.get_total_size_on_install(
+        self.cache.query_total_size_on_install(
             self.app_details.pkgname,
             self.addons_manager.addons_to_install,
             self.addons_manager.addons_to_remove,
             self.app.archive_suite)
-        total_download_size, total_install_size = res
-        if res == (0, 0) and isinstance(self.app, DebFileApplication):
+
+    def _on_query_total_size_on_install_done(self,
+                                             pkginfo,
+                                             total_download_size,
+                                             total_install_size):
+        label_string = ""
+        if (total_download_size == 0 and
+            total_install_size == 0 and
+            isinstance(self.app, DebFileApplication)):
             total_install_size = self.app_details.installed_size
         if total_download_size > 0:
             download_size = GLib.format_size(total_download_size)

=== modified file 'tests/test_pkginfo.py'
--- tests/test_pkginfo.py	2012-05-30 18:39:55 +0000
+++ tests/test_pkginfo.py	2012-08-20 10:09:26 +0000
@@ -6,6 +6,7 @@
 from mock import patch
 
 from tests.utils import (
+    get_test_pkg_info,
     setup_test_env,
 )
 setup_test_env()
@@ -35,7 +36,36 @@
             self.cache = apt.Cache(memonly=True)
 
     def test_get_total_size(self):
-        # get a cache
+        def _on_query_total_size_on_install_done(pkginfo, download, space):
+            self.need_download = download
+            self.need_space = space
+            loop.quit()
+        TEST_PKG = "casper"
+        ADDONS_TO_INSTALL = [ "lupin-casper" ]
+        ADDONS_TO_REMOVE = []
+        loop =  GObject.MainLoop(GObject.main_context_default())
+        cache = get_test_pkg_info()
+        cache.connect(
+            "query-total-size-on-install-done", 
+            _on_query_total_size_on_install_done)
+        cache.query_total_size_on_install(
+            TEST_PKG, ADDONS_TO_INSTALL, ADDONS_TO_REMOVE)
+        loop.run()
+        # work out the numbers that we at least need to get (this will
+        # not include dependencies so it is probably lower)
+        need_at_least_download = (
+            cache[TEST_PKG].candidate.size + 
+            sum([cache[pkg].candidate.size for pkg in ADDONS_TO_INSTALL]))
+        need_at_least_installed = (
+            cache[TEST_PKG].candidate.installed_size +
+            sum([cache[pkg].candidate.installed_size for pkg in ADDONS_TO_INSTALL]))
+        self.assertTrue(self.need_download >= need_at_least_download)
+        self.assertTrue(self.need_space >= need_at_least_installed)
+        del self.need_download
+        del self.need_space
+
+    def test_get_total_size_with_mock(self):
+        # get a cache 
         cache = get_pkg_info()
         cache.open()
         # pick first uninstalled pkg
@@ -45,11 +75,13 @@
         # prepare args
         addons_to_install = addons_to_remove = []
         archive_suite = "foo"
-        with patch.object(cache, "_set_candidate_release") as f_mock:
-            cache.get_total_size_on_install(
+        with patch.object(cache.aptd_client, "commit_packages") as f_mock:
+            cache.query_total_size_on_install(
                 pkg.name, addons_to_install, addons_to_remove, archive_suite)
             # ensure it got called with the right arguments
-            f_mock.assert_called_with(pkg, archive_suite)
+            args, kwargs = f_mock.call_args
+            to_install = args[0]
+            self.assertTrue(to_install[0].endswith("/%s" % archive_suite))
 
 
 if __name__ == "__main__":

=== modified file 'tests/utils.py'
--- tests/utils.py	2012-05-31 12:50:01 +0000
+++ tests/utils.py	2012-08-20 10:09:26 +0000
@@ -395,7 +395,7 @@
         """Return (recommended, suggested) addons for 'pkgname'."""
         return ([], [])
 
-    def get_total_size_on_install(self, pkgname, addons_to_install,
+    def query_total_size_on_install(self, pkgname, addons_to_install,
                                   addons_to_remove, archive_suite):
-        """Return a fake (total_download_size, total_install_size) result."""
-        return (0, 0)
+        """Emit a fake signal "query-total-size-on-install-done" """
+        self.emit("query-total-size-on-install-done", (0, 0))