Merge lp:~vorlon/ubuntu/quantal/aptdaemon/py3 into lp:ubuntu/quantal/aptdaemon

[Steve Langasek]

All ready for merge, passes the tests... feel free to upload if it checks
out in the morning and it's blocking anyone, otherwise I'll plan to upload
when I come online myself.

[lp:~vorlon/ubuntu/quantal/aptdaemon/py3]

105. By Steve Langasek on 2012-06-13

test/test_pk.py: increase the sleep on startup, to allow longer for
fake-polkitd to start up.

=== added directory '.pc'
=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2012-06-13 16:29:18 +0000
@@ -0,0 +1,1 @@
+2

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2012-06-13 16:29:18 +0000
@@ -0,0 +1,2 @@
+disable_simulate_test.patch
+test-suite-fixes

=== added directory '.pc/disable_simulate_test.patch'
=== added directory '.pc/disable_simulate_test.patch/tests'
=== added file '.pc/disable_simulate_test.patch/tests/test_simulate.py'
--- .pc/disable_simulate_test.patch/tests/test_simulate.py	1970-01-01 00:00:00 +0000
+++ .pc/disable_simulate_test.patch/tests/test_simulate.py	2012-06-13 16:29:18 +0000
@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Tests if the daemon forces a simualte during run."""
+
+import logging
+import time
+import unittest
+
+from gi.repository import GObject
+import dbus
+
+import aptdaemon.client
+import aptdaemon.loop
+import aptdaemon.enums
+
+import aptdaemon.test
+
+DEBUG=True
+
+
+class DaemonTest(aptdaemon.test.AptDaemonTestCase):
+
+    """Test the python client."""
+
+    def setUp(self):
+        """Setup a chroot, run the aptdaemon and a fake PolicyKit daemon."""
+        # Setup chroot
+        self.chroot = aptdaemon.test.Chroot()
+        self.chroot.setup()
+        self.addCleanup(self.chroot.remove)
+        # Start aptdaemon with the chroot on the session bus
+        self.start_dbus_daemon()
+        self.bus = dbus.bus.BusConnection(self.dbus_address)
+        self.start_session_aptd(self.chroot.path)
+        # Start the fake PolikcyKit daemon
+        self.start_fake_polkitd()
+        time.sleep(1)
+
+    def _on_finished(self, trans, exit):
+        """Callback to stop the mainloop after a transaction is done."""
+        aptdaemon.loop.mainloop.quit()
+
+    def test_detect_unauthenticated(self):
+        """Test if the installation of an unauthenticated packages fails
+        if simulate hasn't been called explicitly before.
+        """
+        self.chroot.add_test_repository(copy_sig=False)
+        self.client = aptdaemon.client.AptClient(self.bus)
+        trans = self.client.install_packages(["silly-base"])
+        trans.connect("finished", self._on_finished)
+        trans.run()
+        aptdaemon.loop.mainloop.run()
+        self.assertEqual(trans.exit, aptdaemon.enums.EXIT_FAILED)
+        self.assertEqual(trans.error.code,
+                         aptdaemon.enums.ERROR_PACKAGE_UNAUTHENTICATED)
+        self.assertEqual(trans.unauthenticated, ["silly-base"])
+
+    def test_environment(self):
+        """Ensure that the test environment works."""
+        self.chroot.add_test_repository()
+        self.client = aptdaemon.client.AptClient(self.bus)
+        trans = self.client.install_packages(["silly-base"])
+        trans.connect("finished", self._on_finished)
+        trans.run()
+        aptdaemon.loop.mainloop.run()
+        self.assertEqual(trans.exit, aptdaemon.enums.EXIT_SUCCESS)
+
+
+if __name__ == "__main__":
+    if DEBUG:
+        logging.basicConfig(level=logging.DEBUG)
+    unittest.main()
+
+# vim: ts=4 et sts=4

=== added directory '.pc/test-suite-fixes'
=== added directory '.pc/test-suite-fixes/aptdaemon'
=== added file '.pc/test-suite-fixes/aptdaemon/test.py'
--- .pc/test-suite-fixes/aptdaemon/test.py	1970-01-01 00:00:00 +0000
+++ .pc/test-suite-fixes/aptdaemon/test.py	2012-06-13 16:29:18 +0000
@@ -0,0 +1,296 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Small helpers for the test suite."""
+# Copyright (C) 2011 Sebastian Heinlein <[e-mail]>
+#
+# Licensed under the GNU General Public License Version 2
+#
+# 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; either version 2 of the License, or
+# at your option) any later version.
+#
+# 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+# Licensed under the GNU General Public License Version 2
+
+__author__  = "Sebastian Heinlein <[e-mail]>"
+__all__ = ("get_tests_dir", "Chroot", "AptDaemonTestCase")
+
+import inspect
+import os
+import shutil
+import subprocess
+import sys
+import time
+import tempfile
+import unittest
+
+if sys.version_info.major > 2:
+    from http.server import HTTPServer
+    from http.server import SimpleHTTPRequestHandler as HTTPRequestHandler
+else:
+    from BaseHTTPServer import HTTPServer
+    from SimpleHTTPServer import SimpleHTTPRequestHandler as HTTPRequestHandler
+
+import apt_pkg
+import apt.auth
+
+PY3K = sys.version_info.major > 2
+
+
+class Chroot(object):
+
+    """Provides a chroot which can be used by APT."""
+
+    def __init__(self, prefix="tmp"):
+        self.path = tempfile.mkdtemp(prefix)
+
+    def setup(self):
+        """Setup the chroot and modify the apt configuration."""
+        for subdir in ["alternatives", "info", "parts", "updates", "triggers"]:
+            path = os.path.join(self.path, "var", "lib", "dpkg", subdir)
+            os.makedirs(path)
+        for fname in ["status", "available"]:
+            with open(os.path.join(self.path, "var", "lib", "dpkg", fname),
+                      "w"):
+                pass
+        os.makedirs(os.path.join(self.path, "var/cache/apt/archives/partial"))
+        os.makedirs(os.path.join(self.path, "var/lib/apt/lists"))
+        os.makedirs(os.path.join(self.path, "var/lib/apt/lists/partial"))
+        os.makedirs(os.path.join(self.path, "etc/apt/apt.conf.d"))
+        os.makedirs(os.path.join(self.path, "etc/apt/sources.list.d"))
+        os.makedirs(os.path.join(self.path, "etc/apt/preferences.d"))
+        os.makedirs(os.path.join(self.path, "var/log"))
+        os.makedirs(os.path.join(self.path, "media"))
+
+        # Make apt use the new chroot
+        dpkg_wrapper = os.path.join(get_tests_dir(), "dpkg-wrapper.sh")
+        apt_key_wrapper = os.path.join(get_tests_dir(), "fakeroot-apt-key")
+        config_path = os.path.join(self.path, "etc/apt/apt.conf.d/10chroot")
+        with open(config_path, "w") as cnf:
+            cnf.write("Dir::Bin::DPkg %s;" % dpkg_wrapper)
+            cnf.write("Dir::Bin::Apt-Key %s;" % apt_key_wrapper)
+        apt_pkg.read_config_file(apt_pkg.config, config_path)
+        apt_pkg.init_system()
+
+    def remove(self):
+        """Remove the files of the chroot."""
+        apt_pkg.config.clear("Dir")
+        apt_pkg.config.clear("Dir::State::Status")
+        apt_pkg.init()
+        shutil.rmtree(self.path)
+
+    def add_trusted_key(self):
+        """Add glatzor's key to the trusted ones."""
+        apt.auth.add_key_from_file(os.path.join(get_tests_dir(),
+                                                "repo/glatzor.gpg"))
+
+    def install_debfile(self, path, force_depends=False):
+        """Install a package file into the chroot."""
+        cmd_list = ["fakeroot", "dpkg", "--root", self.path,
+                    "--log=%s/var/log/dpkg.log" % self.path]
+        if force_depends:
+            cmd_list.append("--force-depends")
+        cmd_list.extend(["--install", path])
+        cmd = subprocess.Popen(cmd_list,
+                               env={"PATH": "/sbin:/bin:/usr/bin:/usr/sbin"})
+        cmd.communicate()
+
+    def add_test_repository(self, copy_list=True, copy_sig=True):
+        """Add the test repository to the to the chroot."""
+        return self.add_repository(os.path.join(get_tests_dir(), "repo"),
+                                   copy_list, copy_sig)
+
+    def add_cdrom_repository(self):
+        """Emulate a repository on removable device."""
+        # Create the content of a fake cdrom
+        media_path = os.path.join(self.path, "tmp/fake-cdrom")
+        # The cdom gets identified by the info file
+        os.makedirs(os.path.join(media_path, ".disk"))
+        with open(os.path.join(media_path, ".disk/info"), "w") as info:
+            info.write("This is a fake CDROM")
+        # Copy the test repository "on" the cdrom
+        shutil.copytree(os.path.join(get_tests_dir(), "repo"),
+                        os.path.join(media_path, "repo"))
+
+        # Call apt-cdrom add
+        mount_point = self.mount_cdrom()
+        os.system("apt-cdrom add -m -d %s "
+                  "-o 'Debug::Acquire::cdrom'=True "
+                  "-o 'Acquire::cdrom::AutoDetect'=False "
+                  "-o 'Dir'=%s" % (mount_point, self.path))
+        self.unmount_cdrom()
+
+        config_path = os.path.join(self.path, "etc/apt/apt.conf.d/11cdrom")
+        with open(config_path, "w") as cnf:
+            cnf.write('Debug::Acquire::cdrom True;\n'
+                      'Acquire::cdrom::AutoDetect False;\n'
+                      'Acquire::cdrom::NoMount True;\n'
+                      'Acquire::cdrom::mount "%s";' % mount_point)
+
+    def mount_cdrom(self):
+        """Copy the repo information to the CDROM mount point."""
+        mount_point = os.path.join(self.path, "media/cdrom")
+        os.symlink(os.path.join(self.path, "tmp/fake-cdrom"), mount_point)
+        return mount_point
+
+    def unmount_cdrom(self):
+        """Remove all files from the mount point."""
+        os.unlink(os.path.join(self.path, "media/cdrom"))
+
+    def add_repository(self, path, copy_list=True, copy_sig=True):
+        """Add a sources.list entry to the chroot."""
+        # Add a sources list
+        lst_path = os.path.join(self.path, "etc/apt/sources.list")
+        with open(lst_path, "w") as lst_file:
+            lst_file.write("deb file://%s ./ # Test repository" % path)
+        if copy_list:
+            filename = apt_pkg.uri_to_filename("file://%s/." % path)
+            shutil.copy(os.path.join(path, "Packages"),
+                        "%s/var/lib/apt/lists/%s_Packages" % (self.path,
+                                                              filename))
+            if os.path.exists(os.path.join(path, "Release")):
+                shutil.copy(os.path.join(path, "Release"),
+                            "%s/var/lib/apt/lists/%s_Release" % (self.path,
+                                                                 filename))
+            if copy_sig and os.path.exists(os.path.join(path, "Release.gpg")):
+                shutil.copy(os.path.join(path, "Release.gpg"),
+                            "%s/var/lib/apt/lists/%s_Release.gpg" % (self.path,
+                                                                     filename))
+
+
+class AptDaemonTestCase(unittest.TestCase):
+
+    @classmethod
+    def setupClass(cls):
+        # Start with a clean APT configuration to remove changes
+        # of previous tests
+        for key in set([key.split("::")[0] for key in apt_pkg.config.keys()]):
+            apt_pkg.config.clear(key)
+        apt_pkg.init_config()
+
+    def start_fake_polkitd(self, options="all"):
+        """Start a fake PolicyKit daemon.
+
+        :param allowed_actions: comma separated list of allowed actions.
+                                Defaults to all
+        """
+        try:
+            env = os.environ.copy()
+            env["DBUS_SYSTEM_BUS_ADDRESS"] = self.dbus_address
+        except AttributeError:
+            env=None
+        dir = get_tests_dir()
+        proc = subprocess.Popen([os.path.join(dir, "fake-polkitd.py"),
+                                "--allowed-actions", options],
+                                env=env)
+        self.addCleanup(self._kill_process, proc)
+        return proc
+
+    def start_session_aptd(self, chroot="/"):
+        """Start an aptdaemon which listens on the session D-Bus.
+
+        :param chroot: path to the chroot
+        """
+        try:
+            env = os.environ.copy()
+            env["DBUS_SYSTEM_BUS_ADDRESS"] = self.dbus_address
+        except AttributeError:
+            env = None
+        dir = get_tests_dir()
+        if dir == "/usr/share/aptdaemon/tests":
+            path = "/usr/sbin/aptd"
+        else:
+            path = os.path.join(dir, "../aptd")
+        proc = subprocess.Popen(["python3", path, "--debug",
+                                 "--disable-timeout", "--disable-plugins",
+                                 "--chroot", chroot],
+                                 env=env)
+        self.addCleanup(self._kill_process, proc)
+        return proc
+
+    def start_dbus_daemon(self):
+        """Start a private D-Bus daemon and return its process and address."""
+        proc, dbus_address = start_dbus_daemon()
+        self.addCleanup(self._kill_process, proc)
+        self.dbus_address = dbus_address
+
+    def start_keyserver(self, filename=None):
+        """Start a fake keyserver on hkp://localhost:19191
+
+        Keyword arguments:
+        filename -- Optional path to a GnuPG pulic key file which should
+            be returned by lookups. By default the key of the test repo
+            is used.
+        """
+        dir = tempfile.mkdtemp(prefix="keyserver-test-")
+        self.addCleanup(shutil.rmtree, dir)
+        os.mkdir(os.path.join(dir, "pks"))
+        if filename is None:
+            filename = os.path.join(get_tests_dir(), "repo/glatzor.gpg")
+        shutil.copy(filename, os.path.join(dir, "pks", "lookup"))
+
+        pid = os.fork()
+        if pid == 0:
+            # quiesce server log
+            os.dup2(os.open('/dev/null', os.O_WRONLY), sys.stderr.fileno())
+            os.chdir(dir)
+            httpd = HTTPServer(('localhost', 19191), HTTPRequestHandler)
+            httpd.serve_forever()
+            os._exit(0)
+        else:
+            self.addCleanup(self._kill_pid, pid)
+
+        # wait a bit until server is ready
+        time.sleep(0.5)
+
+    def _kill_pid(self, pid):
+        os.kill(pid, 15)
+        os.wait()
+
+    def _kill_process(self, proc):
+        proc.kill()
+        proc.wait()
+
+
+def get_tests_dir():
+    """Return the absolute path to the tests directory."""
+    # Try to detect a relative tests dir if we are running from the source
+    # directory
+    try:
+        path = inspect.getsourcefile(sys.modules["aptdaemon.test"])
+    except KeyError as error:
+        path = inspect.getsourcefile(inspect.currentframe())
+    path = os.path.realpath(path)
+    relative_path = os.path.join(os.path.dirname(path), "../tests")
+    if os.path.exists(os.path.join(relative_path, "repo/Packages")):
+        return os.path.normpath(relative_path)
+    # Fallback to an absolute path
+    elif os.path.exists("/usr/share/aptdaemon/tests/repo/Packages"):
+        return "/usr/share/aptdaemon/tests"
+    else:
+        raise Exception("Could not find tests direcotry")
+
+def start_dbus_daemon():
+    """Start a private D-Bus daemon and return its process and address."""
+    config_path = os.path.join(get_tests_dir(), "dbus.conf")
+    proc = subprocess.Popen(["dbus-daemon", "--nofork",
+                             "--print-address", "--config-file",
+                             config_path],
+                             stdout=subprocess.PIPE)
+    output = proc.stdout.readline().strip()
+    if PY3K:
+        dbus_address = output.decode()
+    else:
+        dbus_address = output
+    return proc, dbus_address
+
+
+# vim: ts=4 et sts=4

