Merge lp:~pitti/aptdaemon/pk-plugins into lp:aptdaemon

[Martin Pitt]

This supports PackageKit's new apt plugins to extend WhatProvides. With this, we can write third-party plugins which work with both PK and aptdaemon. Rodrigo Moya is currently working on gnome-control-center's region panel which will make use of this, so it would be good to have proper support for this in aptdaemon.

This is a relatively straightforward port of https://gitorious.org/packagekit/packagekit/commit/b516f18e2

The previous two commits just fix an unrelated bug in the test suite which left a lot of dbus-daemon processes around, and fix the gstreamer test package.

[lp:~pitti/aptdaemon/pk-plugins]

769. By Martin Pitt on 2012-02-02

Add plugin support to PackageKit compat layer

Support plugins for PackageKit's apt backend, to easily extend the
functionality of "what-provides".

This is a pretty straightforward port of the corresponding commit in
PackageKit:
https://gitorious.org/packagekit/packagekit/commit/b516f18e2

[Martin Pitt (pitti)]

Please note, if you approve this, I'm happy to push my branch into trunk instead of merging, to preserve the individual commits and logs.

[Sebastian Heinlein (glatzor)]

Thanks for your work

=== modified file 'aptdaemon/pkcompat.py'
--- aptdaemon/pkcompat.py	2012-01-23 10:15:32 +0000
+++ aptdaemon/pkcompat.py	2012-02-02 05:55:21 +0000
@@ -39,6 +39,12 @@
 import lsb_release
 import packagekit.enums as pk_enums
 
+# for optional plugin support
+try:
+    import pkg_resources
+except ImportError:
+    pkg_resources = None
+
 from aptdaemon import policykit1
 import aptdaemon.core
 from aptdaemon.core import APTDAEMON_TRANSACTION_DBUS_INTERFACE
@@ -256,6 +262,7 @@
                        pk_enums.ROLE_SEARCH_DETAILS,
                        pk_enums.ROLE_SEARCH_GROUP,
                        pk_enums.ROLE_SEARCH_FILE,
+                       pk_enums.ROLE_WHAT_PROVIDES,
                        pk_enums.ROLE_DOWNLOAD_PACKAGES]
 
     SUPPORTED_FILTERS = [pk_enums.FILTER_INSTALLED,
@@ -1744,9 +1751,9 @@
         self.role = pk_enums.ROLE_GET_CATEGORIES
         GObject.idle_add(self._fail_not_implemented)
 
-    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
-                         in_signature="ssas", out_signature="",
-                         sender_keyword="sender")
+    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
+                          in_signature="ssas", out_signature="",
+                          sender_keyword="sender")
     def WhatProvides(self, filter, type, values, sender):
         """This method returns packages that provide the supplied attributes.
         This method is useful for finding out what package(s) provide a
@@ -1765,7 +1772,10 @@
             is backend specific.
         """
         self.role = pk_enums.ROLE_WHAT_PROVIDES
-        GObject.idle_add(self._fail_not_implemented)
+        kwargs = {"filters": filter.split(";"),
+                  "type": type,
+                  "values": values}
+        return self._run_query(kwargs, sender)
 
     @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
                          in_signature="", out_signature="",
@@ -1883,6 +1893,8 @@
 
 class PackageKitWorker(aptdaemon.worker.AptWorker):
 
+    _plugins = None
+
     """Process PackageKit Query transactions."""
 
     def query(self, trans):
@@ -2484,6 +2496,32 @@
             files = ";".join(self._get_installed_files(pkg))
             trans.emit_files(id, files)
 
