Libertine

Merge lp:~larryprice/libertine/libertine-service into lp:libertine

libertine-service
Merge into devel

Proposed by Larry Price on 2016-11-01

Status:

Merged

Approved by:

Christopher Townsend on 2016-11-16

Approved revision:

372

Merged at revision:

334

Proposed branch:

lp:~larryprice/libertine/libertine-service

Merge into:

lp:libertine

Diff against target:

2873 lines (+2532/-14)

46 files modified

data/CMakeLists.txt (+1/-1)
data/com.canonical.libertine.ContainerManager.service (+3/-0)
debian/libertine-tools.install (+2/-0)
debian/python3-libertine.install (+1/-0)
python/libertine/ChrootContainer.py (+3/-1)
python/libertine/ContainersConfig.py (+7/-5)
python/libertine/HostInfo.py (+1/-1)
python/libertine/Libertine.py (+1/-1)
python/libertine/LxcContainer.py (+6/-3)
python/libertine/service/apt.py (+77/-0)
python/libertine/service/container.py (+139/-0)
python/libertine/service/manager.py (+115/-0)
python/libertine/service/progress.py (+83/-0)
python/libertine/service/task_dispatcher.py (+114/-0)
python/libertine/service/tasks/__init__.py (+39/-0)
python/libertine/service/tasks/app_info_task.py (+35/-0)
python/libertine/service/tasks/base_task.py (+94/-0)
python/libertine/service/tasks/container_info_task.py (+29/-0)
python/libertine/service/tasks/create_task.py (+72/-0)
python/libertine/service/tasks/destroy_task.py (+42/-0)
python/libertine/service/tasks/install_task.py (+49/-0)
python/libertine/service/tasks/list_apps_task.py (+30/-0)
python/libertine/service/tasks/list_task.py (+25/-0)
python/libertine/service/tasks/remove_task.py (+48/-0)
python/libertine/service/tasks/search_task.py (+27/-0)
python/libertine/service/tasks/update_task.py (+39/-0)
tests/unit/CMakeLists.txt (+1/-0)
tests/unit/pytest.ini (+2/-0)
tests/unit/service/CMakeLists.txt (+12/-0)
tests/unit/service/tasks/CMakeLists.txt (+10/-0)
tests/unit/service/tasks/test_app_info_task.py (+61/-0)
tests/unit/service/tasks/test_container_info_task.py (+44/-0)
tests/unit/service/tasks/test_create_task.py (+234/-0)
tests/unit/service/tasks/test_destroy_task.py (+80/-0)
tests/unit/service/tasks/test_install_task.py (+76/-0)
tests/unit/service/tasks/test_list_apps_task.py (+59/-0)
tests/unit/service/tasks/test_list_task.py (+45/-0)
tests/unit/service/tasks/test_remove_task.py (+76/-0)
tests/unit/service/tasks/test_search_task.py (+43/-0)
tests/unit/service/tasks/test_update_task.py (+80/-0)
tests/unit/service/test_apt.py (+134/-0)
tests/unit/service/test_container.py (+202/-0)
tests/unit/service/test_task_dispatcher.py (+148/-0)
tools/CMakeLists.txt (+1/-1)
tools/libertine-container-manager (+1/-1)
tools/libertined (+141/-0)

To merge this branch:

bzr merge lp:~larryprice/libertine/libertine-service

Medium

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Christopher Townsend		2016-11-01	Approve on 2016-11-16
Libertine CI Bot	continuous-integration		Approve on 2016-11-16
Review via email: mp+309794@code.launchpad.net

Commit message

Initial implementation of a libertine d-bus service.

Description of the change

Initial implementation of a libertine d-bus service.

How do it work? Every command is asynchronous. After making a call to the service, you'll get an object path back. You can listen on that object path for incoming data or listen for the task to finish with finished (success) or error (failure). It currently emits a processing signal every .5 seconds to let things like the Scopes SDK know there is an ongoing process, but we might want to consider removing this if we don't plan to be used by a specific scope.

What's not implemented? All things configure, fix-integrity, exec, merge. There is currently no way to get output directly from the running command (such as install/remove/create information). It would probably be a good idea to create an integration test which demonstrates how to use the service.

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-03:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/197/rebuild