=== added file '.pc/test-suite-fixes/aptdaemon/worker.py'
--- .pc/test-suite-fixes/aptdaemon/worker.py	1970-01-01 00:00:00 +0000
+++ .pc/test-suite-fixes/aptdaemon/worker.py	2012-06-13 16:29:18 +0000
@@ -0,0 +1,1544 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Provides AptWorker which processes transactions."""
+# Copyright (C) 2008-2009 Sebastian Heinlein <[e-mail]>
+#
+# 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; either version 2 of the License, or
+# any later version.
+#
+# 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.
+
+__author__  = "Sebastian Heinlein <[e-mail]>"
+
+__all__ = ("AptWorker", "DummyWorker")
+
+import contextlib
+import logging
+import os
+import platform
+import re
+import shutil
+import sys
+import tempfile
+import time
+import traceback
+from urllib.parse import urlsplit, urlunsplit
+
+import apt
+import apt.auth
+import apt.cache
+import apt.debfile
+import apt_pkg
+import aptsources
+import aptsources.distro
+from aptsources.sourceslist import SourcesList
+from gi.repository import GObject
+import pkg_resources
+import subprocess
+
+from .enums import *
+from .errors import *
+from . import lock
+from .loop import mainloop
+from .progress import DaemonOpenProgress, \
+                     DaemonInstallProgress, \
+                     DaemonAcquireProgress, \
+                     DaemonAcquireRepoProgress, \
+                     DaemonDpkgInstallProgress, \
+                     DaemonDpkgReconfigureProgress, \
+                     DaemonDpkgRecoverProgress, \
+                     DaemonForkProgress
+
+log = logging.getLogger("AptDaemon.Worker")
+
+# Just required to detect translatable strings. The translation is done by
+# core.Transaction.gettext
+_ = lambda s: s
+
+
+class AptWorker(GObject.GObject):
+
+    """Worker which processes transactions from the queue."""
+
+    __gsignals__ = {"transaction-done":(GObject.SignalFlags.RUN_FIRST,
+                                        None,
+                                        (GObject.TYPE_PYOBJECT,)),
+                    "transaction-simulated":(GObject.SignalFlags.RUN_FIRST,
+                                             None,
+                                             (GObject.TYPE_PYOBJECT,))}
+
+    # the basedir under which license keys can be stored
+    LICENSE_KEY_ROOTDIR = "/opt/"
+
+    def __init__(self, chroot=None, load_plugins=True):
+        """Initialize a new AptWorker instance."""
+        GObject.GObject.__init__(self)
+        self.trans = None
+        self.last_action_timestamp = time.time()
+        self._cache = None
+        # Store the the tid of the transaction whose changes are currently
+        # marked in the cache
+        self.marked_tid = None
+
+        # Change to a given chroot
+        if chroot:
+            apt_conf_file = os.path.join(chroot, "etc/apt/apt.conf")
+            if os.path.exists(apt_conf_file):
+                apt_pkg.read_config_file(apt_pkg.config, apt_conf_file)
+            apt_conf_dir = os.path.join(chroot, "etc/apt/apt.conf.d")
+            if os.path.isdir(apt_conf_dir):
+                apt_pkg.read_config_dir(apt_pkg.config, apt_conf_dir)
+            apt_pkg.config["Dir"] = chroot
+            apt_pkg.config["Dir::State::Status"] = os.path.join(chroot,
+                                                          "var/lib/dpkg/status")
+            apt_pkg.config.clear("DPkg::Post-Invoke")
+            apt_pkg.config.clear("DPkg::Options")
+            apt_pkg.config["DPkg::Options::"] = "--root=%s" % chroot
+            apt_pkg.config["DPkg::Options::"] = "--log=%s/var/log/dpkg.log" % \
+                                                chroot
+            status_file = apt_pkg.config.find_file("Dir::State::status")
+            lock.status_lock.path = os.path.join(os.path.dirname(status_file),
+                                                 "lock")
+            archives_dir = apt_pkg.config.find_dir("Dir::Cache::Archives")
+            lock.archive_lock.path = os.path.join(archives_dir, "lock")
+            lists_dir = apt_pkg.config.find_dir("Dir::State::lists")
+            lock.lists_lock.path = os.path.join(lists_dir, "lock")
+            apt_pkg.init_system()
+
+        self._status_orig = apt_pkg.config.find_file("Dir::State::status")
+        self._status_frozen = None
+        self.plugins = {}
+        if load_plugins:
+            self._load_plugins()
+
+    def _load_plugins(self):
+        """Load the plugins from setuptools' entry points."""
+        plugin_dirs = [os.path.join(os.path.dirname(__file__), "plugins")]
+        env = pkg_resources.Environment(plugin_dirs)
+        dists, errors = pkg_resources.working_set.find_plugins(env)
+        for dist in dists:
+            pkg_resources.working_set.add(dist)
+        for name in ["modify_cache_after", "modify_cache_before",
+                     "get_license_key"]:
+            for ept in pkg_resources.iter_entry_points("aptdaemon.plugins",
+                                                       name):
+                try:
+                    self.plugins.setdefault(name, []).append(ept.load())
+                except:
+                    log.critical("Failed to load %s plugin: "
+                                 "%s" % (name, ept.dist))
+                else:
+                    log.debug("Loaded %s plugin: %s", name, ept.dist)
+
+    def _call_plugins(self, name, resolver=None):
+        """Call all plugins of a given type."""
+        if not resolver:
+            # If the resolver of the original task isn't available we create
+            # a new one and protect the already marked changes
+            resolver = apt.cache.ProblemResolver(self._cache)
+            for pkg in self._cache.get_changes():
+                resolver.clear(pkg)
+                resolver.protect(pkg)
+                if pkg.marked_delete:
+                    resolver.remove(pkg)
+        if not name in self.plugins:
+            log.debug("There isn't any registered %s plugin" % name)
+            return False
+        for plugin in self.plugins[name]:
+            log.debug("Calling %s plugin: %s", name, plugin)
+            try:
+                plugin(resolver, self._cache)
+            except Exception as error:
+                log.critical("Failed to call %s plugin:\n%s" % (plugin, error))
+        return True
+
+    def run(self, transaction):
+        """Process the given transaction in the background.
+
+        Keyword argument:
+        transaction -- core.Transcation instance to run
+        """
+        log.info("Processing transaction %s", transaction.tid)
+        if self.trans:
+            raise Exception("There is already a running transaction")
+        self.trans = transaction
+        GObject.idle_add(self._process_transaction, transaction)
+
+    def _emit_transaction_simulated(self, trans):
+        """Emit the transaction-simulated signal.
+
+        Keyword argument:
+        trans -- the simulated transaction
+        """
+        log.debug("Emitting transaction-simulated: %s", trans.tid)
+        self.emit("transaction-simulated", trans)
+
+    def _emit_transaction_done(self, trans):
+        """Emit the transaction-done signal.
+
+        Keyword argument:
+        trans -- the finished transaction
+        """
+        log.debug("Emitting transaction-done: %s", trans.tid)
+        self.emit("transaction-done", trans)
+
+    def _process_transaction(self, trans):
+        """Run the worker"""
+        self.last_action_timestamp = time.time()
+        trans.status = STATUS_RUNNING
+        trans.progress = 11
+        try:
+            lock.wait_for_lock(trans)
+            # Prepare the package cache
+            if trans.role == ROLE_FIX_INCOMPLETE_INSTALL or \
+               not self.is_dpkg_journal_clean():
+                self.fix_incomplete_install(trans)
+            # Process transaction which don't require a cache
+            if trans.role == ROLE_ADD_VENDOR_KEY_FILE:
+                self.add_vendor_key_from_file(trans, **trans.kwargs)
+            elif trans.role == ROLE_ADD_VENDOR_KEY_FROM_KEYSERVER:
+                self.add_vendor_key_from_keyserver(trans, **trans.kwargs)
+            elif trans.role == ROLE_REMOVE_VENDOR_KEY:
+                self.remove_vendor_key(trans, **trans.kwargs)
+            elif trans.role == ROLE_ADD_REPOSITORY:
+                self.add_repository(trans, **trans.kwargs)
+            elif trans.role == ROLE_ENABLE_DISTRO_COMP:
+                self.enable_distro_comp(trans, **trans.kwargs)
+            elif trans.role == ROLE_RECONFIGURE:
+                self.reconfigure(trans, trans.packages[PKGS_REINSTALL],
+                                 **trans.kwargs)
+            elif trans.role == ROLE_CLEAN:
+                self.clean(trans)
+            # Check if the transaction has been just simulated. So we could
+            # skip marking the changes a second time.
+            elif trans.role in (ROLE_REMOVE_PACKAGES, ROLE_INSTALL_PACKAGES,
+                                ROLE_UPGRADE_PACKAGES, ROLE_COMMIT_PACKAGES,
+                                ROLE_UPGRADE_SYSTEM,
+                                ROLE_FIX_BROKEN_DEPENDS) and \
+                 self.marked_tid == trans.tid:
+                self._apply_changes(trans)
+                trans.exit = EXIT_SUCCESS
+                return False
+            else:
+                self._open_cache(trans)
+            # Process transaction which can handle a broken dep cache
+            if trans.role == ROLE_FIX_BROKEN_DEPENDS:
+                self.fix_broken_depends(trans)
+            elif trans.role == ROLE_UPDATE_CACHE:
+                self.update_cache(trans, **trans.kwargs)
+            # Process the transactions which require a consistent cache
+            elif trans.role == ROLE_ADD_LICENSE_KEY:
+                self.add_license_key(trans, **trans.kwargs)
+            elif self._cache and self._cache.broken_count:
+                broken = [pkg.name for pkg in self._cache if pkg.is_now_broken]
+                raise TransactionFailed(ERROR_CACHE_BROKEN,
+                                        self._get_broken_details(trans))
+            if trans.role == ROLE_PK_QUERY:
+                self.query(trans)
+            elif trans.role == ROLE_INSTALL_FILE:
+                self.install_file(trans, **trans.kwargs)
+            elif trans.role in [ROLE_REMOVE_PACKAGES, ROLE_INSTALL_PACKAGES,
+                                ROLE_UPGRADE_PACKAGES, ROLE_COMMIT_PACKAGES]:
+                self.commit_packages(trans, *trans.packages)
+            elif trans.role == ROLE_UPGRADE_SYSTEM:
+                self.upgrade_system(trans, **trans.kwargs)
+        except TransactionCancelled:
+            trans.exit = EXIT_CANCELLED
+        except TransactionFailed as excep:
+            trans.error = excep
+            trans.exit = EXIT_FAILED
+        except (KeyboardInterrupt, SystemExit):
+            trans.exit = EXIT_CANCELLED
+        except Exception as excep:
+            tbk = traceback.format_exc()
+            trans.error = TransactionFailed(ERROR_UNKNOWN, tbk)
+            trans.exit = EXIT_FAILED
+            try:
+                from . import crash
+            except ImportError:
+                pass
+            else:
+                crash.create_report("%s: %s" % (type(excep), str(excep)),
+                                    tbk, trans)
+        else:
+            trans.exit = EXIT_SUCCESS
+        finally:
+            trans.progress = 100
+            self.last_action_timestamp = time.time()
+            tid = trans.tid[:]
+            self.trans = None
+            self.marked_tid = None
+            self._emit_transaction_done(trans)
+            lock.release()
+            log.info("Finished transaction %s", tid)
+        return False
+
+    def commit_packages(self, trans, install, reinstall, remove, purge, upgrade,
+                        downgrade, simulate=False):
+        """Perform a complex package operation.
+
+        Keyword arguments:
+        trans - the transaction
+        install - list of package names to install
+        reinstall - list of package names to reinstall
+        remove - list of package names to remove
+        purge - list of package names to purge including configuration files
+        upgrade - list of package names to upgrade
+        downgrade - list of package names to upgrade
+        simulate -- if True the changes won't be applied
+        """
+        log.info("Committing packages: %s, %s, %s, %s, %s, %s",
+                 install, reinstall, remove, purge, upgrade, downgrade)
+        with self._cache.actiongroup():
+            resolver = apt.cache.ProblemResolver(self._cache)
+            self._mark_packages_for_installation(install, resolver)
+            self._mark_packages_for_installation(reinstall, resolver,
+                                                 reinstall=True)
+            self._mark_packages_for_removal(remove, resolver)
+            self._mark_packages_for_removal(purge, resolver, purge=True)
+            self._mark_packages_for_upgrade(upgrade, resolver)
+            self._mark_packages_for_downgrade(downgrade, resolver)
+            self._resolve_depends(trans, resolver)
+        self._check_obsoleted_dependencies(trans, resolver)
+        if not simulate:
+            self._apply_changes(trans)
+
+    def _resolve_depends(self, trans, resolver):
+        """Resolve the dependencies using the given ProblemResolver."""
+        self._call_plugins("modify_cache_before", resolver)
+        resolver.install_protect()
+        try:
+            resolver.resolve()
+        except SystemError:
+            raise TransactionFailed(ERROR_DEP_RESOLUTION_FAILED,
+                                    self._get_broken_details(trans, now=False))
+        if self._call_plugins("modify_cache_after", resolver):
+            try:
+                resolver.resolve()
+            except SystemError:
+                details = self._get_broken_details(trans, now=False)
+                raise TransactionFailed(ERROR_DEP_RESOLUTION_FAILED, details)
+
+    @staticmethod
+    def _split_package_id(package):
+        """Return the name, the version number and the release of the
+        specified package."""
+        if "=" in package:
+            name, version = package.split("=", 1)
+            release = None
+        elif "/" in package:
+            name, release = package.split("/", 1)
+            version = None
+        else:
+            name = package
+            version = release = None
+        return name, version, release
+
+    def _get_unauthenticated(self):
+        """Return a list of unauthenticated package names """
+        unauthenticated = []
+        for pkg in self._iterate_packages():
+            if (pkg.marked_install or
+                pkg.marked_downgrade or
+                pkg.marked_upgrade or
+                pkg.marked_reinstall):
+                trusted = False
+                for origin in pkg.candidate.origins:
+                    trusted |= origin.trusted
+                if not trusted:
+                    unauthenticated.append(pkg.name)
+        return unauthenticated
+
+    def _mark_packages_for_installation(self, packages, resolver,
+                                        reinstall=False):
+        """Mark packages for installation."""
+        for pkg_name, pkg_ver, pkg_rel in [self._split_package_id(pkg)
+                                           for pkg in packages]:
+            try:
+                pkg = self._cache[pkg_name]
+            except KeyError:
+                raise TransactionFailed(ERROR_NO_PACKAGE,
+                                        _("Package %s isn't available"),
+                                        pkg_name)
+            if reinstall:
+                if not pkg.is_installed:
+                    raise TransactionFailed(ERROR_PACKAGE_NOT_INSTALLED,
+                                            _("Package %s isn't installed"),
+                                            pkg.name)
+                if pkg_ver and pkg.installed.version != pkg_ver:
+                    raise TransactionFailed(ERROR_PACKAGE_NOT_INSTALLED,
+                                            _("The version %s of %s isn't "
+                                              "installed"),
+                                            pkg_ver, pkg_name)
+            else:
+                # Fail if the user requests to install the same version
+                # of an already installed package.
+                if (pkg.is_installed and
+                    # Compare version numbers
+                    pkg_ver and pkg_ver == pkg.installed.version and
+                    # Optionally compare the origin if specified
+                    (not pkg_rel or
+                     pkg_rel in [origin.archive for
+                                 origin in pkg.installed.origins])):
+                        raise TransactionFailed(ERROR_PACKAGE_ALREADY_INSTALLED,
+                                                _("Package %s is already "
+                                                  "installed"), pkg_name)
+            pkg.mark_install(False, True, True)
+            resolver.clear(pkg)
+            resolver.protect(pkg)
+            if pkg_ver:
+                try:
+                    pkg.candidate = pkg.versions[pkg_ver]
+                except KeyError:
+                    raise TransactionFailed(ERROR_NO_PACKAGE,
+                                            _("The version %s of %s isn't "
+                                              "available."), pkg_ver, pkg_name)
+            elif pkg_rel:
+                self._set_candidate_release(pkg, pkg_rel)
+ 
+
+    def enable_distro_comp(self, trans, component):
+        """Enable given component in the sources list.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        component -- a component, e.g. main or universe
+        """
+        trans.progress = 101
+        trans.status = STATUS_COMMITTING
+        old_umask = os.umask(0o022)
+        try:
+            sourceslist = SourcesList()
+            distro = aptsources.distro.get_distro()
+            distro.get_sources(sourceslist)
+            distro.enable_component(component)
+            sourceslist.save()
+        finally:
+            os.umask(old_umask)
+
+    def add_repository(self, trans, src_type, uri, dist, comps, comment, sourcesfile):
+        """Add given repository to the sources list.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        src_type -- the type of the entry (deb, deb-src)
+        uri -- the main repository uri (e.g. http://archive.ubuntu.com/ubuntu)
+        dist -- the distribution to use (e.g. karmic, "/")
+        comps -- a (possible empty) list of components (main, restricted)
+        comment -- an (optional) comment
+        sourcesfile -- an (optinal) filename in sources.list.d 
+        """
+        trans.progress = 101
+        trans.status = STATUS_COMMITTING
+
+        if sourcesfile:
+            if not sourcesfile.endswith(".list"):
+                sourcesfile += ".list"
+            dir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
+            sourcesfile = os.path.join(dir, os.path.basename(sourcesfile))
+        else:
+            sourcesfile = None
+        # Store any private login information in a separate auth.conf file
+        if re.match("(http|https|ftp)://\S+?:\S+?@\S+", uri):
+            uri = self._store_and_strip_password_from_uri(uri)
+            auth_conf_path = apt_pkg.config.find_file("Dir::etc::netrc")
+            if not comment:
+                comment = "credentials stored in %s" % auth_conf_path
+            else:
+                comment += "; credentials stored in %s" % auth_conf_path
+        try:
+            sources = SourcesList()
+            entry = sources.add(src_type, uri, dist, comps, comment,
+                                file=sourcesfile)
+            if entry.invalid:
+                #FIXME: Introduce new error codes
+                raise RepositoryInvalidError()
+        except:
+            log.exception("adding repository")
+            raise
+        else:
+            sources.save()
+
+    def _store_and_strip_password_from_uri(self, uri):
+        """Extract the credentials from an URI. Store the password in
+        auth.conf and return the URI without any password information.
+        """
+        try:
+            res = urlsplit(uri)
+        except ValueError as error:
+            log.warn("Failed to urlsplit '%s'", error)
+            return uri
+        netloc_public = res.netloc.replace("%s:%s@" % (res.username,
+                                                       res.password),
+                                           "")
+
+        # write auth.conf
+        auth_conf_path = apt_pkg.config.find_file("Dir::etc::netrc")
+        old_umask = os.umask(0o027)
+        try:
+            with open(auth_conf_path, "a") as auth_conf:
+                auth_conf.write("""machine %s
+login %s
+password %s\n\n""" % (netloc_public + res.path, res.username, res.password))
+        except OSError as error:
+            log.warn("Failed to write auth.conf: '%s'" % error)
+        finally:
+            os.umask(old_umask)
+
+        # Return URI without user/pass
+        return urlunsplit((res.scheme, netloc_public, res.path, res.query,
+                           res.fragment))
+
+    def add_vendor_key_from_keyserver(self, trans, keyid, keyserver):
+        """Add the signing key from the given (keyid, keyserver) to the
+        trusted vendors.
+
+        Keyword argument:
+        trans -- the corresponding transaction
+        keyid - the keyid of the key (e.g. 0x0EB12F05)
+        keyserver - the keyserver (e.g. keyserver.ubuntu.com)
+        """
+        log.info("Adding vendor key from keyserver: %s %s", keyid, keyserver)
+        # Perform some sanity checks
+        try:
+            res = urlsplit(keyserver)
+        except ValueError:
+            raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
+                                    #TRANSLATORS: %s is the URL of GnuPG
+                                    #             keyserver
+                                    _("The keyserver URL is invalid: %s"),
+                                    keyserver)
+        if res.scheme not in ["hkp", "ldap", "ldaps", "http", "https"]:
+            raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
+                                    #TRANSLATORS: %s is the URL of GnuPG
+                                    #             keyserver
+                                    _("Invalid protocol of the server: %s"),
+                                    keyserver)
+        try:
+            int(keyid, 16)
+        except ValueError:
+            raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
+                                    #TRANSLATORS: %s is the id of a GnuPG key
+                                    #             e.g. E08ADE95
+                                    _("Invalid key id: %s"), keyid)
+        trans.status = STATUS_DOWNLOADING
+        trans.progress = 101
+        last_pulse = time.time()
+        with DaemonForkProgress(trans) as progress:
+            progress.run(apt.auth.add_key_from_keyserver, keyid, keyserver)
+        if progress._child_exit != 0:
+            #TRANSLATORS: The first %s is the key id and the second the server
+            raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
+                                    _("Failed to download and install the key "
+                                      "%s from %s:\n%s"),
+                                    keyid, keyserver, progress.output)
+
+    def add_vendor_key_from_file(self, trans, path):
+        """Add the signing key from the given file to the trusted vendors.
+
+        Keyword argument:
+        path -- absolute path to the key file
+        """
+        log.info("Adding vendor key from file: %s", path)
+        trans.progress = 101
+        trans.status = STATUS_COMMITTING
+        with DaemonForkProgress(trans) as progress:
+            progress.run(apt.auth.add_key_from_file, path)
+        if progress._child_exit != 0:
+            raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
+                                    _("Key file %s couldn't be installed: %s"),
+                                    path, progress.output)
+
+    def remove_vendor_key(self, trans, fingerprint):
+        """Remove repository key.
+
+        Keyword argument:
+        trans -- the corresponding transaction
+        fingerprint -- fingerprint of the key to remove
+        """
+        log.info("Removing vendor key: %s", fingerprint)
+        trans.progress = 101
+        trans.status = STATUS_COMMITTING
+        try:
+            int(fingerprint, 16)
+        except ValueError:
+            raise TransactionFailed(ERROR_KEY_NOT_REMOVED,
+                                    #TRANSLATORS: %s is the id of a GnuPG key
+                                    #             e.g. E08ADE95
+                                    _("Invalid key id: %s"), fingerprint)
+        with DaemonForkProgress(trans) as progress:
+            progress.run(apt.auth.remove_key, fingerprint)
+        if progress._child_exit != 0:
+            raise TransactionFailed(ERROR_KEY_NOT_REMOVED,
+                                    _("Key with fingerprint %s couldn't be "
+                                      "removed: %s"), fingerprint,
+                                      progress.output)
+
+    def install_file(self, trans, path, force, simulate=False):
+        """Install local package file.
+
+        Keyword argument:
+        trans -- the corresponding transaction
+        path -- absolute path to the package file
+        force -- if installing an invalid package is allowed
+        simulate -- if True the changes won't be committed but the debfile
+                    instance will be returned
+        """
+        log.info("Installing local package file: %s", path)
+        # Check if the dpkg can be installed at all
+        trans.status = STATUS_RESOLVING_DEP
+        deb = self._check_deb_file(path, force, trans.uid)
+        # Check for required changes and apply them before
+        (install, remove, unauth) = deb.required_changes
+        self._call_plugins("modify_cache_after")
+        if simulate:
+            return deb
+        with self._frozen_status():
+            if len(install) > 0 or len(remove) > 0:
+                dpkg_range = (64, 99)
+                self._apply_changes(trans, fetch_range=(15, 33),
+                                    install_range=(34, 63))
+            # Install the dpkg file
+            deb_progress = DaemonDpkgInstallProgress(trans, begin=64, end=95)
+            res = deb.install(deb_progress)
+            encoding = sys.getfilesystemencoding()
+            trans.output += deb_progress.output
+            if res:
+                raise TransactionFailed(ERROR_PACKAGE_MANAGER_FAILED,
+                                        trans.output)
+
+    def _mark_packages_for_removal(self, packages, resolver, purge=False):
+        """Mark packages for installation."""
+        for pkg_name, pkg_ver, pkg_rel in [self._split_package_id(pkg)
+                                           for pkg in packages]:
+            try:
+                pkg = self._cache[pkg_name]
+            except KeyError:
+                raise TransactionFailed(ERROR_NO_PACKAGE,
+                                        _("Package %s isn't available"),
+                                        pkg_name)
+            if not pkg.is_installed and not pkg.installed_files:
+                raise TransactionFailed(ERROR_PACKAGE_NOT_INSTALLED,
+                                        _("Package %s isn't installed"),
+                                        pkg_name)
+            if pkg.essential == True:
+                raise TransactionFailed(ERROR_NOT_REMOVE_ESSENTIAL_PACKAGE,
+                                        _("Package %s cannot be removed."),
+                                        pkg_name)
+            if pkg_ver and pkg.installed != pkg_ver:
+                raise TransactionFailed(ERROR_PACKAGE_NOT_INSTALLED,
+                                        _("The version %s of %s is not "
+                                          "installed"), pkg_ver, pkg_name)
+            pkg.mark_delete(False, purge)
+            resolver.clear(pkg)
+            resolver.protect(pkg)
+            resolver.remove(pkg)
+
+    def _check_obsoleted_dependencies(self, trans, resolver=None):
+        """Mark obsoleted dependencies of to be removed packages for removal."""
+        if not trans.remove_obsoleted_depends:
+            return
+        if not resolver:
+            resolver = apt.cache.ProblemResolver(self._cache)
+        installed_deps = set()
+        with self._cache.actiongroup():
+            for pkg in self._iterate_packages():
+                if pkg.marked_delete:
+                    installed_deps = self._installed_dependencies(pkg.name,
+                                                                 installed_deps)
+            for dep_name in installed_deps:
+                if dep_name in self._cache:
+                    pkg = self._cache[dep_name]
+                    if pkg.is_installed and pkg.is_auto_removable:
+                        pkg.mark_delete(False)
+            # do an additional resolver run to ensure that the autoremove
+            # never leaves the cache in an inconsistent state, see bug
+            # LP: #659111 for the rational, essentially this may happen
+            # if a package is marked install during problem resolving but
+            # is later no longer required. the resolver deals with that
+            self._resolve_depends(trans, resolver)
+
+    def _installed_dependencies(self, pkg_name, all_deps=None):
+        """Recursively return all installed dependencies of a given package."""
+        #FIXME: Should be part of python-apt, since it makes use of non-public
+        #       API. Perhaps by adding a recursive argument to
+        #       apt.package.Version.get_dependencies()
+        if not all_deps:
+            all_deps = set()
+        if not pkg_name in self._cache:
+            return all_deps
+        cur = self._cache[pkg_name]._pkg.current_ver
+        if not cur:
+            return all_deps
+        for sec in ("PreDepends", "Depends", "Recommends"):
+            try:
+                for dep in cur.depends_list[sec]:
+                    dep_name = dep[0].target_pkg.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 _mark_packages_for_downgrade(self, packages, resolver):
+        """Mark packages for downgrade."""
+        for pkg_name, pkg_ver, pkg_rel in [self._split_package_id(pkg)
+                                           for pkg in packages]:
+            try:
+                pkg = self._cache[pkg_name]
+            except KeyError:
+                raise TransactionFailed(ERROR_NO_PACKAGE,
+                                        _("Package %s isn't available"),
+                                        pkg_name)
+            if not pkg.is_installed:
+                raise TransactionFailed(ERROR_PACKAGE_NOT_INSTALLED,
+                                        _("Package %s isn't installed"),
+                                        pkg_name)
+            pkg.mark_install(False, True, pkg.is_auto_installed)
+            resolver.clear(pkg)
+            resolver.protect(pkg)
+            if pkg_ver:
+                if pkg.installed and pkg.installed.version < pkg_ver:
+                    #FIXME: We need a new error enum
+                    raise TransactionFailed(ERROR_NO_PACKAGE,
+                                            _("The former version %s of %s " \
+                                              "is already installed"),
+                                            pkg.installed.version, pkg.name)
+                elif pkg.installed and pkg.installed.version == pkg_ver:
+                    raise TransactionFailed(ERROR_PACKAGE_ALREADY_INSTALLED,
+                                            _("The version %s of %s "
+                                              "is already installed"),
+                                            pkg.installed.version, pkg.name)
+                try:
+                    pkg.candidate = pkg.versions[pkg_ver]
+                except KeyError:
+                    raise TransactionFailed(ERROR_NO_PACKAGE,
+                                            _("The version %s of %s isn't "
+                                              "available"), pkg_ver, pkg_name)
+            else:
+                raise TransactionFailed(ERROR_NO_PACKAGE,
+                                        _("You need to specify a version to " \
+                                          "downgrade %s to"), pkg_name)
+ 
+
+    def _mark_packages_for_upgrade(self, packages, resolver):
+        """Mark packages for upgrade."""
+        for pkg_name, pkg_ver, pkg_rel in [self._split_package_id(pkg)
+                                           for pkg in packages]:
+            try:
+                pkg = self._cache[pkg_name]
+            except KeyError:
+                raise TransactionFailed(ERROR_NO_PACKAGE,
+                                        _("Package %s isn't available"),
+                                        pkg_name)
+            if not pkg.is_installed:
+                raise TransactionFailed(ERROR_PACKAGE_NOT_INSTALLED,
+                                        _("Package %s isn't installed"),
+                                        pkg_name)
+            pkg.mark_install(False, True, pkg.is_auto_installed)
+            resolver.clear(pkg)
+            resolver.protect(pkg)
+            if pkg_ver:
+                if (pkg.installed and
+                    apt_pkg.version_compare(pkg.installed.version,
+                                            pkg_ver) == 1):
+                    raise TransactionFailed(ERROR_PACKAGE_UPTODATE,
+                                            _("The later version %s of %s "
+                                              "is already installed"),
+                                            pkg.installed.version, pkg.name)
+                elif (pkg.installed and
+                      apt_pkg.version_compare(pkg.installed.version,
+                                              pkg_ver) == 0):
+                    raise TransactionFailed(ERROR_PACKAGE_UPTODATE,
+                                            _("The version %s of %s "
+                                              "is already installed"),
+                                            pkg.installed.version, pkg.name)
+                try:
+                    pkg.candidate = pkg.versions[pkg_ver]
+                except KeyError:
+                    raise TransactionFailed(ERROR_NO_PACKAGE,
+                                            _("The version %s of %s isn't "
+                                              "available."), pkg_ver, pkg_name)
+
+            elif pkg_rel:
+                self._set_candidate_release(pkg, pkg_rel)
+
+    @staticmethod
+    def _set_candidate_release(pkg, release):
+        """Set the candidate of a package to the one from the given release."""
+        #FIXME: Should be moved to python-apt
+        # Check if the package is provided in the release
+        for version in pkg.versions:
+            if [origin for origin in version.origins
+                if origin.archive == release]:
+                break
+        else:
+            raise TransactionFailed(ERROR_NO_PACKAGE,
+                                    _("The package %s isn't available in "
+                                      "the %s release."), pkg.name, release)
+        pkg._pcache.cache_pre_change()
+        pkg._pcache._depcache.set_candidate_release(pkg._pkg, version._cand,
+                                                    release)
+        pkg._pcache.cache_post_change()
+
+    def update_cache(self, trans, sources_list):
+        """Update the cache.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        sources_list -- only update the repositories found in the sources.list
+                        snippet by the given file name.
+        """
+        log.info("Updating cache")
+        def compare_pathes(first, second):
+            """Small helper to compare two pathes."""
+            return os.path.normpath(first) == os.path.normpath(second)
+        progress = DaemonAcquireRepoProgress(trans, begin=10, end=90)
+        if sources_list and not sources_list.startswith("/"):
+            dir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
+            sources_list = os.path.join(dir, sources_list)
+        if sources_list:
+            # For security reasons (LP #722228) we only allow files inside
+            # sources.list.d as basedir
+            basedir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
+            system_sources = apt_pkg.config.find_file("Dir::Etc::sourcelist")
+            if "/" in sources_list:
+                sources_list = os.path.abspath(sources_list)
+                # Check if the sources_list snippet is in the sourceparts
+                # directory
+                common_prefix = os.path.commonprefix([sources_list, basedir])
+                if not (compare_pathes(common_prefix, basedir) or
+                        compare_pathes(sources_list, system_sources)):
+                    raise AptDaemonError("Only alternative sources.list files "
+                                         "inside '%s' are allowed (not '%s')" \
+                                         % (basedir, sources_list))
+            else:
+                sources_list = os.path.join(basedir, sources_list)
+        try:
+            self._cache.update(progress, sources_list=sources_list)
+        except apt.cache.FetchFailedException as error:
+            # ListUpdate() method of apt handles a cancelled operation
+            # as a failed one, see LP #162441
+            if trans.cancelled:
+                raise TransactionCancelled()
+            else:
+                raise TransactionFailed(ERROR_REPO_DOWNLOAD_FAILED,
+                                        str(error))
+        except apt.cache.FetchCancelledException:
+            raise TransactionCancelled()
+        except apt.cache.LockFailedException:
+            raise TransactionFailed(ERROR_NO_LOCK)
+        self._open_cache(trans, begin=91, end=95)
+
+    def upgrade_system(self, trans, safe_mode=True, simulate=False):
+        """Upgrade the system.
+
+        Keyword argument:
+        trans -- the corresponding transaction
+        safe_mode -- if additional software should be installed or removed to
+                     satisfy the dependencies the an updates
+        simulate -- if the changes should not be applied
+        """
+        log.info("Upgrade system with safe mode: %s" % safe_mode)
+        trans.status = STATUS_RESOLVING_DEP
+        #FIXME: What to do if already uptotdate? Add error code?
+        self._call_plugins("modify_cache_before")
+        try:
+            self._cache.upgrade(dist_upgrade=not safe_mode)
+        except SystemError as excep:
+            raise TransactionFailed(ERROR_DEP_RESOLUTION_FAILED, str(excep))
+        self._call_plugins("modify_cache_after")
+        self._check_obsoleted_dependencies(trans)
+        if not simulate:
+            self._apply_changes(trans)
+
+    def fix_incomplete_install(self, trans):
+        """Run dpkg --configure -a to recover from a failed installation.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        """
+        log.info("Fixing incomplete installs")
+        trans.status = STATUS_CLEANING_UP
+        with self._frozen_status():
+            with DaemonDpkgRecoverProgress(trans) as progress:
+                progress.run()
+        trans.output += progress.output
+        if progress._child_exit != 0:
+            raise TransactionFailed(ERROR_PACKAGE_MANAGER_FAILED,
+                                    trans.output)
+
+    def reconfigure(self, trans, packages, priority):
+        """Run dpkg-reconfigure to reconfigure installed packages.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        packages -- list of packages to reconfigure
+        priority -- the lowest priority of question which should be asked
+        """
+        log.info("Reconfiguring packages")
+        with self._frozen_status():
+            with DaemonDpkgReconfigureProgress(trans) as progress:
+                progress.run(packages, priority)
+        trans.output += progress.output
+        if progress._child_exit != 0:
+            raise TransactionFailed(ERROR_PACKAGE_MANAGER_FAILED,
+                                    trans.output)
+
+    def fix_broken_depends(self, trans, simulate=False):
+        """Try to fix broken dependencies.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        simualte -- if the changes should not be applied
+        """
+        log.info("Fixing broken depends")
+        trans.status = STATUS_RESOLVING_DEP
+        try:
+            self._cache._depcache.fix_broken()
+        except SystemError:
+            raise TransactionFailed(ERROR_DEP_RESOLUTION_FAILED,
+                                    self._get_broken_details(trans))
+        if not simulate:
+            self._apply_changes(trans)
+
+    def _open_cache(self, trans, begin=1, end=5, quiet=False, status=None):
+        """Open the APT cache.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        start -- the begin of the progress range
+        end -- the end of the the progress range
+        quiet -- if True do no report any progress
+        status -- an alternative dpkg status file
+        """
+        self.marked_tid = None
+        trans.status = STATUS_LOADING_CACHE
+        if not status:
+            status = self._status_orig
+        apt_pkg.config.set("Dir::State::status", status)
+        apt_pkg.init_system()
+        progress = DaemonOpenProgress(trans, begin=begin, end=end,
+                                      quiet=quiet)
+        try:
+            if not isinstance(self._cache, apt.cache.Cache):
+                self._cache = apt.cache.Cache(progress)
+            else:
+                self._cache.open(progress)
+        except SystemError as excep:
+            raise TransactionFailed(ERROR_NO_CACHE, str(excep))
+
+    def is_dpkg_journal_clean(self):
+        """Return False if there are traces of incomplete dpkg status
+        updates."""
+        status_updates = os.path.join(os.path.dirname(self._status_orig),
+                                      "updates/")
+        for dentry in os.listdir(status_updates):
+            if dentry.isdigit():
+                return False
+        return True
+
+    def _apply_changes(self, trans, fetch_range=(15, 50),
+                        install_range=(50, 90)):
+        """Apply previously marked changes to the system.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        fetch_range -- tuple containing the start and end point of the
+                       download progress
+        install_range -- tuple containing the start and end point of the
+                         install progress
+        """
+        changes = self._cache.get_changes()
+        if not changes:
+            return
+        # Do not allow to remove essential packages
+        for pkg in changes:
+            if pkg.marked_delete and (pkg.essential == True or \
+                                      (pkg.installed and \
+                                       pkg.installed.priority == "required") or\
+                                      pkg.name == "aptdaemon"):
+                raise TransactionFailed(ERROR_NOT_REMOVE_ESSENTIAL_PACKAGE,
+                                        _("Package %s cannot be removed"),
+                                        pkg.name)
+        # Check if any of the cache changes get installed from an
+        # unauthenticated repository""
+        if not trans.allow_unauthenticated and trans.unauthenticated:
+            raise TransactionFailed(ERROR_PACKAGE_UNAUTHENTICATED,
+                                    " ".join(sorted(trans.unauthenticated)))
+        if trans.cancelled:
+            raise TransactionCancelled()
+        trans.cancellable = False
+        fetch_progress = DaemonAcquireProgress(trans, begin=fetch_range[0],
+                                               end=fetch_range[1])
+        inst_progress = DaemonInstallProgress(trans, begin=install_range[0],
+                                              end=install_range[1])
+        with self._frozen_status():
+            try:
+                self._cache.commit(fetch_progress, inst_progress)
+            except apt.cache.FetchFailedException as error:
+                raise TransactionFailed(ERROR_PACKAGE_DOWNLOAD_FAILED,
+                                        str(error))
+            except apt.cache.FetchCancelledException:
+                raise TransactionCancelled()
+            except SystemError as excep:
+                # Run dpkg --configure -a to recover from a failed transaction
+                trans.status = STATUS_CLEANING_UP
+                with DaemonDpkgRecoverProgress(trans, begin=90, end=95) as pro:
+                    pro.run()
+                output = inst_progress.output + pro.output
+                trans.output += output
+                raise TransactionFailed(ERROR_PACKAGE_MANAGER_FAILED,
+                                        "%s: %s" % (excep, trans.output))
+            else:
+                enc = sys.getfilesystemencoding()
+                trans.output += inst_progress.output
+
+    @contextlib.contextmanager
+    def _frozen_status(self):
+        """Freeze the status file to allow simulate operations during
+        a dpkg call."""
+        frozen_dir = tempfile.mkdtemp(prefix="aptdaemon-frozen-status")
+        shutil.copy(self._status_orig, frozen_dir)
+        self._status_frozen = os.path.join(frozen_dir, "status")
+        try:
+            yield
+        finally:
+            shutil.rmtree(frozen_dir)
+            self._status_frozen = None
+
+    def query(self, trans):
+        """Process a PackageKit query transaction."""
+        raise NotImplementedError
+
+    def simulate(self, trans):
+        """Return the dependencies which will be installed by the transaction,
+        the content of the dpkg status file after the transaction would have
+        been applied, the download size and the required disk space.
+
+        Keyword arguments:
+        trans -- the transaction which should be simulated
+        """
+        log.info("Simulating trans: %s" % trans.tid)
+        trans.status = STATUS_RESOLVING_DEP
+        GObject.idle_add(self._simulate, trans)
+
+    def _simulate(self, trans):
+        try:
+            trans.depends, trans.download, trans.space, \
+                    trans.unauthenticated = self.__simulate(trans)
+        except TransactionFailed as excep:
+            trans.error = excep
+            trans.exit = EXIT_FAILED
+        except Exception as excep:
+            tbk = traceback.format_exc()
+            trans.error = TransactionFailed(ERROR_UNKNOWN, tbk)
+            try:
+                from . import crash
+            except ImportError:
+                pass
+            else:
+                crash.create_report("%s: %s" % (type(excep), str(excep)),
+                                    tbk, trans)
+            trans.exit = EXIT_FAILED
+        else:
+            trans.status = STATUS_SETTING_UP
+            trans.simulated = time.time()
+            self.marked_tid = trans.tid
+        finally:
+            self._emit_transaction_simulated(trans)
+            self.last_action_timestamp = time.time()
+        return False
+
+    def __simulate(self, trans):
+        depends = [[], [], [], [], [], [], []]
+        unauthenticated = []
+        skip_pkgs = []
+        size = 0
+        installs = reinstalls = removals = purges = upgrades = upgradables = \
+            downgrades = []
+
+        # Only handle transaction which change packages
+        #FIXME: Add support for ROLE_FIX_INCOMPLETE_INSTALL
+        if trans.role not in [ROLE_INSTALL_PACKAGES, ROLE_UPGRADE_PACKAGES,
+                              ROLE_UPGRADE_SYSTEM, ROLE_REMOVE_PACKAGES,
+                              ROLE_COMMIT_PACKAGES, ROLE_INSTALL_FILE,
+                              ROLE_FIX_BROKEN_DEPENDS]:
+            return depends, 0, 0, []
+
+        # If a transaction is currently running use the former status file
+        if self._status_frozen:
+            status_path = self._status_frozen
+        else:
+            status_path = self._status_orig
+        self._open_cache(trans, quiet=True, status=status_path)
+        if trans.role == ROLE_FIX_BROKEN_DEPENDS:
+            self.fix_broken_depends(trans, simulate=True)
+        elif self._cache.broken_count:
+            raise TransactionFailed(ERROR_CACHE_BROKEN,
+                                    self._get_broken_details(trans))
+        elif trans.role == ROLE_UPGRADE_SYSTEM:
+            for pkg in self._iterate_packages():
+                if pkg.is_upgradable:
+                    upgradables.append(pkg)
+            self.upgrade_system(trans, simulate=True, **trans.kwargs)
+        elif trans.role == ROLE_INSTALL_FILE:
+            deb = self.install_file(trans, simulate=True, **trans.kwargs)
+            skip_pkgs.append(deb.pkgname)
+            try:
+                # Sometimes a thousands comma is used in packages
+                # See LP #656633
+                size = int(deb["Installed-Size"].replace(",", "")) * 1024
+                # Some packages ship really large install sizes e.g.
+                # openvpn access server, see LP #758837
+                if size > sys.maxsize:
+                    raise OverflowError("Size is too large: %s Bytes" % size)
+            except (KeyError, AttributeError, ValueError, OverflowError):
+                if not trans.kwargs["force"]:
+                    msg = trans.gettext("The package doesn't provide a "
+                                        "valid Installed-Size control "
+                                        "field. See Debian Policy 5.6.20.")
+                    raise TransactionFailed(ERROR_INVALID_PACKAGE_FILE, msg)
+            try:
+                pkg = self._cache[deb.pkgname]
+            except KeyError:
+                trans.packages = [[deb.pkgname], [], [], [], [], []]
+            else:
+                if pkg.is_installed:
+                    # if we failed to get the size from the deb file do nor
+                    # try to get the delta
+                    if size != 0:
+                        size -= pkg.installed.installed_size
+                    trans.packages = [[], [deb.pkgname], [], [], [], []]
+                else:
+                    trans.packages = [[deb.pkgname], [], [], [], [], []]
+        else:
+            #FIXME: ugly code to get the names of the packages
+            (installs, reinstalls, removals, purges,
+             upgrades, downgrades) = [[re.split("(=|/)", entry, 1)[0] \
+                                       for entry in lst] \
+                                      for lst in trans.packages]
+            self.commit_packages(trans, *trans.packages, simulate=True)
+
+        changes = self._cache.get_changes()
+        changes_names = []
+        # get the additional dependencies
+        for pkg in changes:
+            self._iterate_mainloop()
+            pkg_str = "%s=%s" % (pkg.name, pkg.candidate.version)
+            if pkg.marked_upgrade and pkg.is_installed and \
+               not pkg.name in upgrades:
+                depends[PKGS_UPGRADE].append(pkg_str)
+            elif pkg.marked_reinstall and not pkg.name in reinstalls:
+                depends[PKGS_REINSTALL].append(pkg_str)
+            elif pkg.marked_downgrade and not pkg.name in downgrades:
+                depends[PKGS_DOWNGRADE].append(pkg_str)
+            elif pkg.marked_install and not pkg.name in installs:
+                depends[PKGS_INSTALL].append(pkg_str)
+            elif pkg.marked_delete and not pkg.name in removals:
+                pkg_str = "%s=%s" % (pkg.name, pkg.installed.version)
+                depends[PKGS_REMOVE].append(pkg_str)
+            #FIXME: add support for purges
+            changes_names.append(pkg.name)
+        # get the unauthenticated packages
+        unauthenticated = self._get_unauthenticated()
+        # Check for skipped upgrades
+        for pkg in upgradables:
+            if pkg.marked_keep:
+                pkg_str = "%s=%s" % (pkg.name, pkg.candidate.version)
+                depends[PKGS_KEEP].append(pkg_str)
+
+        # apt.cache.Cache.required_download requires a clean cache. Under some
+        # strange circumstances it can fail (most likely an interrupted
+        # debconf question), see LP#659438
+        # Running dpkg --configure -a fixes the situation
+        try:
+            required_download = self._cache.required_download
+        except SystemError as error:
+            raise TransactionFailed(ERROR_INCOMPLETE_INSTALL, str(error))
+
+        required_space = size + self._cache.required_space
+
+        return depends, required_download, required_space, unauthenticated
+
+    def _check_deb_file(self, path, force, uid):
+        """Perform some basic checks for the Debian package.
+
+        :param trans: The transaction instance.
+
+        :returns: An apt.debfile.Debfile instance.
+        """
+        #FIXME: Unblock lintian call
+        if not os.path.isfile(path):
+            raise TransactionFailed(ERROR_UNREADABLE_PACKAGE_FILE, path)
+        if not force and os.path.isfile("/usr/bin/lintian"):
+            tags_dir = os.path.join(apt_pkg.config.find_dir("Dir"),
+                                    "usr", "share", "aptdaemon")
+            try:
+                distro = platform.dist()[0]
+            except KeyError:
+                distro = None
+            else:
+                tags_file = os.path.join(tags_dir,
+                                         "lintian-nonfatal.tags.%s" % distro)
+                tags_fatal_file = os.path.join(tags_dir,
+                                               "lintian-fatal.tags.%s" % distro)
+            if not distro or not os.path.exists(tags_file):
+                log.debug("Using default lintian tags file")
+                tags_file = os.path.join(tags_dir, "lintian-nonfatal.tags")
+            if not distro or not os.path.exists(tags_fatal_file):
+                log.debug("Using default lintian fatal tags file")
+                tags_fatal_file = os.path.join(tags_dir, "lintian-fatal.tags")
+            # Run linitan as the user who initiated the transaction
+            # Once with non fatal checks and a second time with the fatal
+            # checks which are not allowed to be overriden
+            nonfatal_args = ["/usr/bin/lintian", "--tags-from-file",
+                             tags_file, path]
+            fatal_args = ["/usr/bin/lintian", "--tags-from-file",
+                          tags_fatal_file, "--no-override", path]
+            for lintian_args in (nonfatal_args, fatal_args):
+                proc = subprocess.Popen(lintian_args,
+                                        stderr=subprocess.STDOUT,
+                                        stdout=subprocess.PIPE, close_fds=True,
+                                        preexec_fn=lambda: os.setuid(uid))
+                while proc.poll() is None:
+                    self._iterate_mainloop()
+                    time.sleep(0.05)
+                #FIXME: Add an error to catch return state 2 (failure)
+                if proc.returncode == 1:
+                    stdout = proc.stdout.read()
+                    stdout.decode(sys.stdin.encoding or "UTF-8",
+                                  errors="replace")
+                    raise TransactionFailed(ERROR_INVALID_PACKAGE_FILE,
+                                            "Lintian check results for %s:"
+                                            "\n%s" % (path, stdout))
+        try:
+            deb = apt.debfile.DebPackage(path, self._cache)
+        except IOError:
+            raise TransactionFailed(ERROR_UNREADABLE_PACKAGE_FILE, path)
+        except Exception as error:
+            raise TransactionFailed(ERROR_INVALID_PACKAGE_FILE, str(error))
+        try:
+            ret = deb.check()
+        except Exception as error:
+            raise TransactionFailed(ERROR_DEP_RESOLUTION_FAILED, str(error))
+        if not ret:
+            raise TransactionFailed(ERROR_DEP_RESOLUTION_FAILED,
+                                    deb._failure_string)
+        return deb
+
+    def clean(self, trans):
+        """Clean the download directories.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        """
+        #FIXME: Use pkgAcquire.Clean(). Currently not part of python-apt.
+        trans.status = STATUS_CLEANING_UP
+        archive_path = apt_pkg.config.find_dir("Dir::Cache::archives")
+        for dir in [archive_path, os.path.join(archive_path, "partial")]:
+            for filename in os.listdir(dir):
+                if filename == "lock":
+                    continue
+                path = os.path.join(dir, filename)
+                if os.path.isfile(path):
+                    log.debug("Removing file %s", path)
+                    os.remove(path)
+
+    def add_license_key(self, trans, pkg_name, json_token, server_name):
+        """Add a license key data to the given package.
+
+        Keyword arguemnts:
+        trans -- the coresponding transaction
+        pkg_name -- the name of the corresponding package
+        json_token -- the oauth token as json
+        server_name -- the server to use (ubuntu-production, ubuntu-staging)
+        """
+        # set transaction state to downloading
+        trans.status = STATUS_DOWNLOADING
+        try:
+            license_key, license_key_path = \
+                    self.plugins["get_license_key"][0](trans.uid, pkg_name,
+                                                       json_token, server_name)
+        except Exception as error:
+            logging.exception("get_license_key plugin failed")
+            raise TransactionFailed(ERROR_LICENSE_KEY_DOWNLOAD_FAILED,
+                                    str(error))
+        # ensure stuff is good
+        if not license_key_path or not license_key:
+            raise TransactionFailed(ERROR_LICENSE_KEY_DOWNLOAD_FAILED,
+                                    _("The license key is empty"))
+
+        # add license key if we have one
+        self._add_license_key_to_system(pkg_name, license_key, license_key_path)
+
+    def _add_license_key_to_system(self, pkg_name, license_key, license_key_path):
+        # fixup path
+        license_key_path = os.path.join(apt_pkg.config.find_dir("Dir"),
+                                        license_key_path.lstrip("/"))
+
+        # Check content of the key
+        if (license_key.strip().startswith("#!") or
+            license_key.startswith("\x7fELF")):
+            raise TransactionFailed(ERROR_LICENSE_KEY_INSTALL_FAILED,
+                                    _("The license key is not allowed to "
+                                      "contain executable code."))
+        # Check the path of the license
+        license_key_path = os.path.normpath(license_key_path)
+        license_key_path_rootdir = os.path.join(apt_pkg.config["Dir"],
+                                           self.LICENSE_KEY_ROOTDIR.lstrip("/"),
+                                           pkg_name)
+        if not license_key_path.startswith(license_key_path_rootdir):
+            raise TransactionFailed(ERROR_LICENSE_KEY_INSTALL_FAILED,
+                                    _("The license key path %s is invalid"),
+                                    license_key_path)
+        if os.path.lexists(license_key_path):
+            raise TransactionFailed(ERROR_LICENSE_KEY_INSTALL_FAILED,
+                                   _("The license key already exists: %s"),
+                                   license_key_path)
+        # Symlink attacks!
+        if os.path.realpath(license_key_path) != license_key_path:
+            raise TransactionFailed(ERROR_LICENSE_KEY_INSTALL_FAILED,
+                                   _("The location of the license key is "
+                                     "unsecure since it contains symbolic "
+                                     "links. The path %s maps to %s"),
+                                     license_key_path,
+                                     os.path.realpath(license_key_path))
+        # Check if the directory already exists
+        if not os.path.isdir(os.path.dirname(license_key_path)):
+            raise TransactionFailed(ERROR_LICENSE_KEY_INSTALL_FAILED,
+                                   _("The directory where to install the key "
+                                     "to doesn't exist yet: %s"),
+                                   license_key_path)
+        # write it
+        log.info("Writing license key to '%s'" % license_key_path)
+        old_umask = os.umask(18)
+        try:
+            with open(license_key_path, "w") as license_file:
+                license_file.write(license_key)
+        except IOError:
+            raise TransactionFailed(ERROR_LICENSE_KEY_INSTALL_FAILED,
+                                    _("Failed to write key file to: %s"),
+                                    license_key_path)
+        finally:
+            os.umask(old_umask)
+
+    def _iterate_mainloop(self):
+        """Process pending actions on the main loop."""
+        while GObject.main_context_default().pending():
+            GObject.main_context_default().iteration()
+
+    def _iterate_packages(self, interval=1000):
+        """Itarte von the packages of the cache and iterate on the
+        GObject main loop time for more responsiveness.
+
+        Keyword arguments:
+        interval - the number of packages after which we iterate on the
+            mainloop
+        """
+        for enum, pkg in enumerate(self._cache):
+            if not enum % interval:
+                self._iterate_mainloop()
+            yield pkg
+ 
+    def _get_broken_details(self, trans, now=True):
+        """Return a message which provides debugging information about
+        broken packages.
+
+        This method is basically a Python implementation of apt-get.cc's
+        ShowBroken.
+
+        Keyword arguments:
+        trans -- the corresponding transaction
+        now -- if we check currently broken dependecies or the installation
+               candidate
+        """
+        msg = trans.gettext("The following packages have unmet dependencies:")
+        msg += "\n\n"
+        for pkg in self._cache:
+            if not ((now and pkg.is_now_broken) or
+                    (not now and pkg.is_inst_broken)):
+                continue
+            msg += "%s: " % pkg.name
+            if now:
+                version = pkg.installed
+            else:
+                version = pkg.candidate
+            indent = " " * (len(pkg.name) + 2)
+            dep_msg = ""
+            for dep in version.dependencies:
+                or_msg = ""
+                for base_dep in dep.or_dependencies:
+                    if or_msg:
+                        or_msg += "or\n"
+                        or_msg += indent
+                    # Check if it's an important dependency
+                    # See apt-pkg/depcache.cc IsImportantDep
+                    # See apt-pkg/pkgcache.cc IsCritical()
+                    # FIXME: Add APT::Install-Recommends-Sections
+                    if not (base_dep.rawtype in ["Depends", "PreDepends",
+                                                 "Obsoletes", "DpkgBreaks",
+                                                 "Conflicts"] or
+                           (apt_pkg.config.find_b("APT::Install-Recommends",
+                                                  False) and
+                            base_dep.rawtype == "Recommends") or
+                           (apt_pkg.config.find_b("APT::Install-Suggests",
+                                                  False) and
+                            base_dep.rawtype == "Suggests")):
+                        continue
+                    # Get the version of the target package
+                    try:
+                        pkg_dep = self._cache[base_dep.name]
+                    except KeyError:
+                        dep_version = None
+                    else:
+                        if now:
+                            dep_version = pkg_dep.installed
+                        else:
+                            dep_version = pkg_dep.candidate
+                    # We only want to display dependencies which cannot
+                    # be satisfied
+                    if dep_version and not apt_pkg.check_dep(base_dep.version,
+                                                             base_dep.relation,
+                                                             version.version):
+                        break
+                    or_msg = "%s: %s " % (base_dep.rawtype, base_dep.name)
+                    if base_dep.version:
+                        or_msg += "(%s %s) " % (base_dep.relation,
+                                                base_dep.version)
+                    if self._cache.is_virtual_package(base_dep.name):
+                        or_msg += trans.gettext("but it is a virtual package")
+                    elif not dep_version:
+                        if now:
+                            or_msg += trans.gettext("but it is not installed")
+                        else:
+                            or_msg += trans.gettext("but it is not going to "
+                                                    "be installed")
+                    elif now:
+                        #TRANSLATORS: %s is a version number
+                        or_msg += trans.gettext("but %s is installed") % \
+                                  dep_version.version
+                    else:
+                        #TRANSLATORS: %s is a version number
+                        or_msg += trans.gettext("but %s is to be installed") % \
+                                  dep_version.version
+                else:
+                    # Only append an or-group if at least one of the
+                    # dependencies cannot be satisfied
+                    if dep_msg:
+                        dep_msg += indent
+                    dep_msg += or_msg
+                    dep_msg += "\n"
+            msg += dep_msg 
+        return msg
+
+    def is_reboot_required(self):
+        """If a reboot is required to get all changes into effect."""
+        return os.path.exists(os.path.join(apt_pkg.config.find_dir("Dir"),
+                                           "var/run/reboot-required"))
+
+
+class DummyWorker(AptWorker):
+
+    """Allows to test the daemon without making any changes to the system."""
+
+    def run(self, transaction):
+        """Process the given transaction in the background.
+
+        Keyword argument:
+        transaction -- core.Transcation instance to run
+        """
+        log.info("Processing transaction %s", transaction.tid)
+        if self.trans:
+            raise Exception("There is already a running transaction")
+        self.trans = transaction
+        self.last_action_timestamp = time.time()
+        self.trans.status = STATUS_RUNNING
+        self.trans.progress = 0
+        self.trans.cancellable = True
+        GObject.timeout_add(200, self._process_transaction, transaction)
+
+    def _process_transaction(self, trans):
+        """Run the worker"""
+        if trans.cancelled:
+            trans.exit = EXIT_CANCELLED
+        elif trans.progress == 100:
+            trans.exit = EXIT_SUCCESS
+        elif trans.role == ROLE_UPDATE_CACHE:
+            trans.exit = EXIT_FAILED
+        elif trans.role == ROLE_UPGRADE_PACKAGES:
+            trans.exit = EXIT_SUCCESS
+        elif trans.role == ROLE_UPGRADE_SYSTEM:
+            trans.exit = EXIT_CANCELLED
+        else:
+            if trans.role == ROLE_INSTALL_PACKAGES:
+                if trans.progress == 1:
+                    trans.status = STATUS_RESOLVING_DEP
+                elif trans.progress == 5:
+                    trans.status = STATUS_DOWNLOADING
+                elif trans.progress == 50:
+                    trans.status = STATUS_COMMITTING
+                    trans.status_details = "Heyas!"
+                elif trans.progress == 55:
+                    trans.paused = True
+                    trans.status = STATUS_WAITING_CONFIG_FILE_PROMPT
+                    trans.config_file_conflict = "/etc/fstab", "/etc/mtab"
+                    while trans.paused:
+                        GObject.main_context_default().iteration()
+                    trans.config_file_conflict_resolution = None
+                    trans.config_file_conflict = None
+                    trans.status = STATUS_COMMITTING
+                elif trans.progress == 60:
+                    trans.required_medium = ("Debian Lenny 5.0 CD 1",
+                                             "USB CD-ROM")
+                    trans.paused = True
+                    trans.status = STATUS_WAITING_MEDIUM
+                    while trans.paused:
+                        GObject.main_context_default().iteration()
+                    trans.status = STATUS_DOWNLOADING
+                elif trans.progress == 70:
+                    trans.status_details = "Servus!"
+                elif trans.progress == 90:
+                    trans.status_deatils = ""
+                    trans.status = STATUS_CLEANING_UP
+            elif trans.role == ROLE_REMOVE_PACKAGES:
+                if trans.progress == 1:
+                    trans.status = STATUS_RESOLVING_DEP
+                elif trans.progress == 5:
+                    trans.status = STATUS_COMMITTING
+                    trans.status_details = "Heyas!"
+                elif trans.progress == 50:
+                    trans.status_details = "Hola!"
+                elif trans.progress == 70:
+                    trans.status_details = "Servus!"
+                elif trans.progress == 90:
+                    trans.status_deatils = ""
+                    trans.status = STATUS_CLEANING_UP
+            trans.progress += 1
+            return True
+        trans.status = STATUS_FINISHED
+        self.last_action_timestamp = time.time()
+        tid = self.trans.tid[:]
+        trans = self.trans
+        self.trans = None
+        self._emit_transaction_done(trans)
+        log.info("Finished transaction %s", tid)
+        return False
+
+    def simulate(self, trans):
+        depends = [[], [], [], [], [], [], []]
+        return depends, 0, 0, []
+
+
+# vim:ts=4:sw=4:et

