Merge lp:~mvo/aptdaemon/mvo into lp:aptdaemon

[Michael Vogt]

[Michael Vogt (mvo)]

support for removal of unused dependencies

[Sebastian Heinlein (glatzor)]

Was implemented as a transaction attribute some time ago

review: Disapprove

=== modified file 'aptdaemon/client.py'
--- aptdaemon/client.py	2009-12-12 11:15:12 +0000
+++ aptdaemon/client.py	2010-01-04 11:07:14 +0000
@@ -491,10 +491,13 @@
         return self._run_transaction("UpgradePackages", [package_names],
                                      wait, reply_handler, error_handler)
 
-    def remove_packages(self, package_names, wait=False, reply_handler=None,
-                        error_handler=None):
+    def remove_packages(self, package_names, wait=False, 
+                        remove_unused_dependencies=False,
+                        reply_handler=None, error_handler=None):
         """Remove packages by name."""
-        return self._run_transaction("RemovePackages", [package_names],
+        return self._run_transaction("RemovePackages", 
+                                     (package_names, 
+                                      remove_unused_dependencies),
                                      wait, reply_handler, error_handler)
 
     def commit_packages(self, install, reinstall, remove, purge, upgrade,

=== modified file 'aptdaemon/core.py'
--- aptdaemon/core.py	2009-12-12 09:13:33 +0000
+++ aptdaemon/core.py	2010-01-04 11:07:14 +0000
@@ -865,24 +865,29 @@
         return deferred
 
     @dbus_deferred_method(APTDAEMON_DBUS_INTERFACE,
-                          in_signature="as", out_signature="s",
+                          in_signature="asb", out_signature="s",
                           sender_keyword="sender")
-    def RemovePackages(self, package_names, sender):
+    def RemovePackages(self, package_names, remove_unused_dependencies, sender):
         """Return the id of a newly create transaction which will remove
         the given packages.
 
         Keyword arguments:
         package_names -- list of package names to remove
+        remove_unused_dependencies -- remove direct unused dependencies too
         sender -- the unique D-Bus name of the sender (provided by D-Bus)
         """
-        log.info("RemovePackages() was called: %s" % package_names)
+        log.info("RemovePackages() was called: '%s' '%i'" % (
+                package_names, remove_unused_dependencies))
         packages = ([], [], package_names, [], [])
+        kwargs = {"remove_unused_dependencies": remove_unused_dependencies,
+                  "package_names" : package_names,
+                  }
         deferred = policykit1.check_authorization_by_name(sender,
                                            policykit1.PK_ACTION_REMOVE_PACKAGES)
         deferred.add_callback(lambda x: policykit1.get_uid_from_dbus_name(sender))
         deferred.add_callback(lambda uid: Transaction(ROLE_REMOVE_PACKAGES,
                                                       self.queue, uid,
-                                                      packages=packages))
+                                                      kwargs=kwargs))
         deferred.add_callback(lambda trans: trans.tid)
         return deferred
 

=== modified file 'aptdaemon/worker.py'
--- aptdaemon/worker.py	2009-12-13 07:59:57 +0000
+++ aptdaemon/worker.py	2010-01-04 11:07:14 +0000
@@ -94,7 +94,7 @@
             elif self.trans.role == ROLE_INSTALL_FILE:
                 self.install_file(**self.trans.kwargs)
             elif self.trans.role == ROLE_REMOVE_PACKAGES:
-                self.remove_packages(self.trans.packages[2])
+                self.remove_packages(**self.trans.kwargs)
             elif self.trans.role == ROLE_UPGRADE_SYSTEM:
                 self.upgrade_system(**self.trans.kwargs)
             elif self.trans.role == ROLE_UPDATE_CACHE:
@@ -281,18 +281,26 @@
                                                  begin=64, end=95)):
             raise TransactionFailed(ERROR_UNKNOWN, deb._failure_string)
 
-    def remove_packages(self, package_names):
+    def remove_packages(self, package_names, remove_unused_dependencies):
         """Remove packages.
 
         Keyword argument:
         package_names -- list of package name which should be installed
+        remove_unused_dependencies -- remove unused direct dependencies
         """
-        log.info("Removing packages: %s", package_names)
+        log.info("Removing packages: '%s' '%i'" % (package_names, remove_unused_dependencies))
         ac = self._cache.actiongroup()
         resolver = apt.cache.ProblemResolver(self._cache)
         self._mark_packages_for_removal(package_names, resolver)
         self._resolve_depends(resolver)
         ac.release()
+        if remove_unused_dependencies:
+            # remove no longer used automatic dependencies
+            ac = self._cache.actiongroup()
+            for pkgname in package_names:
+                for unused in self._get_installed_automatic_depends_for_pkg(pkgname):
+                    self._cache[unused].markDelete()
+            ac.release()
         self._commit_changes(fetch_range=(10, 10),
                              install_range=(10, 90))
         #FIXME: should we use a persistant cache? make a check?
@@ -322,6 +330,43 @@
             resolver.protect(pkg)
             resolver.remove(pkg)
 
+    def _installed_dependencies(self, pkg_name, all_deps=None):
+        """ recursively return all installed dependencies of a given pkg """
+        #print "_installed_dependencies", pkg_name, all_deps
+        if not all_deps:
+            all_deps = set()
+        if not self._cache.has_key(pkg_name):
+            return all_deps
+        cur = self._cache[pkg_name]._pkg.CurrentVer
+        if not cur:
+            return all_deps
+        for t in ("PreDepends", "Depends", "Recommends"):
+            try:
+                for dep in cur.DependsList[t]:
+                    dep_name = dep[0].TargetPkg.Name
+                    if not dep_name in all_deps:
+                        all_deps.add(dep_name)
+                        all_deps |= self._installed_dependencies(dep_name, all_deps)
+            except KeyError:
+                pass
+        return all_deps
+    def _get_installed_automatic_depends_for_pkg(self, pkgname):
+        """ Get the installed automatic dependencies for this given package
+            only.
+
+            Note that the package must be marked for removal already for
+            this to work
+        """
+        installed_auto_deps = set()
+        deps = self._installed_dependencies(pkgname)
+        for dep_name in deps:
+            if self._cache.has_key(dep_name):
+                pkg = self._cache[dep_name]
+                if (pkg.isInstalled and 
+                    pkg.isAutoRemovable):
+                    installed_auto_deps.add(dep_name)
+        return installed_auto_deps
+
     def upgrade_packages(self, package_names):
         """Upgrade packages.