+    def what_provides(self, trans, filters, type, values):
+        """Emit all dependencies of the given package ids.
+
+        Doesn't support recursive dependency resolution.
+        """
+        self._init_plugins()
+
+        supported_type = False
+
+        # run plugins
+        for plugin in self._plugins.get("what_provides", []):
+            pklog.debug("calling what_provides plugin %s %s" % (str(plugin), str(filters)))
+            for search_item in values:
+                try:
+                    for package in plugin(self._cache, type, search_item):
+                        self._emit_visible_package(trans, filters, package)
+                    supported_type = True
+                except NotImplementedError:
+                    pass # keep supported_type as False
+
+        if not supported_type and type != pk_enums.PROVIDES_ANY:
+            # none of the plugins felt responsible for this type
+            raise TransactionFailed(aptd_enums.ERROR_NOT_SUPPORTED,
+                                    "Query type '%s' is not supported" % type)
+
+
     # Helpers
 
     def _get_id_from_version(self, version):
@@ -2716,6 +2754,36 @@
                                                              pkg.name))
             return pk_enums.GROUP_UNKNOWN
 
+    def _init_plugins(self):
+        """Initialize PackageKit apt backend plugins.
+        
+        Do nothing if plugins are already initialized.
+        """
+        if self._plugins is not None:
+            return
+
+        if not pkg_resources:
+            return
+
+        self._plugins = {} # plugin_name -> [plugin_fn1, ...]
+
+        # just look in standard Python paths for now
+        dists, errors = pkg_resources.working_set.find_plugins(pkg_resources.Environment())
+        for dist in dists:
+            pkg_resources.working_set.add(dist)
+        for plugin_name in ["what_provides"]:
+            for entry_point in pkg_resources.iter_entry_points(
+                    "packagekit.apt.plugins", plugin_name):
+                try:
+                    plugin = entry_point.load()
+                except Exception as e:
+                    pklog.warning("Failed to load %s from plugin %s: %s" % (
+                        plugin_name, str(entry_point.dist), str(e)))
+                    continue
+                pklog.debug("Loaded %s from plugin %s" % (
+                    plugin_name, str(entry_point.dist)))
+                self._plugins.setdefault(plugin_name, []).append(plugin)
+
 
 if META_RELEASE_SUPPORT:
 

=== modified file 'tests/repo/Packages'
--- tests/repo/Packages	2011-11-18 13:12:49 +0000
+++ tests/repo/Packages	2012-02-02 05:55:21 +0000
@@ -192,3 +192,27 @@
  .
  This package cannot be installed because of a missing dependency.
 
+Package: gstreamer0.10-silly
+Priority: extra
+Section: admin
+Installed-Size: 168
+Maintainer: Sebastian Heinlein <[e-mail]>
+Architecture: all
+Source: silly-packages
+Version: 0.1-0
+Depends: libc6 (>= 2.7-1), libglib2.0-0 (>= 2.16.0), libgstreamer-plugins-base0.10-0 (>= 0.10.0), libgstreamer0.10-0 (>= 0.10.14), libogg0 (>= 1.0rc3)
+Filename: gstreamer0.10-silly_0.1-0_all.deb
+Size: 52016
+MD5sum: bbaf259e0dfcb39050061181d2a13755
+SHA1: be59be2d82b7f57097f387a22f5f295d202d9c1d
+SHA256: 6b91b67de10ae547cd4c648ef343c8acd35e626e4a1ac20df1aaae51d6ec6328
+SHA512: 5f8457338d9bb5de5e65544828bc4be8a32bb3afbe3dd7c035e7a11216831c5aa2faec2c138c7f4ee3d2e9febc0d8fa7689a0781a00332c5e3441a96d633b1e7
+Description: gstreamer plugin test package
+ Silly packages is a set of packages which will break your package
+ management tool. They are created only for debugging purposes.
+ .
+ This package is a GStreamer test plugin package.
+Gstreamer-Version: 0.10
+Gstreamer-Decoders: audio/ac3; audio/mpeg, mpegversion=(int){ 1, 2, 4 }; 
+Gstreamer-Elements: ac3parse
+