=== modified file 'NEWS'
--- NEWS	2011-12-15 10:15:46 +0000
+++ NEWS	2012-06-13 16:29:18 +0000
@@ -1,4 +1,20 @@
-CHANGES (0.4x):
+CHANGES (0.5x):
+
+ * Enhancements:
+
+   - Python3 support
+
+   - Make use of apt.auth instead of softwareproperties.AptAuth
+
+   - Support more PackageKit transactions (InstallSignature, RepoEnable)
+
+ * API changes:
+
+   - aptdaemon.test.TestCase has now a start_keyserver() method to fake
+     a GnuPG key server
+
+
+CHANGES (0.45):
 
  * Enhancements:
 
@@ -9,6 +25,8 @@
    - Freeze (copy) the dpkg status file during a dpkg call to allow
      simulating other transactions with the frozen dpkg status
 
+   - Share WhatProvides plugins with the Python APT PackageKit backend
+
    - Allow to install global license keys, see below
 
    - Add compatibilty for py-gobject 3.0 to the client module by switching
@@ -35,6 +53,10 @@
 
  * API changes:
 
+   - what-provides plugin: Share this plugin with the Python APT backend
+     of PackageKit to allow other packages to specify providers for
+     mod aliases, GStreamer codecs or language support
+
    - get-license-key plugin: Add this new plugin which gets the uid,
      the package name, a json oauth token identifieng the customer
      and a server name to retrieve a license key and the path to store it to
@@ -57,7 +79,9 @@
    - org.freedesktop.PackageKit.transaction D-Bus interface: Initial
      implementaion
 