review: Needs Fixing (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-03

356. By Larry Price on 2016-11-03: Merge
357. By Larry Price on 2016-11-03: attempt to get this file in
358. By Larry Price on 2016-11-03: checkpoint

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-03:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/200/rebuild

review: Needs Fixing (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-03

359. By Larry Price on 2016-11-03: trying to fix test_task_dispatcher

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-03:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/201/rebuild

review: Needs Fixing (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-04

360. By Larry Price on 2016-11-04: Removed appstream (find it at lp:~larryprice/+junk/libertine-service-with-appstream)

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-04:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/202/rebuild

review: Needs Fixing (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-04

361. By Larry Price on 2016-11-04: Restructure checking task equality for the sake of vivid

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-04:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/203/rebuild

review: Needs Fixing (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-04

362. By Larry Price on 2016-11-04: use a real function instead of a magic function to test fuzzy equality

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-04:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/204/rebuild

review: Approve (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-04

363. By Larry Price on 2016-11-04: Merge

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-04:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/205/rebuild

review: Approve (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-07

364. By Larry Price on 2016-11-07: Update for status reporting and delayed callback

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-07:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/206/rebuild

review: Approve (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-07

365. By Larry Price on 2016-11-07: address minor threading issues

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-07:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/207/rebuild

review: Approve (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-07

366. By Larry Price on 2016-11-07: update task retrieval

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-07:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/208/rebuild

review: Approve (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-08

367. By Larry Price on 2016-11-08: upstreaming changes from integration branch
368. By Larry Price on 2016-11-08: fixing all the things
369. By Larry Price on 2016-11-08: stop double-running tests

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-08:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/209/rebuild

review: Approve (continuous-integration)

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-08:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/210/rebuild

review: Approve (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-08

370. By Larry Price on 2016-11-08: upstreaming changes from integration tests

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-08:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/211/rebuild

review: Approve (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-10

371. By Larry Price on 2016-11-10: remove unused appstream dep

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-10:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/227/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-10:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/228/rebuild

review: Approve (continuous-integration)

lp:~larryprice/libertine/libertine-service updated on 2016-11-16

372. By Larry Price on 2016-11-16: merge

Revision history for this message

Libertine CI Bot (libertine-ci-bot) wrote on 2016-11-16:

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/233/rebuild

review: Approve (continuous-integration)

Revision history for this message

Christopher Townsend (townsend) wrote on 2016-11-16:

Ok, let's get this in:)

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Larry Price

Libertine Developers

 === modified file 'data/CMakeLists.txt'
 --- data/CMakeLists.txt	2016-10-07 18:58:30 +0000
 +++ data/CMakeLists.txt	2016-11-16 17:34:14 +0000
@@ -8,7 +8,7 @@
          DESTINATION ${CMAKE_INSTALL_DATADIR}/upstart/sessions)
  install(FILES libertine-lxc-sudo
          DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/sudoers.d)
--install(FILES com.canonical.libertine.LxcManager.service
++install(FILES com.canonical.libertine.LxcManager.service com.canonical.libertine.ContainerManager.service
          DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services)
  configure_file("python3-libertine-chroot.click-hook.in"
 === added file 'data/com.canonical.libertine.ContainerManager.service'
 --- data/com.canonical.libertine.ContainerManager.service	1970-01-01 00:00:00 +0000
 +++ data/com.canonical.libertine.ContainerManager.service	2016-11-16 17:34:14 +0000
@@ -0,0 +1,3 @@
++[D-BUS Service]
++Name=com.canonical.libertine.ContainerManager
++Exec=/usr/bin/libertined --cache-output
 === modified file 'debian/libertine-tools.install'
 --- debian/libertine-tools.install	2016-10-26 20:48:08 +0000
 +++ debian/libertine-tools.install	2016-11-16 17:34:14 +0000
@@ -1,4 +1,6 @@
  usr/bin/libertine-container-manager
  usr/bin/libertine-launch
++usr/bin/libertined
++usr/share/dbus-1/services/com.canonical.libertine.ContainerManager.service
  usr/share/bash-completion/completions/libertine-container-manager
  usr/share/man
 === modified file 'debian/python3-libertine.install'
 --- debian/python3-libertine.install	2016-10-13 18:28:34 +0000
 +++ debian/python3-libertine.install	2016-11-16 17:34:14 +0000
@@ -4,4 +4,5 @@
  usr/lib/python*/*/libertine/Libertine.py
  usr/lib/python*/*/libertine/__init__.py
  usr/lib/python*/*/libertine/launcher
++usr/lib/python*/*/libertine/service
  usr/lib/python*/*/libertine/utils.py
 === modified file 'python/libertine/ChrootContainer.py'
 --- python/libertine/ChrootContainer.py	2016-11-16 16:38:16 +0000
 +++ python/libertine/ChrootContainer.py	2016-11-16 17:34:14 +0000
@@ -64,8 +64,10 @@
          container_root = os.path.join(utils.get_libertine_containers_dir_path(), self.container_id)
          try:
              shutil.rmtree(container_root)
++            return True
          except Exception as e:
              print("%s" % e)
++            return False
      def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
          # Create the actual chroot
@@ -147,7 +149,7 @@
      def update_packages(self, verbosity=1):
          retcode = super().update_packages(verbosity)
          self._run_ldconfig(verbosity)
--        return retcode
++        return retcode == 0
      def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
          returncode = super().install_package(package_name, verbosity, no_dialog, update_cache)
 === modified file 'python/libertine/ContainersConfig.py'
 --- python/libertine/ContainersConfig.py	2016-11-09 18:25:33 +0000
 +++ python/libertine/ContainersConfig.py	2016-11-16 17:34:14 +0000
@@ -28,6 +28,7 @@
      if (os.path.exists(container_config_file) and
          os.path.getsize(container_config_file) != 0):
          with open(container_config_file, 'r') as fd:
++            fcntl.flock(fd, fcntl.LOCK_EX)
              container_list = json.load(fd)
      return container_list
@@ -41,18 +42,18 @@
          container_list["_warning"] = "This file is automatically generated by Libertine and should not be manually edited."
      with open(container_config_file, 'w') as fd:
--        fcntl.lockf(fd, fcntl.LOCK_EX)
++        fcntl.flock(fd, fcntl.LOCK_EX)
          json.dump(container_list, fd, sort_keys=True, indent=4)
          fd.write('\n')
--        fcntl.lockf(fd, fcntl.LOCK_UN)
  def container_config_hash():
      checksum = md5()
      container_config_file = libertine.utils.get_libertine_database_file_path()
      if (os.path.exists(container_config_file) and os.path.getsize(container_config_file) != 0):
--        with open(container_config_file, "rb") as f:
--            for chunk in iter(lambda: f.read(128 * checksum.block_size), b""):
++        with open(container_config_file, "rb") as fd:
++            fcntl.flock(fd, fcntl.LOCK_EX)
++            for chunk in iter(lambda: fd.read(128 * checksum.block_size), b""):
                  checksum.update(chunk)
      return checksum.hexdigest()
@@ -90,7 +91,8 @@
              return container[key]
      def _get_array_object_value_by_key(self, container_id, array_key, object_key, matcher, key):
--        for item in self._get_value_by_key(container_id, array_key):
++        items = self._get_value_by_key(container_id, array_key) or []
++        for item in items:
              if item[object_key] == matcher:
                  return item[key]
 === modified file 'python/libertine/HostInfo.py'
 --- python/libertine/HostInfo.py	2016-07-07 20:00:10 +0000
 +++ python/libertine/HostInfo.py	2016-11-16 17:34:14 +0000
@@ -36,7 +36,7 @@
          return distinfo.get('CODENAME', 'n/a')
--    def is_distro_valid(self, distro, force):
++    def is_distro_valid(self, distro, force=False):
          if force:
              return UbuntuDistroInfo().valid(distro)
 === modified file 'python/libertine/Libertine.py'
 --- python/libertine/Libertine.py	2016-11-10 16:36:05 +0000
 +++ python/libertine/Libertine.py	2016-11-16 17:34:14 +0000
@@ -166,7 +166,7 @@
          :param verbosity: the chattiness of the output on a range from 0 to 2
          """
          self.update_apt_cache(verbosity)
--        return self.run_in_container(apt_command_prefix(verbosity) + '--force-yes dist-upgrade')
++        return self.run_in_container(apt_command_prefix(verbosity) + '--force-yes dist-upgrade') == 0
      def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
          """
 === modified file 'python/libertine/LxcContainer.py'
 --- python/libertine/LxcContainer.py	2016-11-10 20:43:40 +0000
 +++ python/libertine/LxcContainer.py	2016-11-16 17:34:14 +0000
@@ -199,9 +199,12 @@
          return super().update_packages(verbosity)
      def destroy_libertine_container(self):
--        if self.container.defined:
--            self.container.stop()
--            self.container.destroy()
++        if not self.container.defined:
++            return False
++
++        self.container.stop()
++        self.container.destroy()
++        return True
      def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
          if password is None:
 === added directory 'python/libertine/service'
 === added file 'python/libertine/service/__init__.py'
 === added file 'python/libertine/service/apt.py'
 --- python/libertine/service/apt.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/apt.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,77 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++import apt
++import re
++
++import gi
++gi.require_version('Libertine', '1')
++from gi.repository import Libertine
++
++from libertine import utils
++from os import path
++from threading import Lock
++
++
++class AptCache(object):
++    """
++    Class to find app information using apt-cache
++    """
++    def __init__(self, container_id):
++        super(AptCache, self).__init__()
++        self._container = container_id
++        self._cache = None
++        self._lock = Lock()
++
++    def search(self, query):
++        self._load()
++
++        pkg_keys = [key for key in self._cache.keys() if re.match(query, key)]
++        apps = []
++        for key in pkg_keys:
++            apps.append(self._app_to_dict(key))
++        return apps
++
++    def app_info(self, app_id):
++        self._load()
++        return self._app_to_dict(app_id)
++
++    def _app_to_dict(self, app_id):
++        app_data = {}
++        if app_id in self._cache.keys():
++            app = self._cache[app_id]
++            app_data["name"] = app.name
++            app_data["id"] = app.name
++            app_data["package"] = app.name
++            if len(app.versions) > 0:
++                app_data["summary"] = app.versions[0].summary
++                app_data["website"] = app.versions[0].homepage
++                app_data["description"] = app.versions[0].description
++            app_data["package"] = app.name
++
++        return app_data
++
++    def _load(self):
++        with self._lock:
++            if self._cache is None:
++                try:
++                    utils.get_logger().debug("Trying aptcache for container %s" % self._container)
++                    container_path = Libertine.container_path(self._container)
++                    if not container_path or not path.exists(container_path):
++                        raise PermissionError
++
++                    self._cache = apt.Cache(rootdir=container_path)
++                except PermissionError:
++                    utils.get_logger().debug("Trying system aptcache")
++                    self._cache = apt.Cache()
 === added file 'python/libertine/service/container.py'
 --- python/libertine/service/container.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/container.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,139 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++from libertine.service.tasks import *
++from libertine import utils
++from libertine.service import apt
++
++
++class Container(object):
++    def __init__(self, container_id, config, lock, connection, callback):
++        self._id = container_id
++        self._connection = connection
++        self._callback = callback
++        self._config = config
++        self._lock = lock
++        self._tasks = []
++        self._cache = apt.AptCache(self.id)
++
++    def _cleanup_task(self, task):
++        utils.get_logger().debug("cleaning up tasks for container '%s'" % self.id)
++
++        if task in self._tasks:
++            self._tasks.remove(task)
++
++        if len(self._tasks) == 0:
++            self._callback(self)
++
++    @property
++    def id(self):
++        return self._id
++
++    @property
++    def tasks(self):
++        return [task.id for task in self._tasks if task.running]
++
++    def search(self, query):
++        utils.get_logger().debug("search container '%s' for package '%s'" % (self.id, query))
++
++        task = SearchTask(self.id, self._cache, query, self._connection, self._cleanup_task)
++        self._tasks.append(task)
++        task.start()
++
++        return task.id
++
++    def app_info(self, package_name):
++        utils.get_logger().debug("get info for package '%s' in container '%s'" % (package_name, self.id))
++
++        related_task_ids = [t.id for t in self._tasks if t.package == package_name and t.running]
++        task = AppInfoTask(self.id, self._cache, package_name, related_task_ids, self._config, self._connection, self._cleanup_task)
++
++        self._tasks.append(task)
++        task.start()
++        return task.id
++
++    def install(self, package_name):
++        utils.get_logger().debug("Install package '%s' from container '%s'" % (package_name, self.id))
++
++        tasks = [t for t in self._tasks if t.matches(package_name, InstallTask) and t.running]
++        if len(tasks) > 0:
++            utils.get_logger().debug("Install already in progress for '%s':'%s'" % (package_name, self.id))
++            return tasks[0].id
++
++        task = InstallTask(package_name, self.id, self._config, self._lock, self._connection, self._cleanup_task)
++        self._tasks.append(task)
++        task.start()
++        return task.id
++
++    def remove(self, package_name):
++        utils.get_logger().debug("Remove package '%s' from container '%s'" % (package_name, self.id))
++
++        tasks = [t for t in self._tasks if t.matches(package_name, RemoveTask) and t.running]
++        if len(tasks) > 0:
++            utils.get_logger().debug("Remove already in progress for '%s':'%s'" % (package_name, self.id))
++            return tasks[0].id
++
++        task = RemoveTask(package_name, self.id, self._config, self._lock, self._connection, self._cleanup_task)
++        self._tasks.append(task)
++        task.start()
++        return task.id
++
++    def create(self, container_name, distro, container_type, enable_multiarch):
++        utils.get_logger().debug("Create container with ID '%s'" % self.id)
++
++        tasks = [t for t in self._tasks if t.matches(self.id, CreateTask) and t.running]
++        if len(tasks) > 0:
++            utils.get_logger().debug("Create already in progress for '%s'" % self.id)
++            return tasks[0].id
++
++        task = CreateTask(self.id, container_name, distro, container_type, enable_multiarch,
++                          self._config, self._lock, self._connection, self._cleanup_task)
++        self._tasks.append(task)
++        task.start()
++        return task.id
++
++    def destroy(self):
++        utils.get_logger().debug("Destroy container with ID '%s'" % self.id)
++
++        tasks = [t for t in self._tasks if t.matches(self.id, DestroyTask) and t.running]
++        if len(tasks) > 0:
++            utils.get_logger().debug("Destroy already in progress for '%s'" % self.id)
++            return tasks[0].id
++
++        task = DestroyTask(self.id, self._config, self._lock, self._connection, self._cleanup_task)
++        self._tasks.append(task)
++        task.start()
++        return task.id
++
++    def update(self):
++        utils.get_logger().debug("Update container with ID '%s'" % self.id)
++
++        tasks = [t for t in self._tasks if t.matches(self.id, UpdateTask) and t.running]
++        if len(tasks) > 0:
++            utils.get_logger().debug("Update already in progress for '%s'" % self.id)
++            return tasks[0].id
++
++        task = UpdateTask(self.id, self._config, self._lock, self._connection, self._cleanup_task)
++        self._tasks.append(task)
++        task.start()
++        return task.id
++
++    def list_apps(self):
++        utils.get_logger().debug("List all apps in container '%s'" % self.id)
++
++        task = ListAppsTask(self.id, self._config, self._connection, self._cleanup_task)
++
++        self._tasks.append(task)
++        task.start()
++        return task.id
 === added file 'python/libertine/service/manager.py'
 --- python/libertine/service/manager.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/manager.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,115 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++import dbus
++import dbus.service
++import libertine.service.task_dispatcher
++from dbus.mainloop.glib import DBusGMainLoop
++from libertine.service import container
++from libertine import utils
++
++
++LIBERTINE_MANAGER_NAME = "com.canonical.libertine.Service"
++LIBERTINE_MANAGER_INTERFACE = LIBERTINE_MANAGER_NAME
++LIBERTINE_STORE_PATH = "/Manager"
++
++
++class Manager(dbus.service.Object):
++    def __init__(self):
++        utils.get_logger().debug("creating service")
++        DBusGMainLoop(set_as_default=True)
++        try:
++            bus_name = dbus.service.BusName(LIBERTINE_MANAGER_NAME,
++                                            bus=dbus.SessionBus(),
++                                            do_not_queue=True)
++        except dbus.exceptions.NameExistsException:
++            utils.get_logger().warning("service is already running")
++            raise
++
++        super().__init__(bus_name, LIBERTINE_STORE_PATH)
++
++        self._dispatcher = libertine.service.task_dispatcher.TaskDispatcher(self.connection)
++
++    # Information
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='ss',
++                         out_signature='o')
++    def search(self, container_id, search_string):
++        utils.get_logger().debug("search('{}', '{}') called".format(container_id, search_string))
++        return self._dispatcher.search(container_id, search_string)
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='ss',
++                         out_signature='o')
++    def app_info(self, container_id, app_id):
++        utils.get_logger().debug("app_info('{}', '{}') called".format(container_id, app_id))
++        return self._dispatcher.app_info(container_id, app_id)
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='s',
++                         out_signature='o')
++    def container_info(self, container_id):
++        utils.get_logger().debug("container_info('{}')".format(container_id))
++        return self._dispatcher.container_info(container_id)
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='s',
++                         out_signature='o')
++    def list_apps(self, container_id):
++        utils.get_logger().debug("list_apps('{}')".format(container_id))
++        return self._dispatcher.list_apps(container_id)
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         out_signature='o')
++    def list(self):
++        utils.get_logger().debug("list()")
++        return self._dispatcher.list()
++
++    # Operations
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='ssssb',
++                         out_signature='o')
++    def create(self, container_id, container_name='', distro='', container_type='', enable_multiarch=False):
++        utils.get_logger().debug("create('{}', '{}', '{}', '{}', '{}')".format(container_id, container_name, distro, container_type, enable_multiarch))
++        return self._dispatcher.create(container_id, container_name, distro, container_type, enable_multiarch)
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='s',
++                         out_signature='o')
++    def destroy(self, container_id):
++        utils.get_logger().debug("destroy('{}')".format(container_id))
++        return self._dispatcher.destroy(container_id)
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='s',
++                         out_signature='o')
++    def update(self, container_id):
++        utils.get_logger().debug("update('{}')".format(container_id))
++        return self._dispatcher.update(container_id)
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='ss',
++                         out_signature='o')
++    def install(self, container_id, package_name):
++        utils.get_logger().debug("install('%s', '%s')" % (container_id, package_name))
++        return self._dispatcher.install(container_id, package_name)
++
++    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
++                         in_signature='ss',
++                         out_signature='o')
++    def remove(self, container_id, package_name):
++        utils.get_logger().debug("remove('%s', '%s')" % (container_id, package_name))
++        return self._dispatcher.remove(container_id, package_name)
 === added file 'python/libertine/service/progress.py'
 --- python/libertine/service/progress.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/progress.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,83 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++import dbus.service
++import threading
++from libertine import utils
++from time import time
++
++DOWNLOAD_INTERFACE = "com.canonical.applications.Download"
++PROGRESS_INTERFACE = "com.canonical.libertine.Progress"
++
++class Progress(dbus.service.Object):
++    def __init__(self, connection):
++        utils.get_logger().debug("creating a Progress object")
++        self._finished = False
++        self._result = []
++        self._error = ''
++        dbus.service.Object.__init__(self, conn=connection, object_path=("/Progress/%s" % hex(int(time()*10000000))[2:]))
++
++        self.emit_processing()
++
++    @property
++    def id(self):
++        return self._object_path
++
++    def emit_processing(self):
++        if not self.done:
++            self.processing(self.id)
++            threading.Timer(0.5, self.emit_processing).start()
++
++    @property
++    def done(self):
++        return self._finished
++
++    @dbus.service.signal(DOWNLOAD_INTERFACE)
++    def processing(self, path):
++        utils.get_logger().debug("emit processing('%s')" % path)
++
++    @dbus.service.signal(DOWNLOAD_INTERFACE)
++    def finished(self, path):
++        utils.get_logger().debug("emit finished('%s')" % path)
++        self._finished = True
++
++    @dbus.service.signal(DOWNLOAD_INTERFACE)
++    def progress(self, received, total):
++        utils.get_logger().debug("emit progress(%d, %d)" % (received, total))
++
++    @dbus.service.signal(DOWNLOAD_INTERFACE)
++    def error(self, message):
++        utils.get_logger().error("emit error(%s)" % message)
++        self._error = message
++        self._finished = True
++
++    @dbus.service.signal(PROGRESS_INTERFACE)
++    def data(self, message):
++        utils.get_logger().debug("emit data(%s)" % message)
++        self._result.append(message)
++
++    @dbus.service.method(PROGRESS_INTERFACE, out_signature='b')
++    def running(self):
++        utils.get_logger().debug("running()")
++        return not self.done
++
++    @dbus.service.method(PROGRESS_INTERFACE, out_signature='s')
++    def result(self):
++        utils.get_logger().debug("result()")
++        return "\n".join(self._result)
++
++    @dbus.service.method(PROGRESS_INTERFACE, out_signature='s')
++    def last_error(self):
++        utils.get_logger().debug("last_error()")
++        return self._error
 === added file 'python/libertine/service/task_dispatcher.py'
 --- python/libertine/service/task_dispatcher.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/task_dispatcher.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,114 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++import libertine.ContainersConfig
++from libertine.service.container import Container
++from libertine.service.tasks import *
++from threading import Lock
++from libertine import utils
++
++
++class TaskDispatcher(object):
++    def __init__(self, connection):
++        self._connection = connection
++        self._config = libertine.ContainersConfig.ContainersConfig()
++        self._lock = Lock()
++        self._containerless_tasks = []
++        self._tasks = []
++        self._containers = []
++
++    def _cleanup_task(self, task):
++        utils.get_logger().debug("cleaning up containerless task '%s'" % task.id)
++        if task in self._tasks:
++            self._tasks.remove(task)
++
++    def _cleanup_container(self, container):
++        utils.get_logger().debug("cleaning up container '%s'" % container)
++        if container in self._containers:
++            self._containers.remove(container)
++
++    def _find_or_create_container(self, container_id):
++        utils.get_logger().debug("finding or creating container '%s'" % container_id)
++        container = self._find_container(container_id)
++        if container is not None:
++            utils.get_logger().debug("using existing container '%s'" % container_id)
++            return container
++        container = Container(container_id, self._config, self._lock, self._connection, self._cleanup_container)
++        self._containers.append(container)
++
++        return container
++
++    def _find_container(self, container_id):
++        containers = [c for c in self._containers if c.id == container_id]
++        if len(containers) > 0:
++            return containers[0]
++
++    # Tasks (usually) run within a container
++
++    def search(self, container_id, query):
++        utils.get_logger().debug("dispatching search in container '%s' for package '%s'" % (container_id, query))
++        return self._find_or_create_container(container_id).search(query)
++
++    def app_info(self, container_id, app_id):
++        utils.get_logger().debug("dispatching app_info in container '%s' for package '%s'" % (container_id, app_id))
++        return self._find_or_create_container(container_id).app_info(app_id)
++
++    def install(self, container_id, package_name):
++        utils.get_logger().debug("dispatching install of package '%s' from container '%s'" % (package_name, container_id))
++        return self._find_or_create_container(container_id).install(package_name)
++
++    def remove(self, container_id, package_name):
++        utils.get_logger().debug("dispatching remove of package '%s' from container '%s'" % (package_name, container_id))
++        return self._find_or_create_container(container_id).remove(package_name)
++
++    def create(self, container_id, container_name, distro, container_type, enable_multiarch):
++        utils.get_logger().debug("dispatching create of container '%s'" % container_id)
++        return self._find_or_create_container(container_id).create(container_name, distro, container_type, enable_multiarch)
++
++    def destroy(self, container_id):
++        utils.get_logger().debug("dispatching destroy container '%s'" % container_id)
++        return self._find_or_create_container(container_id).destroy()
++
++    def update(self, container_id):
++        utils.get_logger().debug("dispatching update container '%s'" % container_id)
++        return self._find_or_create_container(container_id).update()
++
++    def list_apps(self, container_id):
++        utils.get_logger().debug("dispatching list all apps in container '%s'" % container_id)
++        return self._find_or_create_container(container_id).list_apps()
++
++    # Containerless Tasks
++
++    def container_info(self, container_id):
++        utils.get_logger().debug("dispatching get info for container '%s'" % container_id)
++
++        related_task_ids = []
++        container = self._find_container(container_id)
++        if container is not None:
++            related_task_ids = container.tasks
++        task = ContainerInfoTask(container_id, related_task_ids, self._config, self._connection, self._cleanup_task)
++        self._tasks.append(task)
++        task.start()
++
++        return task.id
++
++    def list(self):
++        utils.get_logger().debug("dispatching list all containers")
++
++        task = ListTask(self._connection, self._cleanup_task)
++        self._tasks.append(task)
++        task.start()
++
++        return task.id
 === added directory 'python/libertine/service/tasks'
 === added file 'python/libertine/service/tasks/__init__.py'
 --- python/libertine/service/tasks/__init__.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/__init__.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,39 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++from .base_task import BaseTask
++from .app_info_task import AppInfoTask
++from .container_info_task import ContainerInfoTask
++from .create_task import CreateTask
++from .destroy_task import DestroyTask
++from .install_task import InstallTask
++from .remove_task import RemoveTask
++from .search_task import SearchTask
++from .update_task import UpdateTask
++from .list_task import ListTask
++from .list_apps_task import ListAppsTask
++
++__all__ = [
++          'AppInfoTask',
++          'BaseTask',
++          'ContainerInfoTask',
++          'CreateTask',
++          'DestroyTask',
++          'InstallTask',
++          'RemoveTask',
++          'SearchTask',
++          'UpdateTask',
++          'ListTask',
++          'ListAppsTask'
++          ]
 === added file 'python/libertine/service/tasks/app_info_task.py'
 --- python/libertine/service/tasks/app_info_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/app_info_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,35 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import utils
++
++
++class AppInfoTask(BaseTask):
++    def __init__(self, container_id, cache, app_id, tasks, config, connection, callback):
++        super().__init__(lock=None, container_id=container_id, config=config, connection=connection, callback=callback)
++        self._cache = cache
++        self._app_id = app_id
++        self._tasks = tasks
++
++    def _run(self):
++        app = self._cache.app_info(self._app_id)
++        if app == {}:
++            self._progress.error("Could not find app info for '%s' in container '%s'" % (self._app_id, self._container))
++            return
++
++        app['status'] = self._config.get_package_install_status(self._container, app['package']) or ''
++        app['task_ids'] = self._tasks
++        self._progress.data(str(app))
 === added file 'python/libertine/service/tasks/base_task.py'
 --- python/libertine/service/tasks/base_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/base_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,94 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++import libertine.service.progress
++import threading
++from abc import ABCMeta, abstractmethod
++from libertine import utils
++
++
++class BaseTask(metaclass=ABCMeta):
++    """
++    Abstract class for performing long-running, synchronous operations on a
++    Libertine container. Child classes must implement _run, which will execute
++    in a separate thread. Override _before to implement pre-execution actions
++    without locking; if _before returns False, _run will not be executed.
++    """
++    def __init__(self, lock, container_id, config, connection, callback):
++        self._lock = lock
++        self._container = container_id
++        self._config = config
++        self._callback = callback
++        self._connection = connection
++        self._progress = None
++        self._instant_callback = False
++
++    def matches(self, container, klass):
++        return self._container == container and self.__class__ == klass
++
++    @property
++    def id(self):
++        if self._progress is not None:
++            return self._progress.id
++        else:
++            return None
++
++    @property
++    def container(self):
++        return self._container or ''
++
++    @property
++    def package(self):
++        return ''
++
++    @property
++    def running(self):
++        return not self._progress.done
++
++    def _delayed_callback(self):
++        if self._instant_callback:
++            self._callback(self)
++        else:
++            threading.Timer(30, lambda: self._callback(self)).start()
++
++    def start(self):
++        self._progress = libertine.service.progress.Progress(self._connection)
++        thread = threading.Thread(target=self.run)
++        thread.start()
++        return thread
++
++    def run(self):
++        if not self._before():
++            self._progress.finished(self.container)
++            self._delayed_callback()
++            return
++
++        if self._lock is not None:
++            with self._lock:
++                self._run()
++        else:
++            self._run()
++
++        if self.running:
++            self._progress.finished(self.container)
++            utils.refresh_libertine_scope()
++
++        self._delayed_callback()
++
++    @abstractmethod
++    def _run(self):
++        pass
++
++    def _before(self):
++        return True
 === added file 'python/libertine/service/tasks/container_info_task.py'
 --- python/libertine/service/tasks/container_info_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/container_info_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,29 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import utils
++
++
++class ContainerInfoTask(BaseTask):
++    def __init__(self, container_id, tasks, config, connection, callback):
++        super().__init__(lock=None, container_id=container_id, config=config, connection=connection, callback=callback)
++        self._tasks = tasks
++
++    def _run(self):
++        container = {'id': str(self._container)}
++        container['status'] = self._config._get_value_by_key(self._container, 'installStatus') or ''
++        container['task_ids'] = self._tasks
++        self._progress.data(str(container))
 === added file 'python/libertine/service/tasks/create_task.py'
 --- python/libertine/service/tasks/create_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/create_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,72 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import LibertineContainer, utils
++from libertine.HostInfo import HostInfo
++
++
++class CreateTask(BaseTask):
++    def __init__(self, container_id, container_name, distro, container_type, enable_multiarch, config, lock, connection, callback):
++        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
++        self._name = container_name
++        self._distro = distro
++        self._type = container_type
++        self._multiarch = enable_multiarch
++
++    def _run(self):
++        utils.get_logger().debug("Creating container '%s'" % self._container)
++
++        try:
++            container = LibertineContainer(self._container, self._config)
++
++            if not container.create_libertine_container(password='', multiarch=self._multiarch):
++                self._config.delete_container(self._container)
++                self._progress.error("Creating container '%s' failed" % self._container)
++            else:
++                self._config.update_container_install_status(self._container, "ready")
++        except RuntimeError as e:
++            self._progress.error(str(e))
++            self._config.delete_container(self._container)
++
++    def _before(self):
++        utils.get_logger().debug("CreateTask::_before")
++        if self._config.container_exists(self._container):
++            self._progress.error("Container '%s' already exists" % self._container)
++            return False
++
++        info = HostInfo()
++        if not self._distro:
++            self._distro = info.get_host_distro_release()
++        elif not info.is_distro_valid(self._distro):
++            self._progress.error("Invalid distro '%s'." % self._distro)
++            return False
++
++        if not self._type:
++            self._type = info.select_container_type_by_kernel()
++        elif self._type == 'lxc' and not info.has_lxc_support():
++            self._progress.error("System kernel does not support lxc type containers. Please either use chroot or leave empty.")
++            return False
++
++        if not self._name:
++            self._name = "Ubuntu \'" + info.get_distro_codename(self._distro) + "\'"
++
++        self._config.add_new_container(self._container, self._name, self._type, self._distro)
++
++        if self._multiarch:
++            self._config.update_container_multiarch_support(self._container, 'enabled')
++
++        self._config.update_container_install_status(self._container, 'installing')
++        return True
 === added file 'python/libertine/service/tasks/destroy_task.py'
 --- python/libertine/service/tasks/destroy_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/destroy_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,42 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import LibertineContainer, utils
++
++
++class DestroyTask(BaseTask):
++    def __init__(self, container_id, config, lock, connection, callback):
++        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
++
++    def _run(self):
++        utils.get_logger().debug("Destroying container '%s'" % self._container)
++
++        container = LibertineContainer(self._container, self._config)
++        if not container.destroy_libertine_container():
++            self._progress.error("Destroying container '%s' failed" % self._container)
++            self._config.update_container_install_status(self._container, "ready")
++            return
++
++        self._config.delete_container(self._container)
++
++    def _before(self):
++        utils.get_logger().debug("CreateTask::_before")
++        if self._config._get_value_by_key(self._container, 'installStatus') != 'ready':
++            self._progress.error("Container '%s' does not exist" % self._container)
++            return False
++
++        self._config.update_container_install_status(self._container, 'removing')
++        return True
 === added file 'python/libertine/service/tasks/install_task.py'
 --- python/libertine/service/tasks/install_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/install_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,49 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import LibertineContainer, utils
++
++
++class InstallTask(BaseTask):
++    def __init__(self, package_name, container_id, config, lock, connection, callback):
++        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
++        self._package = package_name
++
++    def matches(self, package, klass):
++        return self._package == package and self.__class__ == klass
++
++    @property
++    def package(self):
++        return self._package
++
++    def _run(self):
++        utils.get_logger().debug("Installing package '%s'" % self._package)
++        container = LibertineContainer(self._container, self._config)
++        if container.install_package(self._package):
++            self._config.update_package_install_status(self._container, self._package, "installed")
++        else:
++            self._config.delete_package(self._container, self._package)
++            self._progress.error("Package installation failed for '%s'" % self._package)
++
++    def _before(self):
++        utils.get_logger().debug("InstallTask::_before")
++        if self._config.package_exists(self._container, self._package):
++            self._progress.error("Package '%s' already exists, skipping install" % self._package)
++            return False
++        else:
++            self._config.add_new_package(self._container, self._package)
++            self._config.update_package_install_status(self._container, self._package, "installing")
++            return True
 === added file 'python/libertine/service/tasks/list_apps_task.py'
 --- python/libertine/service/tasks/list_apps_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/list_apps_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,30 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import LibertineContainer, utils
++
++
++class ListAppsTask(BaseTask):
++    def __init__(self, container_id, config, connection, callback):
++        super().__init__(lock=None, container_id=container_id, config=config, connection=connection, callback=callback)
++
++    def _run(self):
++        utils.get_logger().debug("Listing apps in container '%s'" % self._container)
++        if not self._config.container_exists(self._container):
++            self._progress.error("Container '%s' does not exist, skipping list" % self._container)
++        else:
++            container = LibertineContainer(self._container, self._config)
++            self._progress.data(str(container.list_app_launchers(use_json=True)))
 === added file 'python/libertine/service/tasks/list_task.py'
 --- python/libertine/service/tasks/list_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/list_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,25 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import utils
++
++
++class ListTask(BaseTask):
++    def __init__(self, connection, callback):
++        super().__init__(lock=None, container_id=None, config=None, connection=connection, callback=callback)
++
++    def _run(self):
++        self._progress.data(str(utils.Libertine.list_containers()))
 === added file 'python/libertine/service/tasks/remove_task.py'
 --- python/libertine/service/tasks/remove_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/remove_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,48 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import LibertineContainer, utils
++
++
++class RemoveTask(BaseTask):
++    def __init__(self, package_name, container_id, config, lock, connection, callback):
++        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
++        self._package = package_name
++
++    def matches(self, package, klass):
++        return self._package == package and self.__class__ == klass
++
++    @property
++    def package(self):
++        return self._package
++
++    def _run(self):
++        utils.get_logger().debug("Removing package '%s'" % self._package)
++        container = LibertineContainer(self._container, self._config)
++        if container.remove_package(self._package):
++            self._config.delete_package(self._container, self._package)
++        else:
++            self._config.update_package_install_status(self._container, self._package, 'installed')
++            self._progress.error("Package removal failed for '%s'" % self._package)
++
++    def _before(self):
++        utils.get_logger().debug("RemoveTask::_before")
++        if self._config.get_package_install_status(self._container, self._package) == 'installed':
++            self._config.update_package_install_status(self._container, self._package, "removing")
++            return True
++        else:
++            self._progress.error("Package '%s' not installed, skipping remove" % self._package)
++            return False
 === added file 'python/libertine/service/tasks/search_task.py'
 --- python/libertine/service/tasks/search_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/search_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,27 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import utils
++
++
++class SearchTask(BaseTask):
++    def __init__(self, container_id, cache, query, connection, callback):
++        super().__init__(lock=None, container_id=container_id, config=None, connection=connection, callback=callback)
++        self._cache = cache
++        self._query = query
++
++    def _run(self):
++        self._progress.data(str(self._cache.search(self._query)))
 === added file 'python/libertine/service/tasks/update_task.py'
 --- python/libertine/service/tasks/update_task.py	1970-01-01 00:00:00 +0000
 +++ python/libertine/service/tasks/update_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,39 @@
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++
++from .base_task import BaseTask
++from libertine import LibertineContainer, utils
++
++
++class UpdateTask(BaseTask):
++    def __init__(self, container_id, config, lock, connection, callback):
++        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
++
++    def _run(self):
++        utils.get_logger().debug("Updating container '%s'" % self._container)
++        container = LibertineContainer(self._container, self._config)
++        self._config.update_container_install_status(self._container, "updating")
++        if not container.update_libertine_container():
++            self._progress.error("Failed to update container '%s'" % self._container)
++
++        self._config.update_container_install_status(self._container, "ready")
++
++    def _before(self):
++        utils.get_logger().debug("UpdateTask::_before")
++        if not self._config.container_exists(self._container):
++            self._progress.error("Container '%s' does not exist, skipping update" % self._container)
++            return False
++        else:
++            return True
 === modified file 'tests/unit/CMakeLists.txt'
 --- tests/unit/CMakeLists.txt	2016-09-27 00:55:28 +0000
 +++ tests/unit/CMakeLists.txt	2016-11-16 17:34:14 +0000
@@ -30,3 +30,4 @@
                       ENVIRONMENT
                       "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
++add_subdirectory(service)
 === added file 'tests/unit/pytest.ini'
 --- tests/unit/pytest.ini	1970-01-01 00:00:00 +0000
 +++ tests/unit/pytest.ini	2016-11-16 17:34:14 +0000
@@ -0,0 +1,2 @@
++[pytest]
++norecursedirs = service
 === added directory 'tests/unit/service'
 === added file 'tests/unit/service/CMakeLists.txt'
 --- tests/unit/service/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/CMakeLists.txt	2016-11-16 17:34:14 +0000
@@ -0,0 +1,12 @@
++function(create_service_unit_test test_name)
++  add_test(${test_name} /usr/bin/python3 -m testtools.run ${test_name})
++  set_tests_properties(${test_name}
++                       PROPERTIES ENVIRONMENT
++                       "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;LIBERTINE_DATA_DIR=${CMAKE_CURRENT_SOURCE_DIR}")
++endfunction(create_service_unit_test)
++
++create_service_unit_test(test_container)
++create_service_unit_test(test_apt)
++create_service_unit_test(test_task_dispatcher)
++
++add_subdirectory(tasks)
 === added directory 'tests/unit/service/containerroot'
 === added directory 'tests/unit/service/containerroot/var'
 === added directory 'tests/unit/service/containerroot/var/cache'
 === added directory 'tests/unit/service/containerroot/var/cache/app-info'
 === added directory 'tests/unit/service/containerroot/var/cache/app-info/gv'
 === added file 'tests/unit/service/containerroot/var/cache/app-info/gv/en_US.gvz'
 === added directory 'tests/unit/service/tasks'
 === added file 'tests/unit/service/tasks/CMakeLists.txt'
 --- tests/unit/service/tasks/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/CMakeLists.txt	2016-11-16 17:34:14 +0000
@@ -0,0 +1,10 @@
++create_service_unit_test(test_app_info_task)
++create_service_unit_test(test_container_info_task)
++create_service_unit_test(test_create_task)
++create_service_unit_test(test_destroy_task)
++create_service_unit_test(test_install_task)
++create_service_unit_test(test_list_task)
++create_service_unit_test(test_list_apps_task)
++create_service_unit_test(test_remove_task)
++create_service_unit_test(test_search_task)
++create_service_unit_test(test_update_task)
 === added file 'tests/unit/service/tasks/test_app_info_task.py'
 --- tests/unit/service/tasks/test_app_info_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_app_info_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,61 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks, apt
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestAppInfoTask(TestCase):
++    def setUp(self):
++        self.config     = unittest.mock.create_autospec(ContainersConfig)
++        self.cache      = unittest.mock.create_autospec(apt.AptCache)
++        self.connection = unittest.mock.Mock()
++
++    def test_app_not_found_causes_error(self):
++        self.called_with = None
++        def callback(t):
++            self.called_with = t
++
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            self.cache.app_info.return_value = {}
++            task = tasks.AppInfoTask('palpatine', self.cache, 'lightside', [1, 2], self.config, self.connection, callback)
++            task._instant_callback = True
++            task.start().join()
++
++            progress.error.assert_called_once_with('Could not find app info for \'lightside\' in container \'palpatine\'')
++
++            self.assertEqual(task, self.called_with)
++
++    def test_success_sends_data(self):
++        self.called_with = None
++        def callback(t):
++            self.called_with = t
++
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++
++            self.cache.app_info.return_value = {'package': 'darkside-common'}
++            self.config.get_package_install_status.return_value = 'installed'
++            task = tasks.AppInfoTask('palpatine', self.cache, 'darkside', [1, 2, 3], self.config, self.connection, callback)
++            task._instant_callback = True
++            task.start().join()
++
++            progress.data.assert_called_once_with(str({'package': 'darkside-common', 'status': 'installed', 'task_ids': [1, 2, 3]}))
++
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_container_info_task.py'
 --- tests/unit/service/tasks/test_container_info_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_container_info_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,44 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestContainerInfoTask(TestCase):
++    def setUp(self):
++        self.config     = unittest.mock.create_autospec(ContainersConfig)
++        self.connection = unittest.mock.Mock()
++
++    def test_success_sends_data(self):
++        self.called_with = None
++        def callback(t):
++            self.called_with = t
++
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++
++            self.config._get_value_by_key.return_value = 'ready'
++            task = tasks.ContainerInfoTask('palpatine', [1, 2, 3], self.config, self.connection, callback)
++            task._instant_callback = True
++            task.start().join()
++
++            progress.data.assert_called_once_with(str({'id': 'palpatine', 'status': 'ready', 'task_ids': [1, 2, 3]}))
++            progress.finished.assert_called_once_with('palpatine')
++
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_create_task.py'
 --- tests/unit/service/tasks/test_create_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_create_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,234 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestCreateTask(TestCase):
++    def setUp(self):
++        self.config      = unittest.mock.create_autospec(ContainersConfig)
++        self.connection  = unittest.mock.Mock()
++        self.lock      = unittest.mock.MagicMock()
++        self.called_with = None
++
++    def callback(self, task):
++        self.called_with = task
++
++    def test_success_creates_lxc_container(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.is_distro_valid.return_value = True
++                MockHostInfo.return_value.has_lxc_support.return_value = True
++
++                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
++                    MockContainer.return_value.create_libertine_container.return_value = True
++                    task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'lxc', 'zesty')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'installing'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
++
++    def test_success_creates_chroot_container(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'chroot', False, self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.is_distro_valid.return_value = True
++
++                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
++                    MockContainer.return_value.create_libertine_container.return_value = True
++                    task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'chroot', 'zesty')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'installing'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
++
++    def test_container_runtime_error_sends_error(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.is_distro_valid.return_value = True
++                MockHostInfo.return_value.has_lxc_support.return_value = True
++
++                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
++                    MockContainer.return_value.create_libertine_container.side_effect = RuntimeError('a great disturbance')
++                    task.start().join()
++
++            progress.error.assert_called_once_with('a great disturbance')
++
++            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'lxc', 'zesty')
++            self.config.update_container_install_status.assert_called_once_with('palpatine', 'installing')
++            self.config.delete_container.assert_called_once_with('palpatine')
++
++            self.assertEqual(task, self.called_with)
++
++    def test_failed_container_exists_sends_error(self):
++        self.config.container_exists.return_value = True
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++            task.start().join()
++
++            progress.error.assert_called_once_with('Container \'palpatine\' already exists')
++            self.assertEqual(task, self.called_with)
++
++    def test_container_invalid_distro_error_sends_error(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.is_distro_valid.return_value = False
++                task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'vesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
++                task._instant_callback = True
++                task.start().join()
++
++            progress.error.assert_called_once_with('Invalid distro \'vesty\'.')
++            self.assertEqual(task, self.called_with)
++
++    def test_container_improper_lxc_error_sends_error(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.is_distro_valid.return_value = True
++                MockHostInfo.return_value.has_lxc_support.return_value = False
++                task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
++                task._instant_callback = True
++                task.start().join()
++
++            progress.error.assert_called_once_with('System kernel does not support lxc type containers. Please either use chroot or leave empty.')
++            self.assertEqual(task, self.called_with)
++
++    def test_sets_generic_name_when_empty(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.CreateTask('palpatine', None, 'zesty', 'chroot', False, self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.is_distro_valid.return_value = True
++                MockHostInfo.return_value.get_distro_codename.return_value = 'Zesty Zapus 17.04'
++
++                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
++                    MockContainer.return_value.create_libertine_container.return_value = True
++                    task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.add_new_container.assert_called_once_with('palpatine', 'Ubuntu \'Zesty Zapus 17.04\'', 'chroot', 'zesty')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'installing'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
++
++    def test_sets_multiarch(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'chroot', True, self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.is_distro_valid.return_value = True
++
++                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
++                    MockContainer.return_value.create_libertine_container.return_value = True
++                    task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'chroot', 'zesty')
++            self.config.update_container_multiarch_support.assert_called_once_with('palpatine', 'enabled')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'installing'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
++
++    def test_sets_default_type(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', None, False, self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.is_distro_valid.return_value = True
++                MockHostInfo.return_value.select_container_type_by_kernel.return_value = 'lxc'
++
++                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
++                    MockContainer.return_value.create_libertine_container.return_value = True
++                    task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'lxc', 'zesty')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'installing'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
++
++    def test_sets_default_distro(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', None, 'lxc', False, self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
++                MockHostInfo.return_value.has_lxc_support.return_value = True
++                MockHostInfo.return_value.get_host_distro_release.return_value = 'zesty'
++
++                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
++                    MockContainer.return_value.create_libertine_container.return_value = True
++                    task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'lxc', 'zesty')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'installing'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_destroy_task.py'
 --- tests/unit/service/tasks/test_destroy_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_destroy_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,80 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestDestroyTask(TestCase):
++    def setUp(self):
++        self.config      = unittest.mock.create_autospec(ContainersConfig)
++        self.connection  = unittest.mock.Mock()
++        self.lock      = unittest.mock.MagicMock()
++        self.called_with = None
++
++    def callback(self, task):
++        self.called_with = task
++
++    def test_sends_error_on_non_ready_container(self):
++        self.config._get_value_by_key.return_value = ''
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.DestroyTask('palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.destroy_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.destroy_libertine_container.return_value = True
++                task.start().join()
++
++            progress.error.assert_called_once_with('Container \'palpatine\' does not exist')
++            self.assertEqual(task, self.called_with)
++
++    def test_sends_error_on_failed_destroy(self):
++        self.config._get_value_by_key.return_value = 'ready'
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.DestroyTask('palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.destroy_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.destroy_libertine_container.return_value = False
++                task.start().join()
++
++            progress.error.assert_called_once_with('Destroying container \'palpatine\' failed')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'removing'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
++
++    def test_successfully_destroys(self):
++        self.config._get_value_by_key.return_value = 'ready'
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.DestroyTask('palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.destroy_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.destroy_libertine_container.return_value = True
++                task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.update_container_install_status.assert_called_once_with('palpatine', 'removing')
++            self.config.delete_container.assert_called_once_with('palpatine')
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_install_task.py'
 --- tests/unit/service/tasks/test_install_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_install_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,76 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestInstallTask(TestCase):
++    def setUp(self):
++        self.config      = unittest.mock.create_autospec(ContainersConfig)
++        self.connection  = unittest.mock.Mock()
++        self.lock        = unittest.mock.MagicMock()
++        self.called_with = None
++
++    def callback(self, task):
++        self.called_with = task
++
++    def test_sends_error_on_existing_package(self):
++        self.config.package_exists.return_value = True
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++            task.start().join()
++
++            progress.error.assert_called_once_with('Package \'darkside-common\' already exists, skipping install')
++            self.assertEqual(task, self.called_with)
++
++    def test_sends_error_on_failed_install(self):
++        self.config.package_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.install_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.install_package.return_value = False
++                task.start().join()
++
++            progress.error.assert_called_once_with("Package installation failed for 'darkside-common'")
++            self.config.update_package_install_status.assert_called_once_with('palpatine', 'darkside-common', 'installing')
++            self.config.delete_package.assert_called_once_with('palpatine', 'darkside-common')
++            self.assertEqual(task, self.called_with)
++
++    def test_successfully_install(self):
++        self.config.package_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.install_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.install_package.return_value = True
++                task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.update_package_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'darkside-common', 'installing'),
++                unittest.mock.call('palpatine', 'darkside-common', 'installed')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_list_apps_task.py'
 --- tests/unit/service/tasks/test_list_apps_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_list_apps_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,59 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestListAppsTask(TestCase):
++    def setUp(self):
++        self.config      = unittest.mock.create_autospec(ContainersConfig)
++        self.connection  = unittest.mock.Mock()
++        self.lock      = unittest.mock.MagicMock()
++        self.called_with = None
++
++    def callback(self, task):
++        self.called_with = task
++
++    def test_sends_error_on_non_existent_container(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.ListAppsTask('palpatine', self.config, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.list_apps_task.LibertineContainer') as MockContainer:
++                task.start().join()
++
++            progress.error.assert_called_once_with('Container \'palpatine\' does not exist, skipping list')
++            self.assertEqual(task, self.called_with)
++
++    def test_successfully_lists_apps(self):
++        self.config.container_exists.return_value = True
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.ListAppsTask('palpatine', self.config, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.list_apps_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.list_app_launchers.return_value = 'jarjar\nsidius'
++                task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            progress.data.assert_called_once_with('jarjar\nsidius')
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_list_task.py'
 --- tests/unit/service/tasks/test_list_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_list_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,45 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestListTask(TestCase):
++    def setUp(self):
++        self.config     = unittest.mock.create_autospec(ContainersConfig)
++        self.connection = unittest.mock.Mock()
++
++    def test_success_sends_data(self):
++        self.called_with = None
++        def callback(t):
++            self.called_with = t
++
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.ListTask(self.connection, callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.list_task.utils.Libertine') as MockLibertine:
++                MockLibertine.list_containers.return_value = 'palpatine\nvader\nmaul'
++                task.start().join()
++
++            progress.data.assert_called_once_with('palpatine\nvader\nmaul')
++            progress.finished.assert_called_once_with('')
++
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_remove_task.py'
 --- tests/unit/service/tasks/test_remove_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_remove_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,76 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestRemoveTask(TestCase):
++    def setUp(self):
++        self.config      = unittest.mock.create_autospec(ContainersConfig)
++        self.connection  = unittest.mock.Mock()
++        self.lock      = unittest.mock.MagicMock()
++        self.called_with = None
++
++    def callback(self, task):
++        self.called_with = task
++
++    def test_sends_error_on_non_installed_package(self):
++        self.config.get_package_install_status.return_value = 'installing'
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++            task.start().join()
++
++            progress.error.assert_called_once_with('Package \'darkside-common\' not installed, skipping remove')
++            self.assertEqual(task, self.called_with)
++
++    def test_sends_error_on_failed_install(self):
++        self.config.get_package_install_status.return_value = 'installed'
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.remove_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.remove_package.return_value = False
++                task.start().join()
++
++            progress.error.assert_called_once_with("Package removal failed for 'darkside-common'")
++            self.config.update_package_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'darkside-common', 'removing'),
++                unittest.mock.call('palpatine', 'darkside-common', 'installed')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
++
++    def test_successfully_install(self):
++        self.config.get_package_install_status.return_value = 'installed'
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.remove_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.remove_package.return_value = True
++                task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.update_package_install_status.assert_called_once_with('palpatine', 'darkside-common', 'removing')
++            self.config.delete_package.assert_called_once_with('palpatine', 'darkside-common')
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_search_task.py'
 --- tests/unit/service/tasks/test_search_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_search_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,43 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks, apt
++
++
++class TestSearchTask(TestCase):
++    def setUp(self):
++        self.connection  = unittest.mock.Mock()
++        self.lock      = unittest.mock.MagicMock()
++        self.cache     = unittest.mock.create_autospec(apt.AptCache)
++        self.called_with = None
++
++    def callback(self, task):
++        self.called_with = task
++
++    def test_successfully_lists_apps(self):
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.SearchTask('palpatine', self.cache, 'jarjar', self.connection, self.callback)
++            task._instant_callback = True
++
++            self.cache.search.return_value = ['jarjar', 'sidius']
++            task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            progress.data.assert_called_once_with(str(['jarjar', 'sidius']))
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/tasks/test_update_task.py'
 --- tests/unit/service/tasks/test_update_task.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/tasks/test_update_task.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,80 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import tasks
++from libertine.ContainersConfig import ContainersConfig
++
++
++class TestUpdateTask(TestCase):
++    def setUp(self):
++        self.config      = unittest.mock.create_autospec(ContainersConfig)
++        self.connection  = unittest.mock.Mock()
++        self.lock      = unittest.mock.MagicMock()
++        self.called_with = None
++
++    def callback(self, task):
++        self.called_with = task
++
++    def test_sends_error_on_non_existent_container(self):
++        self.config.container_exists.return_value = False
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.UpdateTask('palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.update_task.LibertineContainer') as MockContainer:
++                task.start().join()
++
++            progress.error.assert_called_once_with('Container \'palpatine\' does not exist, skipping update')
++            self.assertEqual(task, self.called_with)
++
++    def test_sends_error_on_failed_update(self):
++        self.config.container_exists.return_value = True
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            task = tasks.UpdateTask('palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.update_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.update_libertine_container.return_value = False
++                task.start().join()
++
++            progress.error.assert_called_once_with('Failed to update container \'palpatine\'')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'updating'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
++
++    def test_successfully_updates(self):
++        self.config.container_exists.return_value = True
++        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
++            progress = MockProgress.return_value
++            progress.done = False
++            task = tasks.UpdateTask('palpatine', self.config, self.lock, self.connection, self.callback)
++            task._instant_callback = True
++
++            with unittest.mock.patch('libertine.service.tasks.update_task.LibertineContainer') as MockContainer:
++                MockContainer.return_value.update_libertine_container.return_value = True
++                task.start().join()
++
++            progress.finished.assert_called_once_with('palpatine')
++            self.config.update_container_install_status.assert_has_calls([
++                unittest.mock.call('palpatine', 'updating'),
++                unittest.mock.call('palpatine', 'ready')
++            ], any_order=True)
++            self.assertEqual(task, self.called_with)
 === added file 'tests/unit/service/test_apt.py'
 --- tests/unit/service/test_apt.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/test_apt.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,134 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++import os
++import unittest.mock
++from unittest import TestCase
++from libertine.service import apt
++
++
++def build_mock_app(name, summary, website, description):
++    app = unittest.mock.Mock()
++    app.name = name
++    version = unittest.mock.Mock()
++    version.summary = summary
++    version.homepage = website
++    version.description = description
++    app.versions = [version]
++    return app
++
++
++class TestAptCache(TestCase):
++    def test_search_returns_empty_when_no_matching_results(self):
++        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
++            MockCache.return_value.keys.return_value = []
++
++            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
++                MockLibertine.container_path.return_value = '/some/junk'
++                self.assertEqual(apt.AptCache('palpatine').search('vim'), [])
++
++    def test_search_returns_matching_results(self):
++        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
++            MockCache.return_value = {
++                "vim": build_mock_app("vim", "vi improved", "vim.com", "who even uses raw vi"),
++                "gedit": build_mock_app("gedit", "text editor", "gedit.com", "visual text editor"),
++                "gimp": build_mock_app("gimp", "foss photoshop", "gimp.com", "edit bitmap images"),
++                "vim-common": build_mock_app("vim-common", "common vim stuff", "vim.common", "dependencies")
++            }
++
++            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
++                MockLibertine.container_path.return_value = '/some/junk'
++                results = apt.AptCache('palpatine').search('vim')
++
++            self.assertEqual(len(results), 2)
++            results = sorted(results, key=lambda xx: xx['id'])
++            self.assertEqual(results[0]['description'], 'who even uses raw vi')
++            self.assertEqual(results[0]['name'], 'vim')
++            self.assertEqual(results[0]['id'], 'vim')
++            self.assertEqual(results[0]['summary'], 'vi improved')
++            self.assertEqual(results[0]['website'], 'vim.com')
++            self.assertEqual(results[0]['package'], 'vim')
++
++            self.assertEqual(results[1]['description'], 'dependencies')
++            self.assertEqual(results[1]['name'], 'vim-common')
++            self.assertEqual(results[1]['id'], 'vim-common')
++            self.assertEqual(results[1]['summary'], 'common vim stuff')
++            self.assertEqual(results[1]['website'], 'vim.common')
++            self.assertEqual(results[1]['package'], 'vim-common')
++
++            MockCache.assert_called_once_with()
++
++    def test_app_info_returns_empty_dict_when_no_such_app_exists(self):
++        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
++            MockCache.return_value = {}
++            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
++                MockLibertine.container_path.return_value = '/some/junk'
++                self.assertEqual(apt.AptCache('palpatine').app_info("vim"), {})
++            MockCache.assert_called_once_with()
++
++    def test_app_info_returns_values_for_app(self):
++        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
++            MockCache.return_value = {
++                "vim": build_mock_app("vim", "vi improved", "vim.com", "who even uses raw vi"),
++                "gimp": build_mock_app("gimp", "foss photoshop", "gimp.com", "visual text editor"),
++            }
++            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
++                MockLibertine.container_path.return_value = '/some/junk'
++                self.assertEqual(apt.AptCache('palpatine').app_info("vim"), {
++                    'name': 'vim',
++                    'id': 'vim',
++                    'package': 'vim',
++                    'summary': 'vi improved',
++                    'description': 'who even uses raw vi',
++                    'website': 'vim.com'
++                })
++            MockCache.assert_called_once_with()
++
++    def test_loads_cache_from_container_directory(self):
++        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
++            MockCache.return_value = {
++                "vim": build_mock_app("vim", "vi improved", "vim.com", "who even uses raw vi"),
++                "gimp": build_mock_app("gimp", "foss photoshop", "gimp.com", "visual text editor"),
++            }
++            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
++                containerpath = "%s/containerroot" % os.path.dirname(os.path.realpath(__file__))
++                MockLibertine.container_path.return_value = containerpath
++                self.assertEqual(apt.AptCache('palpatine').app_info("vim"), {
++                    'name': 'vim',
++                    'id': 'vim',
++                    'package': 'vim',
++                    'summary': 'vi improved',
++                    'description': 'who even uses raw vi',
++                    'website': 'vim.com'
++                })
++
++            MockCache.assert_called_once_with(rootdir=containerpath)
++
++    def test_loads_cache_only_once(self):
++        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
++            MockCache.return_value = {
++                "vim": build_mock_app("vim", "vi improved", "vim.com", "who even uses raw vi"),
++                "gimp": build_mock_app("gimp", "foss photoshop", "gimp.com", "visual text editor"),
++            }
++            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
++                MockLibertine.container_path.return_value = '/some/junk'
++                cache = apt.AptCache('palpatine')
++                cache.app_info("vim")
++                cache.app_info("vim")
++
++            MockCache.assert_called_once_with()
++
++
++if __name__ == '__main__':
++    unittest.main()
 === added file 'tests/unit/service/test_container.py'
 --- tests/unit/service/test_container.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/test_container.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,202 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import container
++from libertine.service import tasks
++
++
++class TestContainer(TestCase):
++    def setUp(self):
++        self._connection = unittest.mock.Mock()
++        self._config = unittest.mock.Mock()
++        self._lock = unittest.mock.Mock()
++
++    def test_search_creates_search_task(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.SearchTask') as MockSearchTask:
++                c.search('darkseid')
++                MockSearchTask.assert_called_once_with('palpatine', cache, 'darkseid', self._connection, unittest.mock.ANY)
++                MockSearchTask.return_value.start.assert_called_once_with()
++
++    def test_app_info_creates_app_info_task(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.AppInfoTask') as MockAppInfoTask:
++                c.app_info('force')
++                MockAppInfoTask.assert_called_once_with('palpatine', cache, 'force', [], self._config, self._connection, unittest.mock.ANY)
++                MockAppInfoTask.return_value.start.assert_called_once_with()
++
++    def test_app_info_gets_related_task_info(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
++                MockInstallTask.return_value.package = 'darkside'
++                MockInstallTask.return_value.matches.return_value = False
++                install_task_id = c.install('darkside')
++                with unittest.mock.patch('libertine.service.container.RemoveTask') as MockRemoveTask:
++                    MockRemoveTask.return_value.package = 'darkside'
++                    remove_task_id = c.remove('darkside')
++                with unittest.mock.patch('libertine.service.container.AppInfoTask') as MockAppInfoTask:
++                    c.app_info('darkside')
++                    MockAppInfoTask.assert_called_once_with('palpatine', cache, 'darkside', [install_task_id, remove_task_id],
++                                                            self._config, self._connection, unittest.mock.ANY)
++
++    def test_install_creates_install_task(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
++                c.install('force')
++                MockInstallTask.assert_called_once_with('force', 'palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockInstallTask.return_value.start.assert_called_once_with()
++
++    def test_install_only_calls_once_when_unfinished(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
++                c.install('darkside')
++                c.install('darkside')
++                c.install('darkside')
++                # MockInstallTask.assert_called_once_with('darkside', 'palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockInstallTask.return_value.start.assert_called_once_with()
++
++    def test_remove_creates_remove_task(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.RemoveTask') as MockRemoveTask:
++                c.remove('force')
++                MockRemoveTask.assert_called_once_with('force', 'palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockRemoveTask.return_value.start.assert_called_once_with()
++
++    def test_remove_only_calls_once_when_unfinished(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.RemoveTask') as MockRemoveTask:
++                c.remove('darkside')
++                c.remove('darkside')
++                c.remove('darkside')
++                # MockRemoveTask.assert_called_once_with('darkside', 'palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockRemoveTask.return_value.start.assert_called_once_with()
++
++    def test_create_creates_create_task(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.CreateTask') as MockCreateTask:
++                c.create('Emperor Palpatine', 'zesty', 'lxd', False)
++                MockCreateTask.assert_called_once_with('palpatine', 'Emperor Palpatine', 'zesty', 'lxd', False,
++                                                       self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockCreateTask.return_value.start.assert_called_once_with()
++
++    def test_create_only_calls_once_when_unfinished(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.CreateTask') as MockCreateTask:
++                c.create('Emperor Palpatine', 'zesty', 'lxd', False)
++                c.create('Emperor Palpatine', 'zesty', 'lxd', False)
++                c.create('Emperor Palpatine', 'zesty', 'lxd', False)
++                # MockCreateTask.assert_called_once_with('palpatine', 'Emperor Palpatine', 'zesty', 'lxd', False,
++                #                                        self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockCreateTask.return_value.start.assert_called_once_with()
++
++    def test_destroy_creates_destroy_task(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.DestroyTask') as MockDestroyTask:
++                c.destroy()
++                # MockDestroyTask.assert_called_once_with('palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockDestroyTask.return_value.start.assert_called_once_with()
++
++    def test_destroy_only_calls_once_when_unfinished(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.DestroyTask') as MockDestroyTask:
++                c.destroy()
++                c.destroy()
++                c.destroy()
++                # MockDestroyTask.assert_called_once_with('palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockDestroyTask.return_value.start.assert_called_once_with()
++
++    def test_update_creates_update_task(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.UpdateTask') as MockUpdateTask:
++                c.update()
++                MockUpdateTask.assert_called_once_with('palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockUpdateTask.return_value.start.assert_called_once_with()
++
++    def test_update_only_calls_once_when_unfinished(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.UpdateTask') as MockUpdateTask:
++                c.update()
++                c.update()
++                c.update()
++                # MockUpdateTask.assert_called_once_with('palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
++                MockUpdateTask.return_value.start.assert_called_once_with()
++
++    def test_list_apps_creates_list_apps_task(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.ListAppsTask') as MockListAppsTask:
++                c.list_apps()
++                MockListAppsTask.assert_called_once_with('palpatine', self._config, self._connection, unittest.mock.ANY)
++                MockListAppsTask.return_value.start.assert_called_once_with()
++
++    def test_removes_task_during_callback(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
++            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
++                MockInstallTask.return_value.package = 'force'
++                c.install('force')
++                self.assertEqual(1, len(MockInstallTask.return_value.start.mock_calls)) # ensure initial mocks were called
++                c.install('force')
++                self.assertEqual(1, len(MockInstallTask.return_value.start.mock_calls)) # ensure no more mocks were called
++                name, args, kwargs = MockInstallTask.mock_calls[0]
++                args[len(args)-1](MockInstallTask.return_value.start.return_value)
++                c.install('force')
++                self.assertEqual(2, len(MockInstallTask.return_value.start.mock_calls)) # ensure mocks were called again
++
++    def test_completing_all_tasks_fires_callback(self):
++        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
++            cache = MockCache.return_value
++            self._container_id = None
++            def callback(container):
++                self._container_id = container.id
++            c = container.Container('palpatine', self._config, self._lock, self._connection, callback)
++            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
++                c.install('force')
++                name, args, kwargs = MockInstallTask.mock_calls[0]
++                args[len(args)-1](MockInstallTask.return_value)
++            self.assertEqual('palpatine', self._container_id)
++
++
++if __name__ == '__main__':
++    unittest.main()
 === added file 'tests/unit/service/test_task_dispatcher.py'
 --- tests/unit/service/test_task_dispatcher.py	1970-01-01 00:00:00 +0000
 +++ tests/unit/service/test_task_dispatcher.py	2016-11-16 17:34:14 +0000
@@ -0,0 +1,148 @@
++# Copyright 2016 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 3, as published
++# by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranties of
++# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
++
++import unittest.mock
++from unittest import TestCase
++from libertine.service import task_dispatcher
++
++
++class TestTaskDispatcher(TestCase):
++    def setUp(self):
++        self._connection = unittest.mock.Mock()
++        self._config_patcher = unittest.mock.patch('libertine.service.task_dispatcher.libertine.ContainersConfig.ContainersConfig')
++        self._config_patcher.start()
++        self._dispatcher = task_dispatcher.TaskDispatcher(self._connection)
++
++    def tearDown(self):
++        self._config_patcher.stop()
++
++    def test_search_calls_search_on_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.search.return_value = 123
++            self.assertEqual(123, self._dispatcher.search('palpatine', 'sith'))
++            c.search.assert_called_once_with('sith')
++
++    def test_app_info_calls_app_info_on_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.app_info.return_value = 123
++            self.assertEqual(123, self._dispatcher.app_info('palpatine', 'deathstar'))
++            c.app_info.assert_called_once_with('deathstar')
++
++    def test_install_calls_install_on_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.install.return_value = 123
++            self.assertEqual(123, self._dispatcher.install('palpatine', 'darkside'))
++            c.install.assert_called_once_with('darkside')
++
++    def test_remove_calls_remove_on_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.remove.return_value = 123
++            self.assertEqual(123, self._dispatcher.remove('palpatine', 'lightside'))
++            c.remove.assert_called_once_with('lightside')
++
++    def test_create_calls_create_on_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.create.return_value = 123
++            self.assertEqual(123, self._dispatcher.create('palpatine', 'Emperor Palpatine', 'zesty', 'lxd', False))
++            c.create.assert_called_once_with('Emperor Palpatine', 'zesty', 'lxd', False)
++
++    def test_destroy_calls_destroy_on_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.destroy.return_value = 123
++            self.assertEqual(123, self._dispatcher.destroy('palpatine'))
++            c.destroy.assert_called_once_with()
++
++    def test_update_calls_update_on_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.update.return_value = 123
++            self.assertEqual(123, self._dispatcher.update('palpatine'))
++            c.update.assert_called_once_with()
++
++    def test_list_apps_calls_list_apps_on_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.list_apps.return_value = 123
++            self.assertEqual(123, self._dispatcher.list_apps('palpatine'))
++            c.list_apps.assert_called_once_with()
++
++    def test_containers_reused_on_subsequent_calls(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.id = 'palpatine'
++            self._dispatcher.list_apps('palpatine')
++            self._dispatcher.list_apps('palpatine')
++            self._dispatcher.list_apps('palpatine')
++            MockContainer.assert_called_once_with('palpatine', unittest.mock.ANY, unittest.mock.ANY, self._connection, unittest.mock.ANY)
++
++    def test_container_callback_removes_container(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++            c = MockContainer.return_value
++            c.id = 'palpatine'
++            self._dispatcher.list_apps('palpatine')
++            MockContainer.assert_called_once_with('palpatine', unittest.mock.ANY, unittest.mock.ANY, self._connection, unittest.mock.ANY)
++            name, args, kwargs = MockContainer.mock_calls[0]
++            args[len(args)-1](MockContainer.return_value)
++            self._dispatcher.list_apps('palpatine')
++            MockContainer.assert_has_calls([ # verify container constructed twice
++                unittest.mock.call('palpatine', unittest.mock.ANY, unittest.mock.ANY, self._connection, unittest.mock.ANY),
++                unittest.mock.call('palpatine', unittest.mock.ANY, unittest.mock.ANY, self._connection, unittest.mock.ANY)
++            ], any_order=True)
++
++    def test_container_info_creates_container_info_task(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.ContainerInfoTask') as MockContainerInfoTask:
++            task = MockContainerInfoTask.return_value
++            task.id = 123
++            self.assertEqual(123, self._dispatcher.container_info('palpatine'))
++            MockContainerInfoTask.assert_called_once_with('palpatine', [], unittest.mock.ANY, self._connection, unittest.mock.ANY)
++            task.start.assert_called_once_with()
++
++    def test_container_info_forwards_container_task_ids(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.ContainerInfoTask') as MockContainerInfoTask:
++            task = MockContainerInfoTask.return_value
++            with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
++                c = MockContainer.return_value
++                c.tasks = [1, 2, 3]
++                c.id = 'palpatine'
++                self._dispatcher.list_apps('palpatine') # creates container
++                self._dispatcher.container_info('palpatine')
++            MockContainerInfoTask.assert_called_once_with('palpatine', [1, 2, 3], unittest.mock.ANY, self._connection, unittest.mock.ANY)
++            task.start.assert_called_once_with()
++
++    def test_list_creates_list_task(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.ListTask') as MockListTask:
++            task = MockListTask.return_value
++            task.id = 123
++            self.assertEqual(123, self._dispatcher.list())
++            MockListTask.assert_called_once_with(self._connection, unittest.mock.ANY)
++            task.start.assert_called_once_with()
++
++    def test_containerless_tasks_are_cleaned_up(self):
++        with unittest.mock.patch('libertine.service.task_dispatcher.ListTask') as MockListTask:
++            self._dispatcher.list()
++            MockListTask.assert_called_once_with(self._connection, unittest.mock.ANY)
++            name, args, kwargs = MockListTask.mock_calls[0]
++            self.assertEqual(1, len(self._dispatcher._tasks))
++            args[len(args)-1](MockListTask.return_value)
++            self.assertEqual(0, len(self._dispatcher._tasks))
++
++
++if __name__ == '__main__':
++    unittest.main()
 === modified file 'tools/CMakeLists.txt'
 --- tools/CMakeLists.txt	2016-08-04 01:39:08 +0000
 +++ tools/CMakeLists.txt	2016-11-16 17:34:14 +0000
@@ -1,4 +1,4 @@
--install(PROGRAMS libertine-container-manager libertine-launch libertine-lxc-manager libertine-xmir libertine-lxc-setup
++install(PROGRAMS libertine-container-manager libertine-launch libertine-lxc-manager libertine-xmir libertine-lxc-setup libertined
          DESTINATION ${CMAKE_INSTALL_BINDIR})
  install(FILES libertine-launch.1 libertine-container-manager.1 libertine-lxc-manager.1 libertine-xmir.1
          DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
 === modified file 'tools/libertine-container-manager'
 --- tools/libertine-container-manager	2016-11-09 18:25:33 +0000
 +++ tools/libertine-container-manager	2016-11-16 17:34:14 +0000
@@ -183,7 +183,7 @@
          container = LibertineContainer(container_id)
          self.containers_config.update_container_install_status(container_id, "updating")
--        if container.update_libertine_container(args.verbosity) is not 0:
++        if not container.update_libertine_container(args.verbosity):
              self.containers_config.update_container_install_status(container_id, "ready")
              sys.exit(1)
 === added file 'tools/libertined'
 --- tools/libertined	1970-01-01 00:00:00 +0000
 +++ tools/libertined	2016-11-16 17:34:14 +0000
@@ -0,0 +1,141 @@
++#!/usr/bin/python3
++# -*- coding: utf-8 -*-
++
++# Copyright 2016 Canonical Ltd.
++#
++# 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; version 3 of the License.
++#
++# 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, see <http://www.gnu.org/licenses/>.
++
++import argparse
++import signal
++import sys
++import os
++from gi.repository import GLib, GObject
++from libertine import utils
++from libertine.service import manager
++
++
++class OutputRedirector(object):
++    def __init__(self, config):
++        self.config = config
++        self.cache_path = '%s/.cache/libertined' % os.environ['HOME']
++        self.cache_file = '%s/libertined.log' % self.cache_path
++        self.output_file = None
++        self.copied_stdout = None
++        self.copied_stderr = None
++
++    def _fileno(self, file_or_fd):
++        return getattr(file_or_fd, 'fileno', lambda: file_or_fd)()
++
++    def _do_redirect(self, stream):
++        fd = self._fileno(stream)
++        copied_stream = os.fdopen(os.dup(fd), 'wb')
++        stream.flush()
++        os.dup2(self._fileno(self.output_file), fd)
++        return copied_stream, fd
++
++    def _undo_redirect(self, stream, stream_fd, copied_stream):
++        stream.flush()
++        os.dup2(copied_stream.fileno(), stream_fd)
++        copied_stream.close()
++
++    def _rotate_logs(self):
++        os.makedirs(self.cache_path, exist_ok=True)
++        num_backups = 3
++        for i in range(num_backups, 0, -1):
++            filename = '%s.%i' % (self.cache_file, i)
++            if os.path.exists(filename):
++                if i == num_backups:
++                    os.remove(filename)
++                else:
++                    os.rename(filename, '%s.%i' % (self.cache_file, i+1))
++        if os.path.exists(self.cache_file):
++            os.rename(self.cache_file, '%s.1' % self.cache_file)
++
++    def __enter__(self):
++        if self.config.debug:
++            os.environ['LIBERTINE_DEBUG'] = '1'
++        else:
++            if self.config.cache_output:
++                os.environ['LIBERTINE_DEBUG'] = '1'
++                self._rotate_logs()
++                self.output_file = open(self.cache_file, 'w')
++            else:
++                self.output_file = open(os.devnull, 'w')
++
++            self.copied_stdout, self.stdout_fd = self._do_redirect(sys.stdout)
++            self.copied_stderr, self.stderr_fd = self._do_redirect(sys.stderr)
++
++    def __exit__(self, type, value, tb):
++        if self.copied_stdout and self.stdout_fd:
++            self._undo_redirect(sys.stdout, self.stdout_fd, self.copied_stdout)
++        if self.copied_stderr and self.stderr_fd:
++            self._undo_redirect(sys.stderr, self.stderr_fd, self.copied_stderr)
++        if self.output_file:
++            self.output_file.close()
++
++
++class Config(object):
++  def __init__(self):
++    self._arg_parser = argparse.ArgumentParser(description=u'Libertine Store service')
++    self._arg_parser.add_argument(u'-l', u"--use-local-cache",
++                                  action='store_true',
++                                  default=False,
++                                  help=u"use local cache instead of system cache")
++    self._arg_parser.add_argument(u'-d', u"--debug",
++                                  action='store_true',
++                                  default=False,
++                                  help=u"allow all output on stdout")
++    self._arg_parser.add_argument(u'-c', u"--cache-output",
++                                  action='store_true',
++                                  default=False,
++                                  help=u"Log to $HOME/.cache/libertined/ instead of stdout")
++    args = self._arg_parser.parse_args(namespace=Config)
++
++
++class Loop(object):
++    def __init__(self):
++        GLib.unix_signal_add(GLib.PRIORITY_HIGH,
++                         signal.SIGTERM,
++                         self.sigterm,
++                         None)
++        self.loop = GLib.MainLoop()
++
++    def sigterm(self, code):
++        utils.get_logger().info("terminate ('%s') signal received" % code)
++        self.shutdown()
++
++    def shutdown(self):
++        utils.get_logger().info("shutting service down")
++        self.loop.quit()
++
++    def run(self):
++        utils.get_logger().debug("entering main loop")
++        self.loop.run()
++
++
++def main():
++    config = Config()
++
++    with OutputRedirector(config):
++        utils.get_logger().info("Starting libertine service")
++        service = manager.Manager()
++        loop = Loop()
++        try:
++            loop.run()
++        except KeyboardInterrupt:
++            utils.get_logger().debug("keyboard interrupt received")
++            loop.shutdown()
++
++
++if __name__ == '__main__':
++    main()