=== modified file 'tests/repo/gstreamer0.10-silly_0.1-0_all.deb'
Binary files tests/repo/gstreamer0.10-silly_0.1-0_all.deb	2011-01-10 07:37:44 +0000 and tests/repo/gstreamer0.10-silly_0.1-0_all.deb	2012-02-02 05:55:21 +0000 differ
=== modified file 'tests/test_pk.py'
--- tests/test_pk.py	2011-12-06 04:57:18 +0000
+++ tests/test_pk.py	2012-02-02 05:55:21 +0000
@@ -8,8 +8,10 @@
 import subprocess
 import tempfile
 import time
+import sys
 import unittest
 
+from gi.repository import GLib
 from gi.repository import PackageKitGlib as pk
 
 import aptdaemon.test
@@ -29,11 +31,21 @@
         self.chroot.setup()
         self.addCleanup(self.chroot.remove)
         self.chroot.add_test_repository()
+        # set up scratch dir
+        self.workdir = tempfile.mkdtemp()
+        # allow tests to add plugins, etc.
+        self.orig_pythonpath = os.environ.get("PYTHONPATH")
+        os.environ["PYTHONPATH"] = "%s:%s" % (self.workdir, os.environ.get("PYTHONPATH", ""))
         self.start_session_aptd(self.chroot.path)
         # Start the fake PolikcyKit daemon
         self.start_fake_polkitd()
         time.sleep(0.5)
 
+    def tearDown(self):
+        shutil.rmtree(self.workdir)
+        if self.orig_pythonpath:
+            os.environ["PYTHONPATH"] = self.orig_pythonpath
+
     def test_install(self):
         """Test installing a package."""
         self.chroot.add_test_repository()
@@ -177,6 +189,112 @@
         else:
             self.fail("Failed to get dependants of %s" % pkg_id)
 