-   - aptdaemon.client: New AptClient.add_license_key method
+   - aptdaemon.client:
+      o New AptClient.add_license_key method
+      o Rename Transaction.disconnect() to Transaction._disconnect_from_dbus()
 
    - aptdaemon.enums:
       o Add enums for package states (e.g. PKG_INSTALLING or
@@ -106,6 +130,11 @@
    - Use apt_pkg.version_compare to detect already upt-to-date packages
      instead of simple string comparison
    - Fix --downgrade option of aptdcon
+   - Fix not supported errors in pkcompat
+   - Fix cancelling transactions
+   - Sync all properties of a transaction in the client before emitting
+     the finished signal (LP#747172)
+   - Fixes to piping the terminal (LP #733090)
 
 
 CHANGES (0.43)

=== modified file 'README.PackageKit'
--- README.PackageKit	2012-03-09 09:02:40 +0000
+++ README.PackageKit	2012-06-13 16:29:18 +0000
@@ -50,20 +50,19 @@
  - GetUpdateDetail
  - GetDistroUpgrades
  - UpgradeSystem
+ - WhatProvides (no builtin handling, only plugins)
+ - RepoEnable: (only enabling, not disabling)
+ - InstallSignature
 
 Not yet supported roles:
 
  - GetCategories: Curently groups are still used, would be nice to reuse the
        categories from software-center
  - GetRepoList: not implemented in the worker
- - RepoEnable: not implemented in the worker)
- - RepoSetData: not implemented in the worker)
+ - RepoSetData: not implemented in the worker
  - InstallFiles: not implemented in the worker
  - SimulateInstallFiles: not implemented in the worker
- - WhatProvides: not implemented in the worker. We could reuse code from
        sessioninstaller.
- - InstallSignature: not implemented in the worker. Could be mapped to
-       AddVendorKeyFromFile.
 
 Roles we won't support at all because of missing infrastructure in APT:
 

=== modified file 'README.tests'
--- README.tests	2010-07-12 09:46:15 +0000
+++ README.tests	2012-06-13 16:29:18 +0000
@@ -1,3 +1,4 @@
-Tests are supported via nosetests from the python-nose package.
+Tests are supported via nosetests3 from the python3-nose package.
 
-Run them via nosetests.
+To run the tests you can either use the "python3 setup.py test" or
+the "nosetests3" command.

=== modified file 'aptd'
--- aptd	2009-06-30 15:06:36 +0000
+++ aptd	2012-06-13 16:29:18 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 """
 aptd - apt daemon

=== modified file 'aptdaemon/client.py'
--- aptdaemon/client.py	2012-04-09 20:48:44 +0000
+++ aptdaemon/client.py	2012-06-13 16:29:18 +0000
@@ -67,12 +67,16 @@
             return value
 
 
-class MemoizedMixIn(MemoizedTransaction, GObject.GObjectMeta):
+class MemoizedMixInMeta(MemoizedTransaction, GObject.GObjectMeta):
 
     """Helper meta class for merging"""
 
-
-class AptTransaction(GObject.GObject):
+# This code is used to make meta classes work with Python 2 and 3 at the same
+# time, see http://mikewatkins.ca/2008/11/29/python-2-and-3-metaclasses/
+MemoizedMixIn = MemoizedMixInMeta("MemoizedMixIn", (GObject.GObject,), {})
+
+
+class AptTransaction(MemoizedMixIn):
 
     """Represents an aptdaemon transaction.
 
@@ -410,7 +414,6 @@
         dependencies before the transaction will be executed.
     """
 
-    __metaclass__ = MemoizedMixIn
 
     __gsignals__ = {"finished": (GObject.SIGNAL_RUN_FIRST,
                                  GObject.TYPE_NONE,
@@ -426,10 +429,10 @@
                                               GObject.TYPE_PYOBJECT)),
                     "download-changed": (GObject.SIGNAL_RUN_FIRST,
                                          GObject.TYPE_NONE,
-                                         (GObject.TYPE_INT,)),
+                                         (GObject.TYPE_INT64,)),
                     "space-changed": (GObject.SIGNAL_RUN_FIRST,
                                       GObject.TYPE_NONE,
-                                      (GObject.TYPE_INT,)),
+                                      (GObject.TYPE_INT64,)),
                     "error": (GObject.SIGNAL_RUN_FIRST,
                               GObject.TYPE_NONE,
                               (GObject.TYPE_STRING, GObject.TYPE_STRING)),
@@ -457,15 +460,17 @@
                     "progress-details-changed": (GObject.SIGNAL_RUN_FIRST,
                                          GObject.TYPE_NONE,
                                          (GObject.TYPE_INT, GObject.TYPE_INT,
-                                          GObject.TYPE_INT, GObject.TYPE_INT,
-                                          GObject.TYPE_INT, GObject.TYPE_INT)),
+                                          GObject.TYPE_INT64,
+                                          GObject.TYPE_INT64,
+                                          GObject.TYPE_INT,
+                                          GObject.TYPE_INT64)),
                     "progress-download-changed": (GObject.SIGNAL_RUN_FIRST,
                                          GObject.TYPE_NONE,
                                          (GObject.TYPE_STRING,
                                           GObject.TYPE_STRING,
                                           GObject.TYPE_STRING,
-                                          GObject.TYPE_INT,
-                                          GObject.TYPE_INT,
+                                          GObject.TYPE_INT64,
+                                          GObject.TYPE_INT64,
                                           GObject.TYPE_STRING)),
                     "packages-changed": (GObject.SIGNAL_RUN_FIRST,
                                          GObject.TYPE_NONE,
@@ -554,8 +559,7 @@
         # main signals
         self._signal_matcher = \
             self._iface.connect_to_signal("PropertyChanged",
-                                          self._on_property_changed,
-                                          utf8_strings=True)
+                                          self._on_property_changed)
 
     def _on_name_owner_changed(self, connection):
         """Fail the transaction if the daemon died."""
@@ -681,7 +685,7 @@
         :raises: dbus.DBusException
         """
         def sync_properties(prop_dict):
-            for property_name, value in prop_dict.iteritems():
+            for property_name, value in prop_dict.items():
                 self._on_property_changed(property_name, value)
             if reply_handler:
                 reply_handler(self)

=== modified file 'aptdaemon/config.py'
--- aptdaemon/config.py	2012-02-03 06:37:42 +0000
+++ aptdaemon/config.py	2012-06-13 16:29:18 +0000
@@ -228,7 +228,7 @@
     for filename in sorted(os.listdir("/etc/apt/apt.conf.d/")):
         lines = open("/etc/apt/apt.conf.d/%s" % filename).readlines()
         cw.parse(lines)
-    print(cw.set_value("huhu::abc", "lumpi", "10glatzor"))
+    print((cw.set_value("huhu::abc", "lumpi", "10glatzor")))
 
 if __name__ == "__main__":
     main()

=== modified file 'aptdaemon/console.py'
--- aptdaemon/console.py	2012-04-09 20:48:44 +0000
+++ aptdaemon/console.py	2012-06-13 16:29:18 +0000
@@ -53,6 +53,8 @@
 ANSI_BOLD = chr(27) + "[1m"
 ANSI_RESET = chr(27) + "[0m"
 
+PY3K = sys.version_info.major > 2
+
 
 class ConsoleClient:
     """
@@ -442,70 +444,73 @@
         kepts = dep_kepts
         if installs:
             #TRANSLATORS: %s is the number of packages
-            print(ngettext("The following NEW package will be installed "
+            print((ngettext("The following NEW package will be installed "
                            "(%(count)s):",
                            "The following NEW packages will be installed "
                            "(%(count)s):",
-                           len(installs)) % {"count": len(installs)})
+                           len(installs)) % {"count": len(installs)}))
             show_packages(installs)
         if upgrades:
             #TRANSLATORS: %s is the number of packages
-            print(ngettext("The following package will be upgraded "
+            print((ngettext("The following package will be upgraded "
                            "(%(count)s):",
                            "The following packages will be upgraded "
                            "(%(count)s):",
-                           len(upgrades)) % {"count": len(upgrades)})
+                           len(upgrades)) % {"count": len(upgrades)}))
             show_packages(upgrades)
         if removals:
             #TRANSLATORS: %s is the number of packages
-            print(ngettext("The following package will be REMOVED "
+            print((ngettext("The following package will be REMOVED "
                            "(%(count)s):",
                            "The following packages will be REMOVED "
                            "(%(count)s):",
-                           len(removals)) % {"count": len(removals)})
+                           len(removals)) % {"count": len(removals)}))
             #FIXME: mark purges
             show_packages(removals)
         if downgrades:
             #TRANSLATORS: %s is the number of packages
-            print(ngettext("The following package will be DOWNGRADED "
+            print((ngettext("The following package will be DOWNGRADED "
                            "(%(count)s):",
                            "The following packages will be DOWNGRADED "
                            "(%(count)s):",
-                           len(downgrades)) % {"count": len(downgrades)})
+                           len(downgrades)) % {"count": len(downgrades)}))
             show_packages(downgrades)
         if reinstalls:
             #TRANSLATORS: %s is the number of packages
-            print(ngettext("The following package will be reinstalled "
+            print((ngettext("The following package will be reinstalled "
                            "(%(count)s):",
                            "The following packages will be reinstalled "
                            "(%(count)s):",
-                           len(reinstalls)) % {"count": len(reinstalls)})
+                           len(reinstalls)) % {"count": len(reinstalls)}))
             show_packages(reinstalls)
         if kepts:
-            print(ngettext("The following package has been kept back "
+            print((ngettext("The following package has been kept back "
                            "(%(count)s):",
                            "The following packages have been kept back "
                            "(%(count)s):",
-                           len(kepts)) % {"count": len(kepts)})
+                           len(kepts)) % {"count": len(kepts)}))
             show_packages(kepts)
 
         if self._transaction.download:
-            print(_("Need to get %sB of archives.") % \
-                    apt_pkg.size_to_str(self._transaction.download))
+            print((_("Need to get %sB of archives.") % \
+                    apt_pkg.size_to_str(self._transaction.download)))
         if self._transaction.space > 0:
-            print(_("After this operation, %sB of additional disk space "
+            print((_("After this operation, %sB of additional disk space "
                     "will be used.") % \
-                            apt_pkg.size_to_str(self._transaction.space))
+                            apt_pkg.size_to_str(self._transaction.space)))
         elif self._transaction.space < 0:
-            print(_("After this operation, %sB of additional disk space "
+            print((_("After this operation, %sB of additional disk space "
                     "will be freed.") % \
-                            apt_pkg.size_to_str(self._transaction.space))
+                            apt_pkg.size_to_str(self._transaction.space)))
         if (not apt_pkg.config.find_b("APT::Get::Assume-Yes") and
             (self._transaction.space or self._transaction.download or
              installs or upgrades or downgrades or removals or kepts or
              reinstalls)):
             try:
-                cont = raw_input(_("Do you want to continue [Y/n]?"))
+                if PY3K:
+                    cont = input(_("Do you want to continue [Y/n]?"))
+                else:
+                    cont = raw_input(_("Do you want to continue [Y/n]?"))
             except EOFError:
                 cont = "n"
             #FIXME: Listen to changed dependencies!
@@ -532,100 +537,100 @@
 
     epilog = _("To operate on more than one package put the package "
                "names in quotation marks:\naptdcon --install "
-               "\"foo bar\"").decode(enc)
+               "\"foo bar\"")
     parser = OptionParser(version=aptdaemon.__version__, epilog=epilog)
     parser.add_option("-c", "--refresh", default="",
                       action="store_true", dest="refresh",
-                      help=_("Refresh the cache").decode(enc))
+                      help=_("Refresh the cache"))
     parser.add_option("", "--fix-depends", default="",
                       action="store_true", dest="fix_depends",
                       help=_("Try to resolve broken dependencies. "
                              "Potentially dangerous operation since it could "
-                             "try to remove many packages.").decode(enc))
+                             "try to remove many packages."))
     parser.add_option("", "--fix-install", default="",
                       action="store_true", dest="fix_install",
                       help=_("Try to finish a previous incompleted "
-                             "installation").decode(enc))
+                             "installation"))
     parser.add_option("-i", "--install", default="",
                       action="store", type="string", dest="install",
-                      help=_("Install the given packages").decode(enc))
+                      help=_("Install the given packages"))
     parser.add_option("", "--reinstall", default="",
                       action="store", type="string", dest="reinstall",
-                      help=_("Reinstall the given packages").decode(enc))
+                      help=_("Reinstall the given packages"))
     parser.add_option("-r", "--remove", default="",
                       action="store", type="string", dest="remove",
-                      help=_("Remove the given packages").decode(enc))
+                      help=_("Remove the given packages"))
     parser.add_option("-p", "--purge", default="",
                       action="store", type="string", dest="purge",
                       help=_("Remove the given packages including "
-                             "configuration files").decode(enc))
+                             "configuration files"))
     parser.add_option("-u", "--upgrade", default="",
                       action="store", type="string", dest="upgrade",
-                      help=_("Install the given packages").decode(enc))
+                      help=_("Install the given packages"))
     parser.add_option("", "--downgrade", default="",
                       action="store", type="string", dest="downgrade",
-                      help=_("Downgrade the given packages").decode(enc))
+                      help=_("Downgrade the given packages"))
     parser.add_option("", "--upgrade-system",
                       action="store_true", dest="safe_upgrade",
                       help=_("Deprecated: Please use "
-                             "--safe-upgrade").decode(enc))
+                             "--safe-upgrade"))
     parser.add_option("", "--safe-upgrade",
                       action="store_true", dest="safe_upgrade",
-                      help=_("Upgrade the system in a safe way").decode(enc))
+                      help=_("Upgrade the system in a safe way"))
     parser.add_option("", "--full-upgrade",
                       action="store_true", dest="full_upgrade",
                       help=_("Upgrade the system, possibly installing and "
-                             "removing packages").decode(enc))
+                             "removing packages"))
     parser.add_option("", "--add-vendor-key", default="",
                       action="store", type="string", dest="add_vendor_key",
-                      help=_("Add the vendor to the trusted ones").decode(enc))
+                      help=_("Add the vendor to the trusted ones"))
     parser.add_option("", "--add-vendor-key-from-keyserver", default="",
                       action="store", type="string", 
                       help=_("Add the vendor keyid (also needs "
-                             "--keyserver)").decode(enc))
+                             "--keyserver)"))
     parser.add_option("", "--keyserver", default="",
                       action="store", type="string", 
                       help=_("Use the given keyserver for looking up "
-                             "keys").decode(enc))
+                             "keys"))
     parser.add_option("", "--add-repository", default="", 
                       action="store", type="string", dest="add_repository",
                       help=_("Add new repository from the given "
-                             "deb-line").decode(enc))
+                             "deb-line"))
     parser.add_option("", "--sources-file", action="store", default="",
                       type="string", dest="sources_file",
                       help=_("Specify an alternative sources.list.d file to "
-                             "which repositories should be added.").decode(enc))
+                             "which repositories should be added."))
     parser.add_option("", "--list-trusted-vendors", default="",
                       action="store_true", dest="list_trusted_vendor_keys",
-                      help=_("List trusted vendor keys").decode(enc))
+                      help=_("List trusted vendor keys"))
     parser.add_option("", "--remove-vendor-key", default="",
                       action="store", type="string", dest="remove_vendor_key",
                       help=_("Remove the trusted key of the given "
-                             "fingerprint").decode(enc))
+                             "fingerprint"))
     parser.add_option("", "--clean",
                       action="store_true", dest="clean",
-                      help=_("Remove downloaded package files").decode(enc))
+                      help=_("Remove downloaded package files"))
     parser.add_option("", "--reconfigure", default="",
                       action="store", type="string", dest="reconfigure",
                       help=_("Reconfigure installed packages. Optionally the "
                              "minimum priority of questions can be "
-                             "specified").decode(enc))
+                             "specified"))
     parser.add_option("", "--priority", default="default",
                       action="store", type="string", dest="priority",
                       help=_("The minimum debconf priority of question to "
-                             "be displayed").decode(enc))
+                             "be displayed"))
     parser.add_option("", "--hide-terminal",
                       action="store_true", dest="hide_terminal",
-                      help=_("Do not attach to the apt terminal").decode(enc))
+                      help=_("Do not attach to the apt terminal"))
     parser.add_option("", "--allow-unauthenticated",
                       action="store_true", dest="allow_unauthenticated",
                       default=False,
                       help=_("Allow packages from unauthenticated "
-                             "sources").decode(enc))
+                             "sources"))
     parser.add_option("-d", "--show-details",
                       action="store_true", dest="details",
                       help=_("Show additional information about the packages. "
-                             "Currently only the version number").decode(enc))
+                             "Currently only the version number"))
     (options, args) = parser.parse_args()
     con = ConsoleClient(show_terminal=not options.hide_terminal,
                            allow_unauthenticated=options.allow_unauthenticated,

=== modified file 'aptdaemon/core.py'
--- aptdaemon/core.py	2012-04-09 20:48:44 +0000
+++ aptdaemon/core.py	2012-06-13 16:29:18 +0000
@@ -54,8 +54,8 @@
 import dbus.service
 import dbus.mainloop.glib
 import dbus.glib
-from softwareproperties.AptAuth import AptAuth
 import apt_pkg
+import apt.auth
 
 from .config import ConfigWriter
 from . import errors
@@ -198,7 +198,7 @@
         xml = ElementTree.fromstring(data)
         for iface in xml.findall("interface"):
             props = self._get_properties(iface.attrib["name"])
-            for key, value in props.iteritems():
+            for key, value in props.items():
                 attrib = {"name": key}
                 if key in self.WRITABLE_PROPERTIES:
                     attrib["access"] = "readwrite"
@@ -346,7 +346,7 @@
         bus -- the DBus connection which should be used (defaults to system bus)
         """
         if tid is None:
-            tid = uuid.uuid4().get_hex()
+            tid = uuid.uuid4().hex
         self.tid = "/org/debian/apt/transaction/%s" % tid
         if connect == True:
             self.bus = bus
@@ -380,9 +380,9 @@
         self._role = dbus.String(role)
         self._progress = dbus.Int32(0)
         # items_done, total_items, bytes_done, total_bytes, speed, time
-        self._progress_details = dbus.Struct((0, 0, 0L, 0L, 0.0, 0L),
+        self._progress_details = dbus.Struct((0, 0, 0, 0, 0.0, 0),
                                              signature="iixxdx")
-        self._progress_download = dbus.Struct(("", "", "", 0L, 0L, ""),
+        self._progress_download = dbus.Struct(("", "", "", 0, 0, ""),
                                               signature="sssxxs")
         self._progress_package = dbus.Struct(("", ""), signature="ss")
         self._exit = dbus.String(enums.EXIT_UNFINISHED)
@@ -485,7 +485,7 @@
         if not data.signature.startswith("s"):
             raise errors.InvalidMetaDataError("Only strings are accepted "
                                               "as keys.")
-        for key, value in data.iteritems():
+        for key, value in data.items():
             if key in self._meta_data:
                 raise errors.InvalidMetaDataError("The key %s already "
                                                   "exists. It is not allowed "
@@ -1471,7 +1471,7 @@
         """Helper method which returns the tid of a new transaction."""
         pid, uid, cmdline = \
                 yield policykit1.get_proc_info_from_dbus_name(sender, self.bus)
-        tid = uuid.uuid4().get_hex()
+        tid = uuid.uuid4().hex
         trans = Transaction(tid, role, self.queue, pid, uid, cmdline, sender,
                             packages=packages, kwargs=kwargs, bus=self.bus)
         self.queue.limbo[trans.tid] = trans
@@ -1926,11 +1926,11 @@
 
     @inline_callbacks
     def _get_trusted_vendor_keys(self, sender):
-        aptauth = AptAuth()
         action = policykit1.PK_ACTION_GET_TRUSTED_VENDOR_KEYS
         yield policykit1.check_authorization_by_name(sender, action,
                                                      bus=self.bus)
-        return_value([key.decode("utf-8", "ignore") for key in aptauth.list()])
+        fingerprints = [key.keyid for key in apt.auth.list_keys()]
+        return_value(fingerprints)
 
     # pylint: disable-msg=C0103,C0322
     @dbus.service.method(APTDAEMON_DBUS_INTERFACE,
@@ -2144,40 +2144,40 @@
                       default=False,
                       action="store_true", dest="disable_timeout",
                       help=_("Do not shutdown the daemon because of "
-                             "inactivity").decode(enc))
+                             "inactivity"))
     parser.add_option("", "--disable-plugins",
                       default=False,
                       action="store_true", dest="disable_plugins",
-                      help=_("Do not load any plugins").decode(enc))
+                      help=_("Do not load any plugins"))
     parser.add_option("-d", "--debug",
                       default=False,
                       action="store_true", dest="debug",
                       help=_("Show internal processing "
-                             "information").decode(enc))
+                             "information"))
     parser.add_option("-r", "--replace",
                       default=False,
                       action="store_true", dest="replace",
                       help=_("Quit and replace an already running "
-                             "daemon").decode(enc))
+                             "daemon"))
     parser.add_option("", "--session-bus",
                       default=False,
                       action="store_true", dest="session_bus",
                       help=_("Listen on the DBus session bus (Only required "
-                             "for testing").decode(enc))
+                             "for testing"))
     parser.add_option("", "--chroot", default=None,
                       action="store", type="string", dest="chroot",
                       help=_("Perform operations in the given "
-                             "chroot").decode(enc))
+                             "chroot"))
     parser.add_option("-p", "--profile",
                       default=False,
                       action="store", type="string", dest="profile",
                       help=_("Store profile stats in the specified "
-                             "file").decode(enc))
+                             "file"))
     parser.add_option("--dummy",
                       default=False,
                       action="store_true", dest="dummy",
                       help=_("Do not make any changes to the system (Only "
-                             "of use to developers)").decode(enc))
+                             "of use to developers)"))
     options, args = parser.parse_args()
     if options.debug == True:
         log.setLevel(logging.DEBUG)

=== modified file 'aptdaemon/errors.py'
--- aptdaemon/errors.py	2012-02-03 06:37:42 +0000
+++ aptdaemon/errors.py	2012-06-13 16:29:18 +0000
@@ -28,11 +28,15 @@
            "get_native_exception")
 
 import inspect
+from functools import wraps
+import sys
+
 import dbus
-from functools import wraps
 
 import aptdaemon.enums
 
+PY3K = sys.version_info.major > 2
+
 
 class AptDaemonError(dbus.DBusException):
 
@@ -49,7 +53,10 @@
         """Overwrite the DBusException method, since it calls
         Exception.__str__() internally which doesn't support unicode or
         or non-ascii encodings."""
-        return self._message.encode("UTF-8")
+        if PY3K:
+            return dbus.DBusException.get_dbus_message(self)
+        else:
+            return self._message.encode("UTF-8")
 
 
 class TransactionRoleAlreadySet(AptDaemonError):
@@ -101,7 +108,7 @@
 
     def __str__(self):
         return "Transaction failed: %s\n%s" % \
-               (aptdaemon.enums.get_role_error_from_enum(self.code),
+               (aptdaemon.enums.get_error_string_from_enum(self.code),
                 self.details)
 
 
@@ -192,9 +199,7 @@
     if not isinstance(error, dbus.DBusException):
         return error
     dbus_name = error.get_dbus_name()
-    # We have to use the deprecated message attribute to avoid encoding errors
-    # See LP #846044
-    dbus_msg = error.message
+    dbus_msg = error.get_dbus_message()
     if dbus_name == TransactionFailed._dbus_error_name:
         return TransactionFailed(*dbus_msg.split(":", 1))
     elif dbus_name == AuthorizationFailed._dbus_error_name:
@@ -211,7 +216,9 @@
 
 def _convert_unicode(text, encoding="UTF-8"):
     """Always return an unicode."""
-    if not isinstance(text, unicode):
+    if PY3K and not isinstance(text, str):
+        text = str(text, encoding, errors="ignore")
+    elif not PY3K and not isinstance(text, unicode):
         text = unicode(text, encoding, errors="ignore")
     return text
 

=== modified file 'aptdaemon/gtk3widgets.py'
--- aptdaemon/gtk3widgets.py	2012-03-14 13:26:31 +0000
+++ aptdaemon/gtk3widgets.py	2012-06-13 16:29:18 +0000
@@ -51,7 +51,7 @@
 _ = lambda msg: gettext.dgettext("aptdaemon", msg)
 
 (COLUMN_ID,
- COLUMN_PACKAGE) = range(2)
+ COLUMN_PACKAGE) = list(range(2))
 
 
 class AptStatusIcon(Gtk.Image):
@@ -446,7 +446,7 @@
     of a transaction.
     """
 
-    COL_TEXT, COL_PROGRESS, COL_URI = range(3)
+    COL_TEXT, COL_PROGRESS, COL_URI = list(range(3))
 
     def __init__(self, transaction=None):
         Gtk.TreeView.__init__(self)
@@ -484,7 +484,7 @@
                              downloaded, message):
         """Callback for a changed download progress."""
         try:
-            progress = downloaded * 100 / full_size
+            progress = int(downloaded * 100 / full_size)
         except ZeroDivisionError:
             progress = -1
         if status == DOWNLOAD_DONE:

=== modified file 'aptdaemon/gtkwidgets.py'
--- aptdaemon/gtkwidgets.py	2012-02-03 06:37:42 +0000
+++ aptdaemon/gtkwidgets.py	2012-06-13 16:29:18 +0000
@@ -53,7 +53,7 @@
 _ = lambda msg: gettext.dgettext("aptdaemon", msg)
 
 (COLUMN_ID,
- COLUMN_PACKAGE) = range(2)
+ COLUMN_PACKAGE) = list(range(2))
 
 
 class AptStatusIcon(gtk.Image):
@@ -440,7 +440,7 @@
     of a transaction.
     """
 
-    COL_TEXT, COL_PROGRESS, COL_URI = range(3)
+    COL_TEXT, COL_PROGRESS, COL_URI = list(range(3))
 
     def __init__(self, transaction=None):
         gtk.TreeView.__init__(self)

=== modified file 'aptdaemon/lock.py'
--- aptdaemon/lock.py	2012-03-14 13:26:31 +0000
+++ aptdaemon/lock.py	2012-06-13 16:29:18 +0000
@@ -110,7 +110,7 @@
         except IOError:
             return None
         finally:
-            fd_lock_read
+            fd_lock_read.close()
     return None
 
 apt_pkg.init()

=== modified file 'aptdaemon/networking.py'
--- aptdaemon/networking.py	2012-05-11 15:56:04 +0000
+++ aptdaemon/networking.py	2012-06-13 16:29:18 +0000
@@ -33,7 +33,8 @@
 DBusGMainLoop(set_as_default=True)
 import logging
 import os
-import packagekit.enums as pk_enums
+
+from . import pkenums as pk_enums
 
 log = logging.getLogger("AptDaemon.NetMonitor")
 
@@ -259,7 +260,7 @@
     @inline_callbacks
     def _call_monitor():
         state = yield monitor.get_network_state()
-        print("Initial network state: %s" % state)
+        print(("Initial network state: %s" % state))
     log_handler = logging.StreamHandler()
     log.addHandler(log_handler)
     log.setLevel(logging.DEBUG)

=== modified file 'aptdaemon/pkcompat.py'
--- aptdaemon/pkcompat.py	2012-05-11 15:56:04 +0000
+++ aptdaemon/pkcompat.py	2012-06-13 16:29:18 +0000
@@ -37,7 +37,6 @@
 from defer.utils import dbus_deferred_method
 import dbus
 from gi.repository import GObject
-import packagekit.enums as pk_enums
 
 # for optional plugin support
 try:
@@ -45,14 +44,15 @@
 except ImportError:
     pkg_resources = None
 
-from aptdaemon import policykit1
-import aptdaemon.core
-from aptdaemon.core import APTDAEMON_TRANSACTION_DBUS_INTERFACE
-import aptdaemon.enums as aptd_enums
-from aptdaemon.errors import TransactionFailed, TransactionCancelled
-from aptdaemon.progress import DaemonAcquireProgress
-import aptdaemon.worker
-import aptdaemon.networking
+from . import policykit1
+from . import core
+from .core import APTDAEMON_TRANSACTION_DBUS_INTERFACE
+from . import enums as aptd_enums
+from .errors import TransactionFailed, TransactionCancelled
+from .progress import DaemonAcquireProgress
+from . import worker
+from . import networking
+from . import pkenums as pk_enums
 
 GObject.threads_init()
 
@@ -239,7 +239,7 @@
     }
 
 
-class PackageKit(aptdaemon.core.DBusObject):
+class PackageKit(core.DBusObject):
 
     """Provides a limited set of the PackageKit system D-Bus API."""
 
@@ -262,6 +262,8 @@
                        pk_enums.ROLE_SEARCH_GROUP,
                        pk_enums.ROLE_SEARCH_FILE,
                        pk_enums.ROLE_WHAT_PROVIDES,
+                       pk_enums.ROLE_REPO_ENABLE,
+                       pk_enums.ROLE_INSTALL_SIGNATURE,
                        pk_enums.ROLE_DOWNLOAD_PACKAGES]
     if META_RELEASE_SUPPORT:
         SUPPORTED_ROLES.append(pk_enums.ROLE_GET_DISTRO_UPGRADES)
@@ -294,14 +296,14 @@
             self.bus = bus
             bus_path = PACKAGEKIT_DBUS_PATH
             bus_name = dbus.service.BusName(PACKAGEKIT_DBUS_SERVICE, self.bus)
-        aptdaemon.core.DBusObject.__init__(self, bus_name, bus_path)
+        core.DBusObject.__init__(self, bus_name, bus_path)
         self._updates_changed_timeout_id = None
         self._updates_changed = False
         self.queue = queue
         self.queue.worker.connect("transaction-done", self._on_transaction_done)
         self.queue.connect("queue-changed", self._on_queue_changed)
         self._distro_id = None
-        self.netmon = aptdaemon.networking.get_network_monitor()
+        self.netmon = networking.get_network_monitor()
         self.netmon.connect("network-state-changed",
                             self._on_network_state_changed)
         self._get_network_state()
@@ -430,15 +432,15 @@
     def _get_properties(self, iface):
         """Helper to get the properties of a D-Bus interface."""
         if iface == PACKAGEKIT_DBUS_INTERFACE:
-            return {# Claim that we are a stable version
-                    "VersionMajor": dbus.UInt32(6),
-                    "VersionMinor": dbus.UInt32(18),
+            return {# Claim that we are a current version
+                    "VersionMajor": dbus.UInt32(7),
+                    "VersionMinor": dbus.UInt32(4),
                     "VersionMicro": dbus.UInt32(0),
                     "BackendName": dbus.String("aptdaemon"),
                     "BackendDescription": dbus.String("Compatibility layer"),
                     "BackendAuthor": dbus.String(__author__),
                     "Filters": dbus.String(";".join(self.SUPPORTED_FILTERS)),
-                    "Groups": dbus.String(";".join(SECTION_GROUP_MAP.values())),
+                    "Groups": dbus.String(";".join(list(SECTION_GROUP_MAP.values()))),
                     "Roles": dbus.String(";".join(self.SUPPORTED_ROLES)),
                     "Locked": dbus.Boolean(False),
                     "NetworkState": dbus.String(self.netmon.state),
@@ -460,7 +462,7 @@
     def _on_network_state_changed(self, mon, state):
         self.Changed()
         self.PropertiesChanged(PACKAGEKIT_DBUS_INTERFACE,
-                               {"Network": state}, [])
+                               {"NetworkState": state}, [])
 
     def _on_queue_changed(self, queue):
         self.TransactionListChanged(self._get_transaction_list())
@@ -522,7 +524,7 @@
         return False
 
 
-class MergedTransaction(aptdaemon.core.Transaction):
+class MergedTransaction(core.Transaction):
 
     """Overlay of an Aptdaemon transaction which also provides the
     PackageKit object and its interfaces.
@@ -530,7 +532,7 @@
 
     def __init__(self, pktrans, role, queue, connect=True,
                  bus=None, packages=None, kwargs=None):
-        aptdaemon.core.Transaction.__init__(self, pktrans.tid[1:], role, queue,
+        core.Transaction.__init__(self, pktrans.tid[1:], role, queue,
                                             pktrans.pid, pktrans.uid,
                                             pktrans.cmdline, pktrans.sender,
                                             connect, bus, packages, kwargs)
@@ -538,52 +540,52 @@
         self.run_time = 0
 
     def _set_status(self, enum):
-        aptdaemon.core.Transaction._set_status(self, enum)
+        core.Transaction._set_status(self, enum)
         self.pktrans.status = get_pk_status_enum(enum)
 
-    status = property(aptdaemon.core.Transaction._get_status, _set_status)
+    status = property(core.Transaction._get_status, _set_status)
 
     def _set_progress(self, percent):
-        aptdaemon.core.Transaction._set_progress(self, percent)
+        core.Transaction._set_progress(self, percent)
         self.pktrans.percentage = self._progress
 
-    progress = property(aptdaemon.core.Transaction._get_progress, _set_progress)
+    progress = property(core.Transaction._get_progress, _set_progress)
 
     def _set_progress_details(self, details):
-        aptdaemon.core.Transaction._set_progress_details(self, details)
+        core.Transaction._set_progress_details(self, details)
         self.pktrans.speed = int(details[4])
         self.pktrans.remaining_time = int(details[5])
         self.pktrans.elapsed_time = int(time.time() - self.pktrans.start_time)
 
-    progress_details = property(aptdaemon.core.Transaction._get_progress_details,
+    progress_details = property(core.Transaction._get_progress_details,
                                 _set_progress_details)
 
     def _set_progress_package(self, progress):
-        aptdaemon.core.Transaction._set_progress_package(self, progress)
+        core.Transaction._set_progress_package(self, progress)
         pkg_name, enum = progress
         self.emit_package(get_pk_package_enum(enum),
                           get_pk_package_id(pkg_name),
                           "")
 
-    progress_package = property(aptdaemon.core.Transaction._get_progress_package,
+    progress_package = property(core.Transaction._get_progress_package,
                                 _set_progress_package)
 
 
     def _set_exit(self, enum):
-        aptdaemon.core.Transaction._set_exit(self, enum)
+        core.Transaction._set_exit(self, enum)
         self.pktrans.exit = get_pk_exit_enum(enum)
 
-    exit = property(aptdaemon.core.Transaction._get_exit, _set_exit)
+    exit = property(core.Transaction._get_exit, _set_exit)
 
     def _set_error(self, excep):
-        aptdaemon.core.Transaction._set_error(self, excep)
+        core.Transaction._set_error(self, excep)
         self.pktrans.ErrorCode(get_pk_error_enum(excep.code),
                                self._error_property[1])
 
-    error = property(aptdaemon.core.Transaction._get_error, _set_error)
+    error = property(core.Transaction._get_error, _set_error)
 
     def _remove_from_connection_no_raise(self):
-        aptdaemon.core.Transaction._remove_from_connection_no_raise(self)
+        core.Transaction._remove_from_connection_no_raise(self)
         self.pktrans.Destroy()
         try:
             self.pktrans.remove_from_connection()
@@ -613,7 +615,7 @@
                                   changelog, state, issued, updated)
 
 
-class PackageKitTransaction(aptdaemon.core.DBusObject):
+class PackageKitTransaction(core.DBusObject):
 
     """Provides a PackageKit transaction object."""
 
@@ -622,14 +624,14 @@
         pklog.info("Initializing PackageKit transaction")
         bus_name = None
         bus_path = None
-        self.tid = "/%s" % uuid.uuid4().get_hex()
+        self.tid = "/%s" % uuid.uuid4().hex
         if connect == True:
             if bus is None:
                 bus = dbus.SystemBus()
             self.bus = bus
             bus_path = self.tid
             bus_name = dbus.service.BusName(PACKAGEKIT_DBUS_SERVICE, bus)
-        aptdaemon.core.DBusObject.__init__(self, bus_name, bus_path)
+        core.DBusObject.__init__(self, bus_name, bus_path)
         self.queue = queue
         self.hints = {}
         self.start_time = time.time()
@@ -1745,9 +1747,9 @@
         self.role = pk_enums.ROLE_INSTALL_FILES
         GObject.idle_add(self._fail_not_implemented)
 
-    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
-                         in_signature="sss", out_signature="",
-                         sender_keyword="sender")
+    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
+                          in_signature="sss", out_signature="",
+                          sender_keyword="sender")
     def InstallSignature(self, sig_type, key_id, package_id, sender):
         """This method allows us to install new security keys.
 
@@ -1755,9 +1757,13 @@
         :param key_id: A key ID, e.g. BB7576AC
         :param package_id:
             A PackageID for the package that the user is trying to install
+            (ignored)
         """
         self.role = pk_enums.ROLE_INSTALL_SIGNATURE
-        GObject.idle_add(self._fail_not_implemented)
+        kwargs = {"sig_type": sig_type,
+                  "key_id": key_id,
+                  "package_id": package_id}
+        return self._run_query(kwargs, sender)
 
     @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
                          in_signature="sss", out_signature="",
@@ -1776,18 +1782,21 @@
         self.role = pk_enums.ROLE_REPO_SET_DATA
         GObject.idle_add(self._fail_not_implemented)
 
-    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
-                         in_signature="sb", out_signature="",
-                         sender_keyword="sender")
+    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
+                          in_signature="sb", out_signature="",
+                          sender_keyword="sender")
     def RepoEnable(self, repo_id, enabled, sender):
         """This method enables the repository specified.
 
         :param repo_id:
-            A repository identifier, e.g. fedora-development-debuginfo
+            A repository identifier, e.g. fedora-development-debuginfo or an
+            apt source ("deb http://... unstable main")
         :param enabled: true if enabled, false if disabled.
         """
         self.role = pk_enums.ROLE_REPO_ENABLE
-        GObject.idle_add(self._fail_not_implemented)
+        kwargs = {"repo_id": repo_id,
+                  "enabled": enabled}
+        return self._run_query(kwargs, sender)
 
     @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
                          in_signature="s", out_signature="",
@@ -1889,7 +1898,7 @@
     # HELPERS
  
     def _fail_not_implemented(self):
-        self.ErrorCode(pk_enums.ERROR_NOT_SUPPORTED, "")
+        self.ErrorCode(pk_enums.ERROR_NOT_SUPPORTED, "Unimplemented method")
         self.exit = pk_enums.EXIT_FAILED
         return False
 
@@ -1941,7 +1950,7 @@
         return trans
 
 
-class PackageKitWorker(aptdaemon.worker.AptWorker):
+class PackageKitWorker(worker.AptWorker):
 
     _plugins = None
 
@@ -1981,6 +1990,10 @@
             self.download_packages(trans, **trans.kwargs)
         elif trans.pktrans.role == pk_enums.ROLE_WHAT_PROVIDES:
             self.what_provides(trans, **trans.kwargs)
+        elif trans.pktrans.role == pk_enums.ROLE_REPO_ENABLE:
+            self.repo_enable(trans, **trans.kwargs)
+        elif trans.pktrans.role == pk_enums.ROLE_INSTALL_SIGNATURE:
+            self.install_signature(trans, **trans.kwargs)
         else:
             raise TransactionFailed(aptd_enums.ERROR_UNKNOWN,
                                     "Role %s isn't supported",
@@ -2063,7 +2076,7 @@
         pklog.info("Searching for package name: %s" % values)
         trans.progress = 101
 
-        for pkg_name in self._cache.keys():
+        for pkg_name in list(self._cache.keys()):
             if matches(values, pkg_name):
                 self._emit_all_visible_pkg_versions(trans, filters,
                                                     self._cache[pkg_name])
@@ -2082,7 +2095,7 @@
             db = xapian.Database(XAPIAN_DB)
             parser = xapian.QueryParser()
             parser.set_default_op(xapian.Query.OP_AND)
-            query = parser.parse_query(u" ".join(values), search_flags)
+            query = parser.parse_query(" ".join(values), search_flags)
             enquire = xapian.Enquire(db)
             enquire.set_query(query)
             matches = enquire.get_mset(0, 1000)
@@ -2212,8 +2225,7 @@
             """
             Create a list of urls pointing to cves referred in the changelog
             """
-            return map(lambda c: HREF_CVE % c,
-                       re.findall(MATCH_CVE, changelog, re.MULTILINE))
+            return [HREF_CVE % c for c in re.findall(MATCH_CVE, changelog, re.MULTILINE)]
 
         pklog.info("Get update details of %s" % package_ids)
         trans.progress = 0
@@ -2239,7 +2251,7 @@
             obsoletes = ""
             vendor_url = ""
             restart = "none"
-            update_text = u""
+            update_text = ""
             state = ""
             issued = ""
             updated = ""
@@ -2271,7 +2283,7 @@
                 changelog_raw = pkg.get_changelog()
                 # The internal download error string of python-apt ist not
                 # provided as unicode object
-                if not isinstance(changelog_raw, unicode):
+                if not isinstance(changelog_raw, str):
                     changelog_raw = changelog_raw.decode("UTF-8")
                 # Cache the fetched changelog
                 if not os.path.exists(changelog_dir):
@@ -2286,24 +2298,24 @@
                 finally:
                     changelog_file.close()
            # Convert the changelog to markdown syntax
-            changelog = u""
+            changelog = ""
             for line in changelog_raw.split("\n"):
                 if line == "":
                     changelog += " \n"
                 else:
-                    changelog += u"    %s  \n" % line
+                    changelog += "    %s  \n" % line
                 if line.startswith(pkg.candidate.source_name):
                     match = re.match(r"(?P<source>.+) \((?P<version>.*)\) "
                                       "(?P<dist>.+); urgency=(?P<urgency>.+)",
                                      line)
-                    update_text += u"%s\n%s\n\n" % (match.group("version"),
+                    update_text += "%s\n%s\n\n" % (match.group("version"),
                                                     "=" * \
                                                     len(match.group("version")))
                 elif line.startswith("  "):
-                    update_text += u"  %s  \n" % line
+                    update_text += "  %s  \n" % line
                 elif line.startswith(" --"):
                     #FIXME: Add %z for the time zone - requires Python 2.6
-                    update_text += u"  \n"
+                    update_text += "  \n"
                     match = re.match("^ -- (?P<maintainer>.+) (?P<mail><.+>)  "
                                      "(?P<date>.+) (?P<offset>[-\+][0-9]+)$",
                                      line)
@@ -2403,7 +2415,7 @@
                 if not self._is_package_visible(pkg, filters):
                     return
             else:
-                summary = u""
+                summary = ""
             if base_dependency.relation:
                 version = "%s%s" % (base_dependency.relation,
                                     base_dependency.version)
@@ -2557,10 +2569,7 @@
             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.
-        """
+        """Emit all packages which provide the given type and search value."""
         self._init_plugins()
 
         supported_type = False
@@ -2581,6 +2590,34 @@
             raise TransactionFailed(aptd_enums.ERROR_NOT_SUPPORTED,
                                     "Query type '%s' is not supported" % type)
 
+    def repo_enable(self, trans, repo_id, enabled):
+        """Enable or disable a repository."""
+
+        if not enabled:
+            raise TransactionFailed(aptd_enums.ERROR_NOT_SUPPORTED,
+                    "Disabling repositories is not implemented")
+
+        fields = repo_id.split()
+        if len(fields) < 3 or fields[0] not in ('deb', 'deb-src'):
+            raise TransactionFailed(aptd_enums.ERROR_NOT_SUPPORTED,
+                    "Unknown repository ID format: %s" % repo_id)
+
+        self.add_repository(trans, fields[0], fields[1], fields[2],
+                fields[3:], '', None)
+
+    def install_signature(self, trans, sig_type, key_id, package_id):
+        """Install an archive key."""
+        if sig_type != "gpg":
+            raise TransactionFailed(aptd_enums.ERROR_NOT_SUPPORTED,
+                                    "Type %s is not supported" % sig_type)
+        try:
+            keyserver = os.environ["APTDAEMON_KEYSERVER"]
+        except KeyError:
+            if platform.dist()[0] == "Ubuntu":
+                keyserver = "hkp://keyserver.ubuntu.com:80"
+            else:
+                keyserver = "hkp://keys.gnupg.net"
+        self.add_vendor_key_from_keyserver(trans, key_id, keyserver)
 
     # Helpers
 
@@ -2662,7 +2699,7 @@
         for name_raw in pkgs:
             #FIXME: Python-apt doesn't allow unicode as key. See #542965
             name = str(name_raw)
-            if self._cache.has_key(name) and \
+            if name in self._cache and \
                self._is_package_visible(self._cache[name], filters):
                 self._emit_package(trans, self._cache[name], info)
 
@@ -2815,7 +2852,7 @@
         Return the packagekit group corresponding to the package's section
         """
         section = pkg.section.split("/")[-1]
-        if SECTION_GROUP_MAP.has_key(section):
+        if section in SECTION_GROUP_MAP:
             return SECTION_GROUP_MAP[section]
         else:
             pklog.debug("Unkown package section %s of %s" % (pkg.section,
@@ -2855,9 +2892,9 @@
     def _apply_changes(self, trans, fetch_range=(15, 50),
                        install_range=(50, 90)):
         """Apply changes and emit RequireRestart accordingly."""
-        aptdaemon.worker.AptWorker._apply_changes(self, trans,
-                                                  fetch_range,
-                                                  install_range)
+        worker.AptWorker._apply_changes(self, trans,
+                                        fetch_range,
+                                        install_range)
         if (hasattr(trans, "pktrans") and
             (trans.role == aptd_enums.ROLE_UPGRADE_SYSTEM or
              trans.packages[aptd_enums.PKGS_UPGRADE] or
@@ -2923,8 +2960,7 @@
     e.g. xterm:i368=235; to xterm;235;i386;installed
     """
     #FIXME add arch support
-    name, version, release = \
-            aptdaemon.worker.AptWorker._split_package_id(pk_id)
+    name, version, release = worker.AptWorker._split_package_id(pk_id)
     try:
         name, arch = name.split(":", 1)
     except ValueError:

=== added file 'aptdaemon/pkenums.py'
--- aptdaemon/pkenums.py	1970-01-01 00:00:00 +0000
+++ aptdaemon/pkenums.py	2012-06-13 16:29:18 +0000
@@ -0,0 +1,326 @@
+# This file was autogenerated from ../../../lib/packagekit-glib2/pk-enum.c by enum-converter.py
+
+class PackageKitEnum:
+	exit = ( "unknown", "success", "failed", "cancelled", "key-required", "eula-required", "media-change-required", "killed", "need-untrusted", "cancelled-priority", "skip-transaction", "repair-required", )
+	status = ( "unknown", "wait", "setup", "running", "query", "info", "refresh-cache", "remove", "download", "install", "update", "cleanup", "obsolete", "dep-resolve", "sig-check", "rollback", "test-commit", "commit", "request", "finished", "cancel", "download-repository", "download-packagelist", "download-filelist", "download-changelog", "download-group", "download-updateinfo", "repackaging", "loading-cache", "scan-applications", "generate-package-list", "waiting-for-lock", "waiting-for-auth", "scan-process-list", "check-executable-files", "check-libraries", "copy-files", )
+	role = ( "unknown", "cancel", "get-depends", "get-details", "get-files", "get-packages", "get-repo-list", "get-requires", "get-update-detail", "get-updates", "install-files", "install-packages", "install-signature", "refresh-cache", "remove-packages", "repo-enable", "repo-set-data", "resolve", "rollback", "search-details", "search-file", "search-group", "search-name", "update-packages", "update-system", "what-provides", "accept-eula", "download-packages", "get-distro-upgrades", "get-categories", "get-old-transactions", "simulate-install-files", "simulate-install-packages", "simulate-remove-packages", "simulate-update-packages", "upgrade-system", "repair-system", "simulate-repair-system", )
+	error = ( "unknown", "out-of-memory", "no-cache", "no-network", "not-supported", "internal-error", "gpg-failure", "filter-invalid", "package-id-invalid", "transaction-error", "transaction-cancelled", "package-not-installed", "package-not-found", "package-already-installed", "package-download-failed", "group-not-found", "group-list-invalid", "dep-resolution-failed", "create-thread-failed", "repo-not-found", "cannot-remove-system-package", "process-kill", "failed-initialization", "failed-finalise", "failed-config-parsing", "cannot-cancel", "cannot-get-lock", "no-packages-to-update", "cannot-write-repo-config", "local-install-failed", "bad-gpg-signature", "missing-gpg-signature", "cannot-install-source-package", "repo-configuration-error", "no-license-agreement", "file-conflicts", "package-conflicts", "repo-not-available", "invalid-package-file", "package-install-blocked", "package-corrupt", "all-packages-already-installed", "file-not-found", "no-more-mirrors-to-try", "no-distro-upgrade-data", "incompatible-architecture", "no-space-on-device", "media-change-required", "not-authorized", "update-not-found", "cannot-install-repo-unsigned", "cannot-update-repo-unsigned", "cannot-get-filelist", "cannot-get-requires", "cannot-disable-repository", "restricted-download", "package-failed-to-configure", "package-failed-to-build", "package-failed-to-install", "package-failed-to-remove", "failed-due-to-running-process", "package-database-changed", "provide-type-not-supported", "install-root-invalid", "cannot-fetch-sources", "cancelled-priority", "unfinished-transaction", )
+	restart = ( "unknown", "none", "system", "session", "application", "security-system", "security-session", )
+	message = ( "unknown", "broken-mirror", "connection-refused", "parameter-invalid", "priority-invalid", "backend-error", "daemon-error", "cache-being-rebuilt", "untrusted-package", "newer-package-exists", "could-not-find-package", "config-files-changed", "package-already-installed", "autoremove-ignored", "repo-metadata-download-failed", "repo-for-developers-only", "other-updates-held-back", )
+	filter = ( "unknown", "none", "installed", "~installed", "devel", "~devel", "gui", "~gui", "free", "~free", "visible", "~visible", "supported", "~supported", "basename", "~basename", "newest", "~newest", "arch", "~arch", "source", "~source", "collections", "~collections", "application", "~application", )
+	group = ( "unknown", "accessibility", "accessories", "education", "games", "graphics", "internet", "office", "other", "programming", "multimedia", "system", "desktop-gnome", "desktop-kde", "desktop-xfce", "desktop-other", "publishing", "servers", "fonts", "admin-tools", "legacy", "localization", "virtualization", "power-management", "security", "communication", "network", "maps", "repos", "science", "documentation", "electronics", "collections", "vendor", "newest", )
+	update_state = ( "unknown", "testing", "unstable", "stable", )
+	info = ( "unknown", "installed", "available", "low", "normal", "important", "security", "bugfix", "enhancement", "blocked", "downloading", "updating", "installing", "removing", "cleanup", "obsoleting", "collection-installed", "collection-available", "finished", "reinstalling", "downgrading", "preparing", "decompressing", "untrusted", "trusted", )
+	sig_type = ( "unknown", "gpg", )
+	upgrade = ( "unknown", "stable", "unstable", )
+	provides = ( "unknown", "any", "modalias", "codec", "mimetype", "driver", "font", "postscript-driver", "plasma-service", "shared-library", "python-module", "language-support", )
+	network = ( "unknown", "offline", "online", "wired", "wifi", "mobile", )
+	media_type = ( "unknown", "cd", "dvd", "disc", )
+	authorize_type = ( "unknown", "yes", "no", "interactive", )
+	upgrade_kind = ( "unknown", "minimal", "default", "complete", )
+
+# Constants
+
+AUTHORIZE_INTERACTIVE = "interactive"
+AUTHORIZE_NO = "no"
+AUTHORIZE_UNKNOWN = "unknown"
+AUTHORIZE_YES = "yes"
+DISTRO_UPGRADE_STABLE = "stable"
+DISTRO_UPGRADE_UNKNOWN = "unknown"
+DISTRO_UPGRADE_UNSTABLE = "unstable"
+ERROR_ALL_PACKAGES_ALREADY_INSTALLED = "all-packages-already-installed"
+ERROR_BAD_GPG_SIGNATURE = "bad-gpg-signature"
+ERROR_CANCELLED_PRIORITY = "cancelled-priority"
+ERROR_CANNOT_CANCEL = "cannot-cancel"
+ERROR_CANNOT_DISABLE_REPOSITORY = "cannot-disable-repository"
+ERROR_CANNOT_FETCH_SOURCES = "cannot-fetch-sources"
+ERROR_CANNOT_GET_FILELIST = "cannot-get-filelist"
+ERROR_CANNOT_GET_LOCK = "cannot-get-lock"
+ERROR_CANNOT_GET_REQUIRES = "cannot-get-requires"
+ERROR_CANNOT_INSTALL_REPO_UNSIGNED = "cannot-install-repo-unsigned"
+ERROR_CANNOT_INSTALL_SOURCE_PACKAGE = "cannot-install-source-package"
+ERROR_CANNOT_REMOVE_SYSTEM_PACKAGE = "cannot-remove-system-package"
+ERROR_CANNOT_UPDATE_REPO_UNSIGNED = "cannot-update-repo-unsigned"
+ERROR_CANNOT_WRITE_REPO_CONFIG = "cannot-write-repo-config"
+ERROR_CREATE_THREAD_FAILED = "create-thread-failed"
+ERROR_DEP_RESOLUTION_FAILED = "dep-resolution-failed"
+ERROR_FAILED_CONFIG_PARSING = "failed-config-parsing"
+ERROR_FAILED_FINALISE = "failed-finalise"
+ERROR_FAILED_INITIALIZATION = "failed-initialization"
+ERROR_FILE_CONFLICTS = "file-conflicts"
+ERROR_FILE_NOT_FOUND = "file-not-found"
+ERROR_FILTER_INVALID = "filter-invalid"
+ERROR_GPG_FAILURE = "gpg-failure"
+ERROR_GROUP_LIST_INVALID = "group-list-invalid"
+ERROR_GROUP_NOT_FOUND = "group-not-found"
+ERROR_INCOMPATIBLE_ARCHITECTURE = "incompatible-architecture"
+ERROR_INSTALL_ROOT_INVALID = "install-root-invalid"
+ERROR_INTERNAL_ERROR = "internal-error"
+ERROR_INVALID_PACKAGE_FILE = "invalid-package-file"
+ERROR_LOCAL_INSTALL_FAILED = "local-install-failed"
+ERROR_MEDIA_CHANGE_REQUIRED = "media-change-required"
+ERROR_MISSING_GPG_SIGNATURE = "missing-gpg-signature"
+ERROR_NOT_AUTHORIZED = "not-authorized"
+ERROR_NOT_SUPPORTED = "not-supported"
+ERROR_NO_CACHE = "no-cache"
+ERROR_NO_DISTRO_UPGRADE_DATA = "no-distro-upgrade-data"
+ERROR_NO_LICENSE_AGREEMENT = "no-license-agreement"
+ERROR_NO_MORE_MIRRORS_TO_TRY = "no-more-mirrors-to-try"
+ERROR_NO_NETWORK = "no-network"
+ERROR_NO_PACKAGES_TO_UPDATE = "no-packages-to-update"
+ERROR_NO_SPACE_ON_DEVICE = "no-space-on-device"
+ERROR_OOM = "out-of-memory"
+ERROR_PACKAGE_ALREADY_INSTALLED = "package-already-installed"
+ERROR_PACKAGE_CONFLICTS = "package-conflicts"
+ERROR_PACKAGE_CORRUPT = "package-corrupt"
+ERROR_PACKAGE_DATABASE_CHANGED = "package-database-changed"
+ERROR_PACKAGE_DOWNLOAD_FAILED = "package-download-failed"
+ERROR_PACKAGE_FAILED_TO_BUILD = "package-failed-to-build"
+ERROR_PACKAGE_FAILED_TO_CONFIGURE = "package-failed-to-configure"
+ERROR_PACKAGE_FAILED_TO_INSTALL = "package-failed-to-install"
+ERROR_PACKAGE_FAILED_TO_REMOVE = "package-failed-to-remove"
+ERROR_PACKAGE_ID_INVALID = "package-id-invalid"
+ERROR_PACKAGE_INSTALL_BLOCKED = "package-install-blocked"
+ERROR_PACKAGE_NOT_FOUND = "package-not-found"
+ERROR_PACKAGE_NOT_INSTALLED = "package-not-installed"
+ERROR_PROCESS_KILL = "process-kill"
+ERROR_PROVIDE_TYPE_NOT_SUPPORTED = "provide-type-not-supported"
+ERROR_REPO_CONFIGURATION_ERROR = "repo-configuration-error"
+ERROR_REPO_NOT_AVAILABLE = "repo-not-available"
+ERROR_REPO_NOT_FOUND = "repo-not-found"
+ERROR_RESTRICTED_DOWNLOAD = "restricted-download"
+ERROR_TRANSACTION_CANCELLED = "transaction-cancelled"
+ERROR_TRANSACTION_ERROR = "transaction-error"
+ERROR_UNFINISHED_TRANSACTION = "unfinished-transaction"
+ERROR_UNKNOWN = "unknown"
+ERROR_UPDATE_FAILED_DUE_TO_RUNNING_PROCESS = "failed-due-to-running-process"
+ERROR_UPDATE_NOT_FOUND = "update-not-found"
+EXIT_CANCELLED = "cancelled"
+EXIT_CANCELLED_PRIORITY = "cancelled-priority"
+EXIT_EULA_REQUIRED = "eula-required"
+EXIT_FAILED = "failed"
+EXIT_KEY_REQUIRED = "key-required"
+EXIT_KILLED = "killed"
+EXIT_MEDIA_CHANGE_REQUIRED = "media-change-required"
+EXIT_NEED_UNTRUSTED = "need-untrusted"
+EXIT_REPAIR_REQUIRED = "repair-required"
+EXIT_SKIP_TRANSACTION = "skip-transaction"
+EXIT_SUCCESS = "success"
+EXIT_UNKNOWN = "unknown"
+FILTER_APPLICATION = "application"
+FILTER_ARCH = "arch"
+FILTER_BASENAME = "basename"
+FILTER_COLLECTIONS = "collections"
+FILTER_DEVELOPMENT = "devel"
+FILTER_FREE = "free"
+FILTER_GUI = "gui"
+FILTER_INSTALLED = "installed"
+FILTER_NEWEST = "newest"
+FILTER_NONE = "none"
+FILTER_NOT_APPLICATION = "~application"
+FILTER_NOT_ARCH = "~arch"
+FILTER_NOT_BASENAME = "~basename"
+FILTER_NOT_COLLECTIONS = "~collections"
+FILTER_NOT_DEVELOPMENT = "~devel"
+FILTER_NOT_FREE = "~free"
+FILTER_NOT_GUI = "~gui"
+FILTER_NOT_INSTALLED = "~installed"
+FILTER_NOT_NEWEST = "~newest"
+FILTER_NOT_SOURCE = "~source"
+FILTER_NOT_SUPPORTED = "~supported"
+FILTER_NOT_VISIBLE = "~visible"
+FILTER_SOURCE = "source"
+FILTER_SUPPORTED = "supported"
+FILTER_UNKNOWN = "unknown"
+FILTER_VISIBLE = "visible"
+GROUP_ACCESSIBILITY = "accessibility"
+GROUP_ACCESSORIES = "accessories"
+GROUP_ADMIN_TOOLS = "admin-tools"
+GROUP_COLLECTIONS = "collections"
+GROUP_COMMUNICATION = "communication"
+GROUP_DESKTOP_GNOME = "desktop-gnome"
+GROUP_DESKTOP_KDE = "desktop-kde"
+GROUP_DESKTOP_OTHER = "desktop-other"
+GROUP_DESKTOP_XFCE = "desktop-xfce"
+GROUP_DOCUMENTATION = "documentation"
+GROUP_EDUCATION = "education"
+GROUP_ELECTRONICS = "electronics"
+GROUP_FONTS = "fonts"
+GROUP_GAMES = "games"
+GROUP_GRAPHICS = "graphics"
+GROUP_INTERNET = "internet"
+GROUP_LEGACY = "legacy"
+GROUP_LOCALIZATION = "localization"
+GROUP_MAPS = "maps"
+GROUP_MULTIMEDIA = "multimedia"
+GROUP_NETWORK = "network"
+GROUP_NEWEST = "newest"
+GROUP_OFFICE = "office"
+GROUP_OTHER = "other"
+GROUP_POWER_MANAGEMENT = "power-management"
+GROUP_PROGRAMMING = "programming"
+GROUP_PUBLISHING = "publishing"
+GROUP_REPOS = "repos"
+GROUP_SCIENCE = "science"
+GROUP_SECURITY = "security"
+GROUP_SERVERS = "servers"
+GROUP_SYSTEM = "system"
+GROUP_UNKNOWN = "unknown"
+GROUP_VENDOR = "vendor"
+GROUP_VIRTUALIZATION = "virtualization"
+INFO_AVAILABLE = "available"
+INFO_BLOCKED = "blocked"
+INFO_BUGFIX = "bugfix"
+INFO_CLEANUP = "cleanup"
+INFO_COLLECTION_AVAILABLE = "collection-available"
+INFO_COLLECTION_INSTALLED = "collection-installed"
+INFO_DECOMPRESSING = "decompressing"
+INFO_DOWNGRADING = "downgrading"
+INFO_DOWNLOADING = "downloading"
+INFO_ENHANCEMENT = "enhancement"
+INFO_FINISHED = "finished"
+INFO_IMPORTANT = "important"
+INFO_INSTALLED = "installed"
+INFO_INSTALLING = "installing"
+INFO_LOW = "low"
+INFO_NORMAL = "normal"
+INFO_OBSOLETING = "obsoleting"
+INFO_PREPARING = "preparing"
+INFO_REINSTALLING = "reinstalling"
+INFO_REMOVING = "removing"
+INFO_SECURITY = "security"
+INFO_TRUSTED = "trusted"
+INFO_UNKNOWN = "unknown"
+INFO_UNTRUSTED = "untrusted"
+INFO_UPDATING = "updating"
+MEDIA_TYPE_CD = "cd"
+MEDIA_TYPE_DISC = "disc"
+MEDIA_TYPE_DVD = "dvd"
+MEDIA_TYPE_UNKNOWN = "unknown"
+MESSAGE_AUTOREMOVE_IGNORED = "autoremove-ignored"
+MESSAGE_BACKEND_ERROR = "backend-error"
+MESSAGE_BROKEN_MIRROR = "broken-mirror"
+MESSAGE_CACHE_BEING_REBUILT = "cache-being-rebuilt"
+MESSAGE_CONFIG_FILES_CHANGED = "config-files-changed"
+MESSAGE_CONNECTION_REFUSED = "connection-refused"
+MESSAGE_COULD_NOT_FIND_PACKAGE = "could-not-find-package"
+MESSAGE_DAEMON_ERROR = "daemon-error"
+MESSAGE_NEWER_PACKAGE_EXISTS = "newer-package-exists"
+MESSAGE_OTHER_UPDATES_HELD_BACK = "other-updates-held-back"
+MESSAGE_PACKAGE_ALREADY_INSTALLED = "package-already-installed"
+MESSAGE_PARAMETER_INVALID = "parameter-invalid"
+MESSAGE_PRIORITY_INVALID = "priority-invalid"
+MESSAGE_REPO_FOR_DEVELOPERS_ONLY = "repo-for-developers-only"
+MESSAGE_REPO_METADATA_DOWNLOAD_FAILED = "repo-metadata-download-failed"
+MESSAGE_UNKNOWN = "unknown"
+MESSAGE_UNTRUSTED_PACKAGE = "untrusted-package"
+NETWORK_MOBILE = "mobile"
+NETWORK_OFFLINE = "offline"
+NETWORK_ONLINE = "online"
+NETWORK_UNKNOWN = "unknown"
+NETWORK_WIFI = "wifi"
+NETWORK_WIRED = "wired"
+PROVIDES_ANY = "any"
+PROVIDES_CODEC = "codec"
+PROVIDES_FONT = "font"
+PROVIDES_HARDWARE_DRIVER = "driver"
+PROVIDES_LANGUAGE_SUPPORT = "language-support"
+PROVIDES_MIMETYPE = "mimetype"
+PROVIDES_MODALIAS = "modalias"
+PROVIDES_PLASMA_SERVICE = "plasma-service"
+PROVIDES_POSTSCRIPT_DRIVER = "postscript-driver"
+PROVIDES_PYTHON = "python-module"
+PROVIDES_SHARED_LIB = "shared-library"
+PROVIDES_UNKNOWN = "unknown"
+RESTART_APPLICATION = "application"
+RESTART_NONE = "none"
+RESTART_SECURITY_SESSION = "security-session"
+RESTART_SECURITY_SYSTEM = "security-system"
+RESTART_SESSION = "session"
+RESTART_SYSTEM = "system"
+RESTART_UNKNOWN = "unknown"
+ROLE_ACCEPT_EULA = "accept-eula"
+ROLE_CANCEL = "cancel"
+ROLE_DOWNLOAD_PACKAGES = "download-packages"
+ROLE_GET_CATEGORIES = "get-categories"
+ROLE_GET_DEPENDS = "get-depends"
+ROLE_GET_DETAILS = "get-details"
+ROLE_GET_DISTRO_UPGRADES = "get-distro-upgrades"
+ROLE_GET_FILES = "get-files"
+ROLE_GET_OLD_TRANSACTIONS = "get-old-transactions"
+ROLE_GET_PACKAGES = "get-packages"
+ROLE_GET_REPO_LIST = "get-repo-list"
+ROLE_GET_REQUIRES = "get-requires"
+ROLE_GET_UPDATES = "get-updates"
+ROLE_GET_UPDATE_DETAIL = "get-update-detail"
+ROLE_INSTALL_FILES = "install-files"
+ROLE_INSTALL_PACKAGES = "install-packages"
+ROLE_INSTALL_SIGNATURE = "install-signature"
+ROLE_REFRESH_CACHE = "refresh-cache"
+ROLE_REMOVE_PACKAGES = "remove-packages"
+ROLE_REPAIR_SYSTEM = "repair-system"
+ROLE_REPO_ENABLE = "repo-enable"
+ROLE_REPO_SET_DATA = "repo-set-data"
+ROLE_RESOLVE = "resolve"
+ROLE_ROLLBACK = "rollback"
+ROLE_SEARCH_DETAILS = "search-details"
+ROLE_SEARCH_FILE = "search-file"
+ROLE_SEARCH_GROUP = "search-group"
+ROLE_SEARCH_NAME = "search-name"
+ROLE_SIMULATE_INSTALL_FILES = "simulate-install-files"
+ROLE_SIMULATE_INSTALL_PACKAGES = "simulate-install-packages"
+ROLE_SIMULATE_REMOVE_PACKAGES = "simulate-remove-packages"
+ROLE_SIMULATE_REPAIR_SYSTEM = "simulate-repair-system"
+ROLE_SIMULATE_UPDATE_PACKAGES = "simulate-update-packages"
+ROLE_UNKNOWN = "unknown"
+ROLE_UPDATE_PACKAGES = "update-packages"
+ROLE_UPDATE_SYSTEM = "update-system"
+ROLE_UPGRADE_SYSTEM = "upgrade-system"
+ROLE_WHAT_PROVIDES = "what-provides"
+SIGTYPE_GPG = "gpg"
+SIGTYPE_UNKNOWN = "unknown"
+STATUS_CANCEL = "cancel"
+STATUS_CHECK_EXECUTABLE_FILES = "check-executable-files"
+STATUS_CHECK_LIBRARIES = "check-libraries"
+STATUS_CLEANUP = "cleanup"
+STATUS_COMMIT = "commit"
+STATUS_COPY_FILES = "copy-files"
+STATUS_DEP_RESOLVE = "dep-resolve"
+STATUS_DOWNLOAD = "download"
+STATUS_DOWNLOAD_CHANGELOG = "download-changelog"
+STATUS_DOWNLOAD_FILELIST = "download-filelist"
+STATUS_DOWNLOAD_GROUP = "download-group"
+STATUS_DOWNLOAD_PACKAGELIST = "download-packagelist"
+STATUS_DOWNLOAD_REPOSITORY = "download-repository"
+STATUS_DOWNLOAD_UPDATEINFO = "download-updateinfo"
+STATUS_FINISHED = "finished"
+STATUS_GENERATE_PACKAGE_LIST = "generate-package-list"
+STATUS_INFO = "info"
+STATUS_INSTALL = "install"
+STATUS_LOADING_CACHE = "loading-cache"
+STATUS_OBSOLETE = "obsolete"
+STATUS_QUERY = "query"
+STATUS_REFRESH_CACHE = "refresh-cache"
+STATUS_REMOVE = "remove"
+STATUS_REPACKAGING = "repackaging"
+STATUS_REQUEST = "request"
+STATUS_ROLLBACK = "rollback"
+STATUS_RUNNING = "running"
+STATUS_SCAN_APPLICATIONS = "scan-applications"
+STATUS_SCAN_PROCESS_LIST = "scan-process-list"
+STATUS_SETUP = "setup"
+STATUS_SIG_CHECK = "sig-check"
+STATUS_TEST_COMMIT = "test-commit"
+STATUS_UNKNOWN = "unknown"
+STATUS_UPDATE = "update"
+STATUS_WAIT = "wait"
+STATUS_WAITING_FOR_AUTH = "waiting-for-auth"
+STATUS_WAITING_FOR_LOCK = "waiting-for-lock"
+UPDATE_STATE_STABLE = "stable"
+UPDATE_STATE_TESTING = "testing"
+UPDATE_STATE_UNKNOWN = "unknown"
+UPDATE_STATE_UNSTABLE = "unstable"
+UPGRADE_KIND_COMPLETE = "complete"
+UPGRADE_KIND_DEFAULT = "default"
+UPGRADE_KIND_MINIMAL = "minimal"
+UPGRADE_KIND_UNKNOWN = "unknown"

=== modified file 'aptdaemon/policykit1.py'
--- aptdaemon/policykit1.py	2012-02-03 06:37:42 +0000
+++ aptdaemon/policykit1.py	2012-06-13 16:29:18 +0000
@@ -91,7 +91,8 @@
     return _check_authorization(subject, action_id, timeout, bus, flags)
 
 def _check_authorization(subject, action_id, timeout, bus, flags=None):
-    def policykit_done((authorized, challenged, auth_details)):
+    def policykit_done(xxx_todo_changeme):
+        (authorized, challenged, auth_details) = xxx_todo_changeme
         if authorized:
             deferred.callback(auth_details)
         elif challenged:

=== modified file 'aptdaemon/progress.py'
--- aptdaemon/progress.py	2012-04-09 20:48:44 +0000
+++ aptdaemon/progress.py	2012-06-13 16:29:18 +0000
@@ -231,7 +231,7 @@
 
     def stop(self):
         """Callback at the end of the operation"""
-        self.transaction.progress_details = (0, 0, 0L, 0L, 0.0, 0L)
+        self.transaction.progress_details = (0, 0, 0, 0, 0.0, 0)
         self.transaction.progress = self.progress_end
         self.transaction.cancellable = False
 
@@ -370,7 +370,16 @@
                                              msg
 
 
-class DaemonInstallProgress(object):
+class DaemonForkProgress(object):
+
+    """Forks and executes a given method in the child process while
+    monitoring the output and return state.
+
+    During the run() call the mainloop will be iterated.
+
+    Furthermore a status file descriptor is available to communicate
+    with the child process.
+    """
 
     def __init__(self, transaction, begin=50, end=100):
         self.transaction = transaction
@@ -385,9 +394,15 @@
         self.output = ""
         self._line_buffer = ""
 
+    def __enter__(self):
+        self.start_update()
+        return self
+
+    def __exit__(self, etype, evalue, etb):
+        self.finish_update()
+
     def start_update(self):
         log.debug("Start update")
-        lock.status_lock.release()
         self.transaction.status = enums.STATUS_COMMITTING
         self.transaction.term_attached = True
         self.last_activity = time.time()
@@ -396,17 +411,21 @@
     def finish_update(self):
         """Callback at the end of the operation"""
         self.transaction.term_attached = False
-        lock.wait_for_lock(self.transaction, lock.status_lock)
-
-    def _child(self, pm):
-        try:
-            res = pm.do_install(self.status_child_fd)
-        except:
-            os._exit(apt_pkg.PackageManager.RESULT_FAILED)
-        else:
-            os._exit(res)
+
+    def _child(self, method, *args):
+        """Call the given method or function with the
+        corrsponding arguments in the child process.
+
+        This method should be replace in subclasses.
+        """
+        method(*args)
+        time.sleep(0.5)
+        os._exit(0)
 
     def run(self, *args, **kwargs):
+        """Setup monitoring, fork and call the self._child() method in the
+        child process with the given arguments.
+        """
         log.debug("Run")
         terminal_fd = None
         if self.transaction.terminal:
@@ -477,68 +496,14 @@
         return False
 
     def _on_status_update(self, source, condition):
-        log.debug("UpdateInterface")
-        status_msg = ""
-        try:
-            while not status_msg.endswith("\n"):
-                self.last_activity = time.time()
-                status_msg += os.read(source, 1)
-        except:
-            return False
-        try:
-            (status, pkg, percent, message_raw) = status_msg.split(":", 3)
-        except ValueError:
-            # silently ignore lines that can't be parsed
-            return True
-        message = message_raw.strip()
-        #print "percent: %s %s" % (pkg, float(percent)/100.0)
-        if status == "pmerror":
-            self._error(pkg, message)
-        elif status == "pmconffile":
-            # we get a string like this:
-            # 'current-conffile' 'new-conffile' useredited distedited
-            match = re.match("\s*\'(.*)\'\s*\'(.*)\'.*", message_raw)
-            if match:
-                new, old = match.group(1), match.group(2)
-                self._conffile(new, old)
-        elif status == "pmstatus":
-            if message.startswith("Installing"):
-                status_enum = enums.PKG_INSTALLING
-            elif message.startswith("Installed"):
-                status_enum = enums.PKG_INSTALLED
-            elif message.startswith("Configuring"):
-                status_enum = enums.PKG_CONFIGURING
-            elif message.startswith("Preparing to configure"):
-                status_enum = enums.PKG_PREPARING_CONFIGURE
-            elif message.startswith("Preparing for removal of"):
-                status_enum = enums.PKG_PREPARING_REMOVE
-            elif message.startswith("Removing"):
-                status_enum = enums.PKG_REMOVING
-            elif message.startswith("Removed"):
-                status_enum = enums.PKG_REMOVED
-            elif message.startswith("Preparing to completely remove"):
-                status_enum = enums.PKG_PREPARING_PURGE
-            elif message.startswith("Completely removing"):
-                status_enum = enums.PKG_PURGING
-            elif message.startswith("Completely removed"):
-                status_enum = enums.PKG_PURGED
-            elif message.startswith("Unpacking"):
-                status_enum = enums.PKG_UNPACKING
-            elif message.startswith("Preparing"):
-                status_enum = enums.PKG_PREPARING_INSTALL
-            elif message.startswith("Noting disappearance of"):
-                 status_enum = enums.PKG_DISAPPEARING
-            elif message.startswith("Running"):
-                status_enum = enums.PKG_RUNNING_TRIGGER
-            else:
-                status_enum = enums.PKG_UNKNOWN
-            self._status_changed(pkg, float(percent), status_enum)
-        # catch a time out by sending crtl+c
-        if self.last_activity + INSTALL_TIMEOUT < time.time() and \
-           self.child_pid:
-            log.critical("Killing child since timeout of %s s", INSTALL_TIMEOUT)
-            os.kill(self.child_pid, 15)
-        return True
+        """Callback for changes on the status file descriptor.
+
+        The method has to return True to keep the monitoring alive. If
+        it returns False the monitoring will stop.
+
+        Replace this method in your subclass if you use the status fd.
+        """
+        return False
 
     def _fork(self):
         """Fork and create a master/slave pty pair by which the forked process
@@ -598,11 +563,12 @@
         if condition == GObject.IO_IN:
             self.last_activity = time.time()
             try:
-                char = os.read(source, 1)
+                char_byte = os.read(source, 1)
             except OSError:
                 log.debug("Faild to read from master")
                 return True
             # Write all the output from dpkg to a log
+            char = char_byte.decode("UTF-8", "ignore")
             if char == "\n":
                 # Skip ANSI characters from the console output
                 line = re.sub(REGEX_ANSI_ESCAPE_CODE, "", self._line_buffer)
@@ -614,7 +580,7 @@
                 self._line_buffer += char
             if target:
                 try:
-                    os.write(target, char)
+                    os.write(target, char_byte)
                 except OSError:
                     log.debug("Failed to write to controlling terminal")
             return True
@@ -642,6 +608,93 @@
         os.close(source)
         return False
 
+
+class DaemonInstallProgress(DaemonForkProgress):
+
+    """Progress to execute APT package operations in a child process."""
+
+    def start_update(self):
+        DaemonForkProgress.start_update(self)
+        lock.status_lock.release()
+
+    def finish_update(self):
+        """Callback at the end of the operation"""
+        DaemonForkProgress.finish_update(self)
+        lock.wait_for_lock(self.transaction, lock.status_lock)
+
+    def _child(self, pm):
+        try:
+            res = pm.do_install(self.status_child_fd)
+        except:
+            os._exit(apt_pkg.PackageManager.RESULT_FAILED)
+        else:
+            os._exit(res)
+
+    def _on_status_update(self, source, condition):
+        """Parse messages from APT on the status fd."""
+        log.debug("UpdateInterface")
+        status_msg = ""
+        try:
+            while not status_msg.endswith("\n"):
+                self.last_activity = time.time()
+                status_msg += os.read(source, 1).decode("UTF-8", "ignore")
+        except:
+            return False
+        try:
+            (status, pkg, percent, message_raw) = status_msg.split(":", 3)
+        except ValueError:
+            # silently ignore lines that can't be parsed
+            return True
+        message = message_raw.strip()
+        #print "percent: %s %s" % (pkg, float(percent)/100.0)
+        if status == "pmerror":
+            self._error(pkg, message)
+        elif status == "pmconffile":
+            # we get a string like this:
+            # 'current-conffile' 'new-conffile' useredited distedited
+            match = re.match("\s*\'(.*)\'\s*\'(.*)\'.*", message_raw)
+            if match:
+                new, old = match.group(1), match.group(2)
+                self._conffile(new, old)
+        elif status == "pmstatus":
+            if message.startswith("Installing"):
+                status_enum = enums.PKG_INSTALLING
+            elif message.startswith("Installed"):
+                status_enum = enums.PKG_INSTALLED
+            elif message.startswith("Configuring"):
+                status_enum = enums.PKG_CONFIGURING
+            elif message.startswith("Preparing to configure"):
+                status_enum = enums.PKG_PREPARING_CONFIGURE
+            elif message.startswith("Preparing for removal of"):
+                status_enum = enums.PKG_PREPARING_REMOVE
+            elif message.startswith("Removing"):
+                status_enum = enums.PKG_REMOVING
+            elif message.startswith("Removed"):
+                status_enum = enums.PKG_REMOVED
+            elif message.startswith("Preparing to completely remove"):
+                status_enum = enums.PKG_PREPARING_PURGE
+            elif message.startswith("Completely removing"):
+                status_enum = enums.PKG_PURGING
+            elif message.startswith("Completely removed"):
+                status_enum = enums.PKG_PURGED
+            elif message.startswith("Unpacking"):
+                status_enum = enums.PKG_UNPACKING
+            elif message.startswith("Preparing"):
+                status_enum = enums.PKG_PREPARING_INSTALL
+            elif message.startswith("Noting disappearance of"):
+                 status_enum = enums.PKG_DISAPPEARING
+            elif message.startswith("Running"):
+                status_enum = enums.PKG_RUNNING_TRIGGER
+            else:
+                status_enum = enums.PKG_UNKNOWN
+            self._status_changed(pkg, float(percent), status_enum)
+        # catch a time out by sending crtl+c
+        if self.last_activity + INSTALL_TIMEOUT < time.time() and \
+           self.child_pid:
+            log.critical("Killing child since timeout of %s s", INSTALL_TIMEOUT)
+            os.kill(self.child_pid, 15)
+        return True
+
     def _status_changed(self, pkg, percent, status_enum):
         """Callback to update status information"""
         log.debug("APT status: %s, %s, %s", pkg, percent, status_enum)
@@ -669,9 +722,9 @@
         log.debug("Sending config file answer: %s",
                   self.transaction.config_file_conflict_resolution)
         if self.transaction.config_file_conflict_resolution == "replace":
-            os.write(self.master_fd, "y\n")
+            os.write(self.master_fd, b"y\n")
         elif self.transaction.config_file_conflict_resolution == "keep":
-            os.write(self.master_fd, "n\n")
+            os.write(self.master_fd, b"n\n")
         self.transaction.config_file_conflict_resolution = None
         self.transaction.config_file_conflict = None
         self.transaction.status = enums.STATUS_COMMITTING
@@ -703,7 +756,7 @@
         status_raw = ""
         try:
             while not status_raw.endswith("\n"):
-                status_raw += os.read(source, 1)
+                status_raw += os.read(source, 1).decode("UTF-8", "ignore")
         except:
             return False
         try:

=== modified file 'aptdaemon/test.py'
--- aptdaemon/test.py	2012-02-03 06:37:42 +0000
+++ aptdaemon/test.py	2012-06-13 16:29:18 +0000
@@ -28,10 +28,21 @@
 import shutil
 import subprocess
 import sys
+import time
 import tempfile
 import unittest
 
+if sys.version_info.major > 2:
+    from http.server import HTTPServer
+    from http.server import SimpleHTTPRequestHandler as HTTPRequestHandler
+else:
+    from BaseHTTPServer import HTTPServer
+    from SimpleHTTPServer import SimpleHTTPRequestHandler as HTTPRequestHandler
+
 import apt_pkg
+import apt.auth
+
+PY3K = sys.version_info.major > 2
 
 
 class Chroot(object):
@@ -55,16 +66,20 @@
         os.makedirs(os.path.join(self.path, "var/lib/apt/lists/partial"))
         os.makedirs(os.path.join(self.path, "etc/apt/apt.conf.d"))
         os.makedirs(os.path.join(self.path, "etc/apt/sources.list.d"))
+        os.makedirs(os.path.join(self.path, "etc/apt/preferences.d"))
         os.makedirs(os.path.join(self.path, "var/log"))
         os.makedirs(os.path.join(self.path, "media"))
 
         # Make apt use the new chroot
         dpkg_wrapper = os.path.join(get_tests_dir(), "dpkg-wrapper.sh")
+        apt_key_wrapper = os.path.join(get_tests_dir(), "fakeroot-apt-key")
         config_path = os.path.join(self.path, "etc/apt/apt.conf.d/10chroot")
         with open(config_path, "w") as cnf:
             cnf.write("Dir::Bin::DPkg %s;" % dpkg_wrapper)
+            cnf.write("Dir::Bin::Apt-Key %s;" % apt_key_wrapper)
         apt_pkg.read_config_file(apt_pkg.config, config_path)
         apt_pkg.init_system()
+        apt_pkg.config["Dir"] = self.path
 
     def remove(self):
         """Remove the files of the chroot."""
@@ -75,16 +90,8 @@
 
     def add_trusted_key(self):
         """Add glatzor's key to the trusted ones."""
-        gpg_cmd = "gpg --ignore-time-conflict --no-options " \
-                  "--no-default-keyring --quiet " \
-                  "--secret-keyring %s/etc/apt/secring.gpg " \
-                  "--trustdb-name %s/etc/apt/trustdb.gpg " \
-                  "--primary-keyring %s/etc/apt/trusted.gpg " % \
-                  (self.path, self.path, self.path)
-        os.system("%s --import %s/repo/glatzor.gpg" % (gpg_cmd,
-                                                       get_tests_dir()))
-        os.system("echo 'D0BF65B7DBE28DB62BEDBF1B683C53C7CF982D18:6:'| "
-                  "%s --import-ownertrust " % gpg_cmd)
+        apt.auth.add_key_from_file(os.path.join(get_tests_dir(),
+                                                "repo/glatzor.gpg"))
 
     def install_debfile(self, path, force_depends=False):
         """Install a package file into the chroot."""
@@ -162,6 +169,14 @@
 
 class AptDaemonTestCase(unittest.TestCase):
 
+    @classmethod
+    def setupClass(cls):
+        # Start with a clean APT configuration to remove changes
+        # of previous tests
+        for key in set([key.split("::")[0] for key in apt_pkg.config.keys()]):
+            apt_pkg.config.clear(key)
+        apt_pkg.init_config()
+
     def start_fake_polkitd(self, options="all"):
         """Start a fake PolicyKit daemon.
 
@@ -169,7 +184,8 @@
                                 Defaults to all
         """
         try:
-            env = {"DBUS_SYSTEM_BUS_ADDRESS": self.dbus_address}
+            env = os.environ.copy()
+            env["DBUS_SYSTEM_BUS_ADDRESS"] = self.dbus_address
         except AttributeError:
             env=None
         dir = get_tests_dir()
@@ -185,7 +201,8 @@
         :param chroot: path to the chroot
         """
         try:
-            env = {"DBUS_SYSTEM_BUS_ADDRESS": self.dbus_address}
+            env = os.environ.copy()
+            env["DBUS_SYSTEM_BUS_ADDRESS"] = self.dbus_address
         except AttributeError:
             env = None
         dir = get_tests_dir()
@@ -193,7 +210,7 @@
             path = "/usr/sbin/aptd"
         else:
             path = os.path.join(dir, "../aptd")
-        proc = subprocess.Popen(["python", path, "--debug",
+        proc = subprocess.Popen(["python3", path, "--debug",
                                  "--disable-timeout", "--disable-plugins",
                                  "--chroot", chroot],
                                  env=env)
@@ -202,14 +219,42 @@
 
     def start_dbus_daemon(self):
         """Start a private D-Bus daemon and return its process and address."""
-        config_path = os.path.join(get_tests_dir(), "dbus.conf")
-        proc = subprocess.Popen(["dbus-daemon", "--nofork",
-                                 "--print-address", "--config-file",
-                                 config_path],
-                                 stdout=subprocess.PIPE)
+        proc, dbus_address = start_dbus_daemon()
         self.addCleanup(self._kill_process, proc)
-        self.dbus_address = proc.stdout.readline().strip()
-        return proc, self.dbus_address
+        self.dbus_address = dbus_address
+
+    def start_keyserver(self, filename=None):
+        """Start a fake keyserver on hkp://localhost:19191
+
+        Keyword arguments:
+        filename -- Optional path to a GnuPG pulic key file which should
+            be returned by lookups. By default the key of the test repo
+            is used.
+        """
+        dir = tempfile.mkdtemp(prefix="keyserver-test-")
+        self.addCleanup(shutil.rmtree, dir)
+        os.mkdir(os.path.join(dir, "pks"))
+        if filename is None:
+            filename = os.path.join(get_tests_dir(), "repo/glatzor.gpg")
+        shutil.copy(filename, os.path.join(dir, "pks", "lookup"))
+
+        pid = os.fork()
+        if pid == 0:
+            # quiesce server log
+            os.dup2(os.open('/dev/null', os.O_WRONLY), sys.stderr.fileno())
+            os.chdir(dir)
+            httpd = HTTPServer(('localhost', 19191), HTTPRequestHandler)
+            httpd.serve_forever()
+            os._exit(0)
+        else:
+            self.addCleanup(self._kill_pid, pid)
+
+        # wait a bit until server is ready
+        time.sleep(0.5)
+
+    def _kill_pid(self, pid):
+        os.kill(pid, 15)
+        os.wait()
 
     def _kill_process(self, proc):
         proc.kill()
@@ -234,5 +279,19 @@
     else:
         raise Exception("Could not find tests direcotry")
 
+def start_dbus_daemon():
+    """Start a private D-Bus daemon and return its process and address."""
+    config_path = os.path.join(get_tests_dir(), "dbus.conf")
+    proc = subprocess.Popen(["dbus-daemon", "--nofork",
+                             "--print-address", "--config-file",
+                             config_path],
+                             stdout=subprocess.PIPE)
+    output = proc.stdout.readline().strip()
+    if PY3K:
+        dbus_address = output.decode()
+    else:
+        dbus_address = output
+    return proc, dbus_address
+
 
 # vim: ts=4 et sts=4

=== modified file 'aptdaemon/utils.py'
--- aptdaemon/utils.py	2012-04-02 19:04:16 +0000
+++ aptdaemon/utils.py	2012-06-13 16:29:18 +0000
@@ -44,8 +44,8 @@
                 'funcname': func.__name__,
             },
             category=DeprecationWarning,
-            filename=func.func_code.co_filename,
-            lineno=func.func_code.co_firstlineno + 1
+            filename=func.__code__.co_filename,
+            lineno=func.__code__.co_firstlineno + 1
         )
         return func(*args, **kwargs)
     return new_func
@@ -62,7 +62,7 @@
         et = ElementTree.ElementTree(file=filename)
         self._dict = {}
         self.norm = norm
-        for element in et.getiterator():
+        for element in list(et.iter()):
             iso_code = element.get(tag)
             if not iso_code and fallback_tag:
                 iso_code = element.get(fallback_tag)

=== modified file 'aptdaemon/worker.py'
--- aptdaemon/worker.py	2012-05-11 15:56:04 +0000
+++ aptdaemon/worker.py	2012-06-13 16:29:18 +0000
@@ -31,8 +31,13 @@
 import tempfile
 import time
 import traceback
+try:
+	from urllib.parse import urlsplit, urlunsplit
+except ImportError:
+	from urlparse import urlsplit, urlunsplit
 
 import apt
+import apt.auth
 import apt.cache
 import apt.debfile
 import apt_pkg
@@ -41,7 +46,6 @@
 from aptsources.sourceslist import SourcesList
 from gi.repository import GObject
 import pkg_resources
-from softwareproperties.AptAuth import AptAuth
 import subprocess
 
 from .enums import *
@@ -54,7 +58,8 @@
                      DaemonAcquireRepoProgress, \
                      DaemonDpkgInstallProgress, \
                      DaemonDpkgReconfigureProgress, \
-                     DaemonDpkgRecoverProgress
+                     DaemonDpkgRecoverProgress, \
+                     DaemonForkProgress
 
 log = logging.getLogger("AptDaemon.Worker")
 
@@ -413,7 +418,7 @@
         """
         trans.progress = 101
         trans.status = STATUS_COMMITTING
-        old_umask = os.umask(0022)
+        old_umask = os.umask(0o022)
         try:
             sourceslist = SourcesList()
             distro = aptsources.distro.get_distro()
@@ -470,8 +475,6 @@
         """Extract the credentials from an URI. Store the password in
         auth.conf and return the URI without any password information.
         """
-        from urlparse import urlsplit, urlunsplit
-
         try:
             res = urlsplit(uri)
         except ValueError as error:
@@ -483,7 +486,7 @@
 
         # write auth.conf
         auth_conf_path = apt_pkg.config.find_file("Dir::etc::netrc")
-        old_umask = os.umask(0027)
+        old_umask = os.umask(0o027)
         try:
             with open(auth_conf_path, "a") as auth_conf:
                 auth_conf.write("""machine %s
@@ -508,33 +511,39 @@
         keyserver - the keyserver (e.g. keyserver.ubuntu.com)
         """
         log.info("Adding vendor key from keyserver: %s %s", keyid, keyserver)
+        # Perform some sanity checks
+        try:
+            res = urlsplit(keyserver)
+        except ValueError:
+            raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
+                                    #TRANSLATORS: %s is the URL of GnuPG
+                                    #             keyserver
+                                    _("The keyserver URL is invalid: %s"),
+                                    keyserver)
+        if res.scheme not in ["hkp", "ldap", "ldaps", "http", "https"]:
+            raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
+                                    #TRANSLATORS: %s is the URL of GnuPG
+                                    #             keyserver
+                                    _("Invalid protocol of the server: %s"),
+                                    keyserver)
+        try:
+            int(keyid, 16)
+        except ValueError:
+            raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
+                                    #TRANSLATORS: %s is the id of a GnuPG key
+                                    #             e.g. E08ADE95
+                                    _("Invalid key id: %s"), keyid)
         trans.status = STATUS_DOWNLOADING
         trans.progress = 101
         last_pulse = time.time()