+    def test_what_provides_unsupported(self):
+        """Test querying for provides for unsupported type."""
+
+        client = pk.Client()
+
+        try:
+            client.what_provides(pk.FilterEnum.NONE, pk.ProvidesEnum.CODEC, 
+                                 ["gstreamer0.10(decoder-audio/ac3)"],
+                                 None, lambda p, t, d: True, None)
+            self.fail("expected GLib.Error failure")
+        except GLib.GError as e:
+            self.assertTrue("codec" in str(e), e)
+            self.assertTrue("not supported" in str(e), e)
+
+    def test_what_provides_plugin(self):
+        """Test querying for provides with plugins."""
+
+        # add plugin for extra codecs
+        f = open(os.path.join(self.workdir, "extra_codecs.py"), "w")
+        f.write("""from packagekit import enums
+
+def fake_what_provides(cache, type, search):
+    if type in (enums.PROVIDES_CODEC, enums.PROVIDES_ANY):
+        if search.startswith('gstreamer'):
+            return [cache["gstreamer0.10-silly"]]
+    raise NotImplementedError('cannot handle type ' + str(type))
+""")
+        f.close()
+        os.mkdir(os.path.join(self.workdir, "extra_codecs-0.egg-info"))
+        f = open(os.path.join(self.workdir, "extra_codecs-0.egg-info", 'entry_points.txt'), "w")
+        f.write("[packagekit.apt.plugins]\nwhat_provides=extra_codecs:fake_what_provides\n")
+        f.close()
+
+        # invalid plugin, should not stop the valid ones
+        os.mkdir(os.path.join(self.workdir, "nonexisting-1.egg-info"))
+        f = open(os.path.join(self.workdir, "nonexisting-1.egg-info", 'entry_points.txt'), "w")
+        f.write("[packagekit.apt.plugins]\nwhat_provides=nonexisting:what_provides\n")
+        f.close()
+
+        # another plugin to test chaining and a new type
+        f = open(os.path.join(self.workdir, "more_stuff.py"), "w")
+        f.write("""from packagekit import enums
+
+def my_what_provides(cache, type, search):
+    if type in (enums.PROVIDES_CODEC, enums.PROVIDES_ANY):
+        if search.startswith('gstreamer'):
+            return [cache["silly-base"]]
+    if type in (enums.PROVIDES_LANGUAGE_SUPPORT, enums.PROVIDES_ANY):
+        if search.startswith('locale('):
+            return [cache["silly-important"]]
+    raise NotImplementedError('cannot handle type ' + str(type))
+""")
+        f.close()
+        os.mkdir(os.path.join(self.workdir, "more_stuff-0.egg-info"))
+        f = open(os.path.join(self.workdir, "more_stuff-0.egg-info", 'entry_points.txt'), "w")
+        f.write("[packagekit.apt.plugins]\nwhat_provides=more_stuff:my_what_provides\n")
+        f.close()
+
+        client = pk.Client()
+
+        # search for CODEC
+        res = client.what_provides(pk.FilterEnum.NONE, pk.ProvidesEnum.CODEC, 
+                                   ["gstreamer0.10(decoder-audio/vorbis)"],
+                                   None, lambda p, t, d: True, None)
+        self.assertEqual(res.get_exit_code(), pk.ExitEnum.SUCCESS)
+        pkgs = [p.get_id().split(";")[0] for p in res.get_package_array()]
+        self.assertEqual(pkgs, ["gstreamer0.10-silly", "silly-base"])
+
+        # search for LANGUAGE_SUPPORT
+        res = client.what_provides(pk.FilterEnum.NONE, pk.ProvidesEnum.LANGUAGE_SUPPORT, 
+                                   ["locale(de_DE)"],
+                                   None, lambda p, t, d: True, None)
+        self.assertEqual(res.get_exit_code(), pk.ExitEnum.SUCCESS)
+        pkgs = [p.get_id().split(";")[0] for p in res.get_package_array()]
+        self.assertEqual(pkgs, ["silly-important"])
+
+        # search ANY
+        res = client.what_provides(pk.FilterEnum.NONE, pk.ProvidesEnum.ANY, 
+                                   ["gstreamer0.10(decoder-audio/vorbis)"],
+                                   None, lambda p, t, d: True, None)
+        self.assertEqual(res.get_exit_code(), pk.ExitEnum.SUCCESS)
+        pkgs = [p.get_id().split(";")[0] for p in res.get_package_array()]
+        self.assertEqual(pkgs, ["gstreamer0.10-silly", "silly-base"])
+
+        res = client.what_provides(pk.FilterEnum.NONE, pk.ProvidesEnum.ANY, 
+                                   ["locale(de_DE)"],
+                                   None, lambda p, t, d: True, None)
+        self.assertEqual(res.get_exit_code(), pk.ExitEnum.SUCCESS)
+        pkgs = [p.get_id().split(";")[0] for p in res.get_package_array()]
+        self.assertEqual(pkgs, ["silly-important"])
+
+        res = client.what_provides(pk.FilterEnum.NONE, pk.ProvidesEnum.ANY, 
+                                   ["modalias(pci:1)"],
+                                   None, lambda p, t, d: True, None)
+        self.assertEqual(res.get_exit_code(), pk.ExitEnum.SUCCESS)
+        self.assertEqual(res.get_package_array(), [])
+
+        # unsupported type with plugins
+        try:
+            client.what_provides(pk.FilterEnum.NONE, pk.ProvidesEnum.PLASMA_SERVICE, 
+                                 ["plasma4(dataengine-weather)"],
+                                 None, lambda p, t, d: True, None)
+            self.fail("expected GLib.Error failure")
+        except GLib.GError as e:
+            self.assertTrue("plasma" in str(e), e)
+            self.assertTrue("not supported" in str(e), e)
 
 def start_dbus_daemon():
     """Start a dbus system daemon.
@@ -205,8 +323,10 @@
     if DEBUG:
         logging.basicConfig(level=logging.DEBUG)
     dbus_proc = start_dbus_daemon()
-    unittest.main()
-    dbus_proc.kill()
-    dbus_proc.wait()
+    try:
+        unittest.main()
+    finally:
+        dbus_proc.kill()
+        dbus_proc.wait()
 
 # vim: ts=4 et sts=4