-        #FIXME: Use GObject.spawn_async and deferreds in the worker
-        #       Alternatively we could use python-pyme directly for a better
-        #       error handling. Or the --status-fd of gpg
-        proc = subprocess.Popen(["/usr/bin/apt-key", "adv",
-                                 "--keyserver", keyserver,
-                                 "--recv", keyid], stderr=subprocess.STDOUT,
-                                 stdout=subprocess.PIPE, close_fds=True)
-        while proc.poll() is None:
-            self._iterate_mainloop()
-            time.sleep(0.05)
-            if time.time() - last_pulse > 0.3:
-                trans.progress = 101
-                last_pulse = time.time()
-        if proc.returncode != 0:
-            stdout = unicode(proc.stdout.read(), 
-                             # that can return "None", in this case, just
-                             # assume something
-                             sys.stdin.encoding or "UTF-8",
-                             errors="replace")
+        with DaemonForkProgress(trans) as progress:
+            progress.run(apt.auth.add_key_from_keyserver, keyid, keyserver)
+        if progress._child_exit != 0:
             #TRANSLATORS: The first %s is the key id and the second the server
             raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
                                     _("Failed to download and install the key "
                                       "%s from %s:\n%s"),
-                                    keyid, keyserver, stdout)
+                                    keyid, keyserver, progress.output)
 
     def add_vendor_key_from_file(self, trans, path):
         """Add the signing key from the given file to the trusted vendors.
@@ -545,15 +554,12 @@
         log.info("Adding vendor key from file: %s", path)
         trans.progress = 101
         trans.status = STATUS_COMMITTING
-        try:
-            #FIXME: use GObject.spawn_async or reactor.spawn
-            #FIXME: use --dry-run before?
-            auth = AptAuth()
-            auth.add(os.path.expanduser(path))
-        except Exception as error:
+        with DaemonForkProgress(trans) as progress:
+            progress.run(apt.auth.add_key_from_file, path)
+        if progress._child_exit != 0:
             raise TransactionFailed(ERROR_KEY_NOT_INSTALLED,
                                     _("Key file %s couldn't be installed: %s"),
-                                    path, error)
+                                    path, progress.output)
 
     def remove_vendor_key(self, trans, fingerprint):
         """Remove repository key.
@@ -566,14 +572,19 @@
         trans.progress = 101
         trans.status = STATUS_COMMITTING
         try:
-            #FIXME: use GObject.spawn_async or reactor.spawn
-            #FIXME: use --dry-run before?
-            auth = AptAuth()
-            auth.rm(fingerprint)
-        except Exception as error:
+            int(fingerprint, 16)
+        except ValueError:
+            raise TransactionFailed(ERROR_KEY_NOT_REMOVED,
+                                    #TRANSLATORS: %s is the id of a GnuPG key
+                                    #             e.g. E08ADE95
+                                    _("Invalid key id: %s"), fingerprint)
+        with DaemonForkProgress(trans) as progress:
+            progress.run(apt.auth.remove_key, fingerprint)
+        if progress._child_exit != 0:
             raise TransactionFailed(ERROR_KEY_NOT_REMOVED,
                                     _("Key with fingerprint %s couldn't be "
-                                      "removed: %s"), fingerprint, error)
+                                      "removed: %s"), fingerprint,
+                                      progress.output)
 
     def install_file(self, trans, path, force, simulate=False):
         """Install local package file.
@@ -603,7 +614,7 @@
             deb_progress = DaemonDpkgInstallProgress(trans, begin=64, end=95)
             res = deb.install(deb_progress)
             encoding = sys.getfilesystemencoding()
-            trans.output += deb_progress.output.decode(encoding, "ignore")
+            trans.output += deb_progress.output
             if res:
                 raise TransactionFailed(ERROR_PACKAGE_MANAGER_FAILED,
                                         trans.output)
@@ -863,13 +874,10 @@
         """
         log.info("Fixing incomplete installs")
         trans.status = STATUS_CLEANING_UP
-        progress = DaemonDpkgRecoverProgress(trans)
         with self._frozen_status():
-            progress.start_update()
-            progress.run()
-            progress.finish_update()
-        trans.output += progress.output.decode(sys.getfilesystemencoding(),
-                                               "ignore")
+            with DaemonDpkgRecoverProgress(trans) as progress:
+                progress.run()
+        trans.output += progress.output
         if progress._child_exit != 0:
             raise TransactionFailed(ERROR_PACKAGE_MANAGER_FAILED,
                                     trans.output)
@@ -883,13 +891,10 @@
         priority -- the lowest priority of question which should be asked
         """
         log.info("Reconfiguring packages")
-        progress = DaemonDpkgReconfigureProgress(trans)
         with self._frozen_status():
-            progress.start_update()
-            progress.run(packages, priority)
-            progress.finish_update()
-        trans.output += progress.output.decode(sys.getfilesystemencoding(),
-                                               "ignore")
+            with DaemonDpkgReconfigureProgress(trans) as progress:
+                progress.run(packages, priority)
+        trans.output += progress.output
         if progress._child_exit != 0:
             raise TransactionFailed(ERROR_PACKAGE_MANAGER_FAILED,
                                     trans.output)
@@ -993,18 +998,15 @@
             except SystemError as excep:
                 # Run dpkg --configure -a to recover from a failed transaction
                 trans.status = STATUS_CLEANING_UP
-                progress = DaemonDpkgRecoverProgress(trans, begin=90, end=95)
-                progress.start_update()
-                progress.run()
-                progress.finish_update()
-                output = inst_progress.output + progress.output
-                trans.output += output.decode(sys.getfilesystemencoding(),
-                                              "ignore")
+                with DaemonDpkgRecoverProgress(trans, begin=90, end=95) as pro:
+                    pro.run()
+                output = inst_progress.output + pro.output
+                trans.output += output
                 raise TransactionFailed(ERROR_PACKAGE_MANAGER_FAILED,
                                         "%s: %s" % (excep, trans.output))
             else:
                 enc = sys.getfilesystemencoding()
-                trans.output += inst_progress.output.decode(enc, "ignore")
+                trans.output += inst_progress.output
 
     @contextlib.contextmanager
     def _frozen_status(self):
@@ -1103,7 +1105,7 @@
                 size = int(deb["Installed-Size"].replace(",", "")) * 1024
                 # Some packages ship really large install sizes e.g.
                 # openvpn access server, see LP #758837
-                if size > sys.maxint:
+                if size > sys.maxsize:
                     raise OverflowError("Size is too large: %s Bytes" % size)
             except (KeyError, AttributeError, ValueError, OverflowError):
                 if not trans.kwargs["force"]:
@@ -1181,7 +1183,6 @@
         :returns: An apt.debfile.Debfile instance.
         """
         #FIXME: Unblock lintian call
-        path = path.encode("UTF-8")
         if not os.path.isfile(path):
             raise TransactionFailed(ERROR_UNREADABLE_PACKAGE_FILE, path)
         if not force and os.path.isfile("/usr/bin/lintian"):
@@ -1219,9 +1220,9 @@
                     time.sleep(0.05)
                 #FIXME: Add an error to catch return state 2 (failure)
                 if proc.returncode == 1:
-                    stdout = unicode(proc.stdout.read(),
-                                     sys.stdin.encoding or "UTF-8",
-                                     errors="replace")
+                    stdout = proc.stdout.read()
+                    stdout.decode(sys.stdin.encoding or "UTF-8",
+                                  errors="replace")
                     raise TransactionFailed(ERROR_INVALID_PACKAGE_FILE,
                                             "Lintian check results for %s:"
                                             "\n%s" % (path, stdout))

=== modified file 'aptdcon'
--- aptdcon	2009-06-30 15:06:36 +0000
+++ aptdcon	2012-06-13 16:29:18 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 """
 aptdcon - command line interface client to aptdaemon

=== modified file 'debian/aptdaemon.install'
--- debian/aptdaemon.install	2012-04-09 20:48:44 +0000
+++ debian/aptdaemon.install	2012-06-13 16:29:18 +0000
@@ -1,7 +1,7 @@
 etc/apt/apt.conf.d/20dbus
 etc/dbus-1/system.d/org.debian.apt.conf
-usr/bin/aptd /usr/sbin
-usr/bin/aptdcon
+../../build/scripts-3.*/aptd /usr/sbin
+../../build/scripts-3.*/aptdcon /usr/bin
 usr/share/dbus-1/system-services/org.debian.apt.service
 usr/share/polkit-1/actions/org.debian.apt.policy
 usr/share/locale

=== modified file 'debian/changelog'
--- debian/changelog	2012-05-23 12:53:16 +0000
+++ debian/changelog	2012-06-13 16:29:18 +0000
@@ -1,3 +1,42 @@
+aptdaemon (0.43+bzr838-0ubuntu1) UNRELEASED; urgency=low
+
+  * Upload of the latest Python3 porting efforts from trunk
+  * debian/patches:
+     - Add disable_simulate_test: Fails on build bot for unknown reasons
+  * debian/control:
+     - Switch aptdaemon package to Python3 by default
+     - Add new python3-aptdaemon.gtk3widgets package
+     - Replace python-aptdaemon.test by python3-aptdaemon.test
+     - Replace python-aptdaemon.pkcompat by python3-aptdaemon.pkcompat
+     - python3-aptdaemon.pkcompat provides the new virtual package
+       packagekit-system-interface to obsolete the OR dependencies
+       with packagekit of PackageKit clients
+     - Remove policykit1 dependecy from the modules and add it to the server
+       package
+     - Remove not used shlibs macros
+     - Remove dependency to python-packagekit, since we ship the enums
+       in python3-aptdaemon.pkcompat
+     - Add build dependencies to run the test suite
+  * debian/rules:
+     - Build with Python2 and 3
+     - Enable the test suite
+  * debian/*.(install|docs|examples):
+     - Adpat to above package changes
+
+  [ Steve Langasek ]
+  * debian/control:
+    - Remove python-software-properties dependency in favor of new
+      python-apt with apt.auth module
+  * aptdaemon/test.py: explicitly set the chroot directory in the apt config
+    as part of the test setup, without which apt-key's chroot handling won't
+    work.
+  * test/test_pk.py: increase the sleep on startup, to allow longer for
+    fake-polkitd to start up.
+  * aptdaemon/worker.py: restore compatibility with python2, which doesn't
+    have urllib.parse.
+
+ -- Sebastian Heinlein <[e-mail]>  Fri, 11 May 2012 08:39:34 -0700
+
 aptdaemon (0.43+bzr810-0ubuntu3) quantal; urgency=low
 
   * debian/python-aptdaemon.test.install: Fix installation path of

=== modified file 'debian/control'
--- debian/control	2012-05-22 11:01:33 +0000
+++ debian/control	2012-06-13 16:29:18 +0000
@@ -4,35 +4,50 @@
 Maintainer: Ubuntu Developers <[e-mail]>
 XSBC-Original-Maintainer: Julian Andres Klode <[e-mail]>
 Build-Depends: debhelper (>= 7.3),
+               debconf-i18n,
+               dbus,
+               lintian,
                dh-translations,
-               dbus,
-               python,
+               python-all,
                python-setuptools,
                python-distutils-extra,
-               python-apt (>= 0.7.96.1ubuntu9),
-               python-debian,
-               python-defer,
+               python-nose,
+               python3-all,
+               python3-setuptools,
+               python3-distutils-extra,
+               python3-nose,
+               gir1.2-glib-2.0,
+               gir1.2-packagekitglib-1.0,
+               python3-apt (>= 0.8.5~ubuntu1),
+               python3-defer (>= 1.0.6),
+               python3-dbus,
+               python3-gi,
+               python3-mock,
+               python3-pkg-resources,
+               python-apt (>= 0.8.5~ubuntu1),
+               python-defer (>= 1.0.6),
                python-dbus,
                python-gi,
-               gir1.2-glib-2.0,
-               python-software-properties
+               python-mock,
+               python-pkg-resources,
 Standards-Version: 3.9.1
 Homepage: https://launchpad.net/aptdaemon
 Vcs-Bzr: lp:~aptdaemon-developers/aptdaemon/ubuntu-quantal
 Vcs-Browser: https://code.launchpad.net/~aptdaemon-developers/aptdaemon/ubuntu-quantal
 XS-Original-Vcs-Bzr: nosmart+http://bzr.debian.org/bzr/apt/aptdaemon/debian-sid
 XS-Original-Vcs-Browser: http://bzr.debian.org/loggerhead/apt/aptdaemon/debian-sid
-XS-Python-Version: >= 2.7
+X-Python-Version: >= 2.7
+X-Python3-Version: >= 3.2
 
 Package: aptdaemon
 Architecture: all
 Depends: ${misc:Depends},
-         ${python:Depends},
-         python-aptdaemon (= ${binary:Version}),
-         python-gi,
-         gir1.2-glib-2.0
+         ${python3:Depends},
+         gir1.2-glib-2.0,
+         python3-aptdaemon (= ${binary:Version}),
+         python3-gi,
+         policykit-1,
 Recommends: lintian
-XB-Python-Version: ${python:Versions}
 Breaks: software-center (<< 1.1.21)
 Description: transaction based package management service
  Aptdaemon allows normal users to perform package management tasks, e.g. 
@@ -54,39 +69,54 @@
  the daemon. Moreover it contains the aptdcon script, which is a command
  line client for aptdaemon. The API is not stable yet.
 
+Package: python3-aptdaemon
+Architecture: all
+Section: python
+Depends: ${misc:Depends},
+         ${python3:Depends},
+         gir1.2-glib-2.0,
+         python3-apt (>= 0.8.5~ubuntu1),
+         python3-defer (>= 1.0.6),
+         python3-dbus,
+         python3-gi,
+         python3-pkg-resources,
+Recommends: aptdaemon
+Description: Python 3 module for the server and client of aptdaemon
+ Aptdaemon is a transaction based package management service. It allows 
+ normal users to perform package management tasks, e.g. refreshing the 
+ cache, upgrading the system, installing or removing software packages.
+ .
+ This package provides the Python 3 modules required to run aptdaemon
+ and to implement a client. The API is not stable yet.
+
+
 Package: python-aptdaemon
 Architecture: all
 Section: python
-Depends: ${shlibs:Depends},
-         ${misc:Depends},
+Depends: ${misc:Depends},
          ${python:Depends},
-         python-apt (>= 0.7.96.1ubuntu9),
+         python-apt (>= 0.8.5~ubuntu1),
          python-debian,
          python-defer,
          python-dbus,
          python-gi,
          gir1.2-glib-2.0,
          python-pkg-resources,
-         python-software-properties,
-         policykit-1
 Recommends: aptdaemon
-XB-Python-Version: ${python:Versions}
-Description: Python module for the server and client of aptdaemon
+Description: Python 2 module for the server and client of aptdaemon
  Aptdaemon is a transaction based package management service. It allows 
  normal users to perform package management tasks, e.g. refreshing the 
  cache, upgrading the system, installing or removing software packages.
  .
- This package provides the Python modules required to run aptdaemon
+ This package provides the Python 2 modules required to run aptdaemon
  and to implement a client. The API is not stable yet.
 
-Package: python-aptdaemon.test
+Package: python3-aptdaemon.test
 Architecture: all
 Section: python
-Depends: ${shlibs:Depends},
-         ${misc:Depends},
-         ${python:Depends},
-         python-aptdaemon (= ${binary:Version}),
-XB-Python-Version: ${python:Versions}
+Depends: ${misc:Depends},
+         ${python3:Depends},
+         python3-aptdaemon (= ${binary:Version}),
 Description: Test environment for aptdaemon clients
  Aptdaemon is a transaction based package management daemon. It allows 
  normal users to perform package management tasks, e.g. refreshing the 
@@ -98,8 +128,7 @@
 
 Package: aptdaemon-data
 Architecture: all
-Depends: ${shlibs:Depends},
-         ${misc:Depends}
+Depends: ${misc:Depends}
 Replaces: python-aptdaemon-gtk (<= 0.41+bzr580-0ubuntu1)
 Description: data files for clients
  Aptdaemon is a transaction based package management daemon. It allows 
@@ -112,12 +141,10 @@
 Package: python-aptdaemon-gtk
 Architecture: all
 Section: python
-Depends: ${shlibs:Depends},
-         ${misc:Depends},
+Depends: ${misc:Depends},
          ${python:Depends},
          python-aptdaemon.gtkwidgets (= ${binary:Version}),
          python-aptdaemon.gtk3widgets (= ${binary:Version})
-XB-Python-Version: ${python:Versions}
 Description: Transitional dummy package
  Aptdaemon is a transaction based package management daemon. It allows 
  normal users to perform package management tasks, e.g. refreshing the 
@@ -129,16 +156,16 @@
  .
  You can remove it safely.
 
-Package: python-aptdaemon.pkcompat
+Package: python3-aptdaemon.pkcompat
 Architecture: all
 Section: python
-Depends: ${shlibs:Depends},
-         ${misc:Depends},
-         ${python:Depends},
-         python-aptdaemon (= ${binary:Version}),
-         python-packagekit,
-Conflicts: packagekit
-XB-Python-Version: ${python:Versions}
+Depends: ${misc:Depends},
+         ${python3:Depends},
+         python3-aptdaemon (= ${binary:Version}),
+Provides: packagekit-system-interface
+Conflicts: packagekit,
+           python-aptdaemon.pkcompat,
+Replaces: python-aptdaemon.pkcompat
 Description: PackageKit compatibilty for AptDaemon
  Aptdaemon is a transaction based package management daemon. It allows 
  normal users to perform package management tasks, e.g. refreshing the 
@@ -149,8 +176,7 @@
 Package: python-aptdaemon.gtkwidgets
 Architecture: all
 Section: python
-Depends: ${shlibs:Depends},
-         ${misc:Depends},
+Depends: ${misc:Depends},
          ${python:Depends},
          python-aptdaemon (= ${binary:Version}),
          python-gtk2,
@@ -158,7 +184,6 @@
          aptdaemon-data
 Conflicts: python-aptdaemon-gtk (<< 0.41+bzr582-0ubuntu1)
 Replaces: python-aptdaemon-gtk (<< 0.41+bzr582-0ubuntu1)
-XB-Python-Version: ${python:Versions}
 Description: Python GTK+ 2 widgets to run an aptdaemon client
  Aptdaemon is a transaction based package management daemon. It allows 
  normal users to perform package management tasks, e.g. refreshing the 
@@ -168,12 +193,32 @@
  graphical client. The widgets can be used to initiate, to monitor and
  to control a transaction. The API is not stable yet.
 
+Package: python3-aptdaemon.gtk3widgets
+Architecture: all
+Section: python
+Depends: ${misc:Depends},
+         ${python3:Depends},
+         python3-aptdaemon (= ${binary:Version}),
+         python3-gi,
+         gir1.2-gtk-3.0,
+         gir1.2-vte-2.90,
+         aptdaemon-data
+Conflicts: python-aptdaemon-gtk (<< 0.41+bzr582-0ubuntu1)
+Replaces: python-aptdaemon-gtk (<< 0.41+bzr582-0ubuntu1)
+Description: Python 3 GTK+ 3 widgets to run an aptdaemon client
+ Aptdaemon is a transaction based package management daemon. It allows 
+ normal users to perform package management tasks, e.g. refreshing the 
+ cache, upgrading the system, installing or removing software packages.
+ .
+ This package provides the Python 3 GTK+ 3 widgets to implement a fully
+ working graphical client. The widgets can be used to initiate, to
+ monitor and to control a transaction. The API is not stable yet.
+
 Package: python-aptdaemon.gtk3widgets
 Architecture: all
 Section: python
-Depends: ${shlibs:Depends},
-         ${misc:Depends},
-         ${python:Depends},
+Depends: ${misc:Depends},
+         ${python3:Depends},
          python-aptdaemon (= ${binary:Version}),
          python-gi,
          gir1.2-gtk-3.0,
@@ -181,12 +226,11 @@
          aptdaemon-data
 Conflicts: python-aptdaemon-gtk (<< 0.41+bzr582-0ubuntu1)
 Replaces: python-aptdaemon-gtk (<< 0.41+bzr582-0ubuntu1)
-XB-Python-Version: ${python:Versions}
-Description: Python GTK+ 3 widgets to run an aptdaemon client
+Description: Python 2 GTK+ 3 widgets to run an aptdaemon client
  Aptdaemon is a transaction based package management daemon. It allows 
  normal users to perform package management tasks, e.g. refreshing the 
  cache, upgrading the system, installing or removing software packages.
  .
- This package provides the Python GTK+ 3 widgets to implement a fully
+ This package provides the Python 2 GTK+ 3 widgets to implement a fully
  working graphical client. The widgets can be used to initiate, to
  monitor and to control a transaction. The API is not stable yet.

=== added file 'debian/patches/disable_simulate_test.patch'
--- debian/patches/disable_simulate_test.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/disable_simulate_test.patch	2012-06-13 16:29:18 +0000
@@ -0,0 +1,12 @@
+=== modified file 'tests/test_simulate.py'
+--- old/tests/test_simulate.py	2012-03-19 07:58:34 +0000
++++ new/tests/test_simulate.py	2012-06-04 11:06:46 +0000
+@@ -25,6 +25,7 @@
+     def setUp(self):
+         """Setup a chroot, run the aptdaemon and a fake PolicyKit daemon."""
+         # Setup chroot
++        self.skipTest("Temporarily disabled")
+         self.chroot = aptdaemon.test.Chroot()
+         self.chroot.setup()
+         self.addCleanup(self.chroot.remove)
+

=== modified file 'debian/patches/series'
--- debian/patches/series	2011-12-15 10:15:46 +0000
+++ debian/patches/series	2012-06-13 16:29:18 +0000
@@ -0,0 +1,2 @@
+disable_simulate_test.patch
+test-suite-fixes

=== added file 'debian/patches/test-suite-fixes'
--- debian/patches/test-suite-fixes	1970-01-01 00:00:00 +0000
+++ debian/patches/test-suite-fixes	2012-06-13 16:29:18 +0000
@@ -0,0 +1,53 @@
+Description: fixes for the test suite
+ fixes against upstream bzr to make the test suite work on quantal, with
+ python2+python3:
+   aptdaemon/test.py: explicitly set the chroot directory in the apt config
+   as part of the test setup, without which apt-key's chroot handling won't
+   work.
+   test/test_pk.py: increase the sleep on startup, to allow longer for
+   fake-polkitd to connect to dbus.
+   aptdaemon/worker.py: restore compatibility with python2, which doesn't
+   have urllib.parse.
+Author: Steve Langasek <[e-mail]>
+
+Index: trunk/aptdaemon/test.py
+===================================================================
+--- trunk.orig/aptdaemon/test.py
++++ trunk/aptdaemon/test.py
+@@ -79,6 +79,7 @@
+             cnf.write("Dir::Bin::Apt-Key %s;" % apt_key_wrapper)
+         apt_pkg.read_config_file(apt_pkg.config, config_path)
+         apt_pkg.init_system()
++        apt_pkg.config["Dir"] = self.path
+ 
+     def remove(self):
+         """Remove the files of the chroot."""
+Index: trunk/aptdaemon/worker.py
+===================================================================
+--- trunk.orig/aptdaemon/worker.py
++++ trunk/aptdaemon/worker.py
+@@ -31,7 +31,10 @@
+ import tempfile
+ import time
+ import traceback
+-from urllib.parse import urlsplit, urlunsplit
++try:
++	from urllib.parse import urlsplit, urlunsplit
++except ImportError:
++	from urlparse import urlsplit, urlunsplit
+ 
+ import apt
+ import apt.auth
+Index: trunk/tests/test_pk.py
+===================================================================
+--- trunk.orig/tests/test_pk.py
++++ trunk/tests/test_pk.py
+@@ -66,7 +66,7 @@
+         self.start_session_aptd(self.chroot.path)
+         # Start the fake PolikcyKit daemon
+         self.start_fake_polkitd()
+-        time.sleep(0.5)
++        time.sleep(2.5)
+ 
+     def tearDown(self):
+         shutil.rmtree(self.workdir)

=== modified file 'debian/python-aptdaemon.pkcompat.install'
--- debian/python-aptdaemon.pkcompat.install	2011-11-21 10:08:24 +0000
+++ debian/python-aptdaemon.pkcompat.install	2012-06-13 16:29:18 +0000
@@ -1,3 +1,4 @@
-usr/lib/python2.*/*-packages/aptdaemon/pkcompat.py
+usr/lib/python3*/*-packages/aptdaemon/pkcompat.py
+usr/lib/python3*/*-packages/aptdaemon/pkenums.py
 usr/share/dbus-1/system-services/org.freedesktop.PackageKit.service
 etc/dbus-1/system.d/org.freedesktop.PackageKit-aptd.conf

=== modified file 'debian/python-aptdaemon.test.install'
--- debian/python-aptdaemon.test.install	2012-05-23 12:53:16 +0000
+++ debian/python-aptdaemon.test.install	2012-06-13 16:29:18 +0000
@@ -1,4 +1,4 @@
-usr/lib/python2.*/*-packages/aptdaemon/test.py
+usr/lib/python3*/*-packages/aptdaemon/test.py
 tests/repo/glatzor.gpg /usr/share/aptdaemon/tests/repo/
 tests/repo/gstreamer0.10-silly_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
 tests/repo/Packages /usr/share/aptdaemon/tests/repo/

=== added file 'debian/python3-aptdaemon.gtk3widgets.examples'
--- debian/python3-aptdaemon.gtk3widgets.examples	1970-01-01 00:00:00 +0000
+++ debian/python3-aptdaemon.gtk3widgets.examples	2012-06-13 16:29:18 +0000
@@ -0,0 +1,1 @@
+gtk3-demo.py

=== added file 'debian/python3-aptdaemon.gtk3widgets.install'
--- debian/python3-aptdaemon.gtk3widgets.install	1970-01-01 00:00:00 +0000
+++ debian/python3-aptdaemon.gtk3widgets.install	2012-06-13 16:29:18 +0000
@@ -0,0 +1,1 @@
+usr/lib/python3*/*-packages/aptdaemon/gtk3widgets.py

=== added file 'debian/python3-aptdaemon.install'
--- debian/python3-aptdaemon.install	1970-01-01 00:00:00 +0000
+++ debian/python3-aptdaemon.install	2012-06-13 16:29:18 +0000
@@ -0,0 +1,16 @@
+usr/lib/python3*/*-packages/aptdaemon/__init__.py
+usr/lib/python3*/*-packages/aptdaemon/client.py
+usr/lib/python3*/*-packages/aptdaemon/config.py
+usr/lib/python3*/*-packages/aptdaemon/console.py
+usr/lib/python3*/*-packages/aptdaemon/core.py
+usr/lib/python3*/*-packages/aptdaemon/crash.py
+usr/lib/python3*/*-packages/aptdaemon/debconf.py
+usr/lib/python3*/*-packages/aptdaemon/enums.py
+usr/lib/python3*/*-packages/aptdaemon/errors.py
+usr/lib/python3*/*-packages/aptdaemon/loop.py
+usr/lib/python3*/*-packages/aptdaemon/lock.py
+usr/lib/python3*/*-packages/aptdaemon/networking.py
+usr/lib/python3*/*-packages/aptdaemon/policykit1.py
+usr/lib/python3*/*-packages/aptdaemon/progress.py
+usr/lib/python3*/*-packages/aptdaemon/utils.py
+usr/lib/python3*/*-packages/aptdaemon/worker.py

=== added file 'debian/python3-aptdaemon.pkcompat.docs'
--- debian/python3-aptdaemon.pkcompat.docs	1970-01-01 00:00:00 +0000
+++ debian/python3-aptdaemon.pkcompat.docs	2012-06-13 16:29:18 +0000
@@ -0,0 +1,1 @@
+README.PackageKit

=== added file 'debian/python3-aptdaemon.pkcompat.install'
--- debian/python3-aptdaemon.pkcompat.install	1970-01-01 00:00:00 +0000
+++ debian/python3-aptdaemon.pkcompat.install	2012-06-13 16:29:18 +0000
@@ -0,0 +1,4 @@
+usr/lib/python3*/*-packages/aptdaemon/pkcompat.py
+usr/lib/python3*/*-packages/aptdaemon/pkenums.py
+usr/share/dbus-1/system-services/org.freedesktop.PackageKit.service
+etc/dbus-1/system.d/org.freedesktop.PackageKit-aptd.conf

=== added file 'debian/python3-aptdaemon.test.examples'
--- debian/python3-aptdaemon.test.examples	1970-01-01 00:00:00 +0000
+++ debian/python3-aptdaemon.test.examples	2012-06-13 16:29:18 +0000
@@ -0,0 +1,1 @@
+tests/test_client.py

=== added file 'debian/python3-aptdaemon.test.install'
--- debian/python3-aptdaemon.test.install	1970-01-01 00:00:00 +0000
+++ debian/python3-aptdaemon.test.install	2012-06-13 16:29:18 +0000
@@ -0,0 +1,18 @@
+usr/lib/python3*/*-packages/aptdaemon/test.py
+tests/repo/glatzor.gpg /usr/share/aptdaemon/tests/repo/
+tests/repo/gstreamer0.10-silly_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/Packages /usr/share/aptdaemon/tests/repo/
+tests/repo/Release /usr/share/aptdaemon/tests/repo/
+tests/repo/Release.gpg /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-base_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-base_0.1-0update1_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-broken_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-config_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-depend-base_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-essential_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-fail_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-important_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/repo/silly-postinst-input_0.1-0_all.deb /usr/share/aptdaemon/tests/repo/
+tests/dpkg-wrapper.sh /usr/share/aptdaemon/tests/
+tests/fake-polkitd.py /usr/share/aptdaemon/tests/
+tests/dbus.conf /usr/share/aptdaemon/tests/

=== modified file 'debian/rules'
--- debian/rules	2011-11-21 10:08:24 +0000
+++ debian/rules	2012-06-13 16:29:18 +0000
@@ -1,12 +1,32 @@
 #!/usr/bin/make -f
 
+#DH_VERBOSE=1
+
+PYTHON2=$(shell pyversions -vr)
+PYTHON3=$(shell py3versions -vr)
+
 %:
-	dh --with=python2,translations $@
+	dh $@ --with=python2,python3,translations
+
+build-python%:
+	python$* setup.py build
+
+override_dh_auto_build: $(PYTHON3:%=build-python%)
+	dh_auto_build
+
+install-python%:
+	python$* setup.py install --root=$(CURDIR)/debian/tmp --install-layout=deb
+
+override_dh_auto_install: $(PYTHON3:%=install-python%)
+	dh_auto_install
 
 override_dh_auto_clean:
 	dh_auto_clean
 	rm -rf build *.egg-info po/aptdaemon.pot
 
-# mvo: disabled temporarely, see changelog for 0.41+bzr586-0ubuntu1
-#override_dh_auto_test:
-#	unit2 discover
+ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
+test-python%:
+	python$* setup.py test -vv
+
+override_dh_auto_test: $(PYTHON3:%=test-python%) $(PYTHON2:%=test-python%)
+endif

=== added file 'doc/source/aptdaemon.gtk3widgets.rst'
--- doc/source/aptdaemon.gtk3widgets.rst	1970-01-01 00:00:00 +0000
+++ doc/source/aptdaemon.gtk3widgets.rst	2012-06-13 16:29:18 +0000
@@ -0,0 +1,5 @@
+:mod:`aptdaemon.gtk3widgets` --- The gtk3widgets module
+=====================================================
+
+.. automodule:: aptdaemon.gtk3widgets
+    :members:

=== removed file 'doc/source/aptdaemon.gtkwidgets.rst'
--- doc/source/aptdaemon.gtkwidgets.rst	2011-11-21 10:08:24 +0000
+++ doc/source/aptdaemon.gtkwidgets.rst	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-:mod:`aptdaemon.gtkwidgets` --- The gtkwidgets module
-=====================================================
-
-.. automodule:: aptdaemon.gtkwidgets
-    :members:

=== modified file 'doc/source/index.rst'
--- doc/source/index.rst	2011-11-21 10:08:24 +0000
+++ doc/source/index.rst	2012-06-13 16:29:18 +0000
@@ -8,7 +8,7 @@
 
    aptdaemon.client
    aptdaemon.enums
-   aptdaemon.gtkwidgets
+   aptdaemon.gtk3widgets
 
    dbus
    plugins

=== modified file 'gtk-demo.py'
--- gtk-demo.py	2011-12-01 14:40:52 +0000
+++ gtk-demo.py	2012-06-13 16:29:18 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 # -*- coding: utf-8 -*-
 """
 Provides a graphical demo application for aptdaemon

=== modified file 'gtk3-demo.py'
--- gtk3-demo.py	2011-12-01 14:40:52 +0000
+++ gtk3-demo.py	2012-06-13 16:29:18 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 """
 Provides a graphical demo application for aptdaemon
@@ -66,14 +66,11 @@
         self._run_transaction(trans)
 
     def _on_error(self, error):
-        try:
-            raise error
-        except aptdaemon.errors.NotAuthorizedError:
+        if isinstance(error, aptdaemon.errors.NotAuthorizedError):
             # Silently ignore auth failures
             return
-        except aptdaemon.errors.TransactionFailed as error:
-            pass
-        except Exception as error:
+        elif not isinstance(error, aptdaemon.errors.TransactionFailed):
+            # Catch internal errors of the client
             error = aptdaemon.errors.TransactionFailed(ERROR_UNKNOWN,
                                                        str(error))
         dia = AptErrorDialog(error)

=== modified file 'po/af.po'
--- po/af.po	2011-11-21 10:08:24 +0000
+++ po/af.po	2012-06-13 16:29:18 +0000
@@ -7,499 +7,585 @@
 msgstr ""
 "Project-Id-Version: aptdaemon\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
-"POT-Creation-Date: 2010-09-27 21:46+0000\n"
-"PO-Revision-Date: 2010-07-26 09:31+0000\n"
+"POT-Creation-Date: 2012-04-10 15:24+0000\n"
+"PO-Revision-Date: 2011-01-16 11:40+0000\n"
 "Last-Translator: Michael Vogt <[e-mail]>\n"
 "Language-Team: Afrikaans <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
-"X-Launchpad-Export-Date: 2010-09-28 16:44+0000\n"
-"X-Generator: Launchpad (build Unknown)\n"
-
-#. This privilege allows to call AddRepository, UpdateCache(Partially)
-#. and InstallPackages in a row and only authenticating once.
-#. 
-#. The client has to authenticate for this privilege before calling
-#. the aptdaemon methods.
+"X-Launchpad-Export-Date: 2012-05-26 09:08+0000\n"
+"X-Generator: Launchpad (build 15288)\n"
+
+#: ../data/org.debian.apt.policy.in.h:1
+msgid "List keys of trusted vendors"
+msgstr ""
+
+#: ../data/org.debian.apt.policy.in.h:2
+msgid "To view the list of trusted keys, you need to authenticate."
+msgstr ""
+
+#: ../data/org.debian.apt.policy.in.h:3 ../aptdaemon/console.py:607
+msgid "Remove downloaded package files"
+msgstr ""
+
+#: ../data/org.debian.apt.policy.in.h:4
+msgid "To clean downloaded package files, you need to authenticate."
+msgstr ""
+
+#: ../data/org.debian.apt.policy.in.h:5
+msgid "Change software configuration"
+msgstr ""
+
 #: ../data/org.debian.apt.policy.in.h:6
-msgid "Add a new repository and install packages from it"
-msgstr ""
-
-#. This privilege allows to call AddRepository, UpdateCache(Partially)
-#. and InstallPackages in a row and only authenticating once.
-#. 
-#. The client has to authenticate for this privilege before calling
-#. the aptdaemon methods.
-#. 
-#. The only difference to install-packages-from-new-repo is the wording
-#. of the message. It is required by Ubuntu's Software-Center.
-#: ../data/org.debian.apt.policy.in.h:15
-msgid ""
-"Add a new repository of purchased software and install packages from it"
-msgstr ""
-
-#: ../data/org.debian.apt.policy.in.h:16
-msgid "Cancel the task of another user"
-msgstr "Kanselleer die taak van 'n ander gebruiker"
-
-#: ../data/org.debian.apt.policy.in.h:17
+msgid "To change software settings, you need to authenticate."
+msgstr ""
+
+#: ../data/org.debian.apt.policy.in.h:7
 msgid "Change software repository"
 msgstr ""
 
-#: ../data/org.debian.apt.policy.in.h:18
-msgid "Install or remove packages"
+#: ../data/org.debian.apt.policy.in.h:8
+msgid "To change software repository settings, you need to authenticate."
 msgstr ""
 
-#: ../data/org.debian.apt.policy.in.h:19
+#: ../data/org.debian.apt.policy.in.h:9
 msgid "Install package file"
 msgstr "Installeer pakketlêer"
 
+#: ../data/org.debian.apt.policy.in.h:10
+msgid "To install this package, you need to authenticate."
+msgstr ""
+
+#: ../data/org.debian.apt.policy.in.h:11
+msgid "Update package information"
+msgstr "Opdateer pakketinformasie"
+
+#: ../data/org.debian.apt.policy.in.h:12
+msgid "To update the software catalog, you need to authenticate."
+msgstr ""
+
+#: ../data/org.debian.apt.policy.in.h:13
+msgid "Install or remove packages"
+msgstr ""
+
+#: ../data/org.debian.apt.policy.in.h:14
+msgid "To install or remove software, you need to authenticate."
+msgstr ""
+
+#. This privilege allows to call AddRepository, UpdateCache(Partially)
+#. and InstallPackages in a row and only authenticating once.
+#. 
+#. The client has to authenticate for this privilege before calling
+#. the aptdaemon methods.
 #: ../data/org.debian.apt.policy.in.h:20
-msgid "List keys of trusted vendors"
+msgid "Add a new repository and install packages from it"
 msgstr ""
 
 #: ../data/org.debian.apt.policy.in.h:21
-msgid "Set a proxy for software downloads"
-msgstr ""
-
-#: ../data/org.debian.apt.policy.in.h:22
-msgid "To cancel someone else's software changes, you need to authenticate."
-msgstr ""
-
-#: ../data/org.debian.apt.policy.in.h:23
-msgid "To change software repository settings, you need to authenticate."
-msgstr ""
-
-#: ../data/org.debian.apt.policy.in.h:24