Merge lp:~larryprice/libertine/release-1.7.1 into lp:libertine/trunk

[Larry Price]

* When starting pasted, ensure DISPLAY is set and valid before continuing to
run. (LP: 1666472)
* Fix pasted to work with rootless Xmir. (LP: 1671257)
* Bump version to 1.7.1
* Gracefully handle creating a LibertineContainer object when the container
backend is unavailable.
* Update libertine xmir components to not depend on container backends.
(LP: 1671938)
* Catch all errors and gracefully shutdown libertined. (LP: 1671009)
* Fix method call from ContainerControl d-bus to interfaces.
* Update signal handlers in test_libertine_service to reflect new API.
* Inject client for accessing ContainerControl within containers.
* Rearchitect libertine service python backend for simpler access to running
tasks. (LP: 1669091)
* Ignore completions from dependencies during snapcraft build.
* LXD needs to forward host environment to container when running arbitrary
commands.
* Add client object to list_app_ids_task to avoid making reentrant service
calls.
* Take advantage of new network subcommand during lxd init on newer
installs.
* Prevent installing empty package names and appropriately update status for
unstopped containers.
* Modifications to make test_libertine_service more stable.
* Add a '-x' option to pkill so it only kills the libertined process(es)
and nothing else. (LP: 1676005)
* Remove hard-coded dependency on libraries.
* Reopen the database file after every failure to grab the lock.
(LP: 1662655)

Release libertine 1.7.1 with packaging/dependency changes and bug fixes.

[lp:~larryprice/libertine/release-1.7.1]

199. By Larry Price on 2017-03-23

* When starting pasted, ensure DISPLAY is set and valid before continuing to
  run. (LP: #1666472)
* Fix pasted to work with rootless Xmir. (LP: #1671257)
* LXD needs to forward host environment to container when running arbitrary
  commands.
* Add client object to list_app_ids_task to avoid making reentrant service
  calls.
* Take advantage of new network subcommand during lxd init on newer
  installs.
* Prevent installing empty package names and appropriately update status for
  unstopped containers.

200. By Larry Price on 2017-03-24

Only depend on libertine-xmir-tools on the appropriate architectures

201. By Larry Price on 2017-03-24

Path does not exist issue

202. By Larry Price on 2017-03-24

Merge with lp:libertine/trunk

203. By Larry Price on 2017-03-27

Merge in test_libertine_service stabilization changes

204. By Larry Price on 2017-03-28

Allow libertine-xmir-tools to build on any architecture

[Christopher Townsend (townsend)]

Ok, +1

review: Approve

[lp:~larryprice/libertine/release-1.7.1]

205. By Larry Price on 2017-03-31

Merge lp:libertine

206. By Larry Price on 2017-03-31

Merge lp:~townsend/libertine/fix-lib-deps

207. By Larry Price on 2017-03-31

Update changelog

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-03-06 17:36:14 +0000
+++ CMakeLists.txt	2017-03-31 20:05:48 +0000
@@ -30,6 +30,12 @@
 pkg_check_modules(PYTHON3 REQUIRED python3)
 include_directories(${PYTHON3_INCLUDE_DIRS})
 
+pkg_check_modules(DBUSTEST REQUIRED dbustest-1>=14.04.0)
+include_directories(${DBUSTEST_INCLUDE_DIRS})
+
+pkg_check_modules(GIO2 REQUIRED gio-2.0 gio-unix-2.0)
+include_directories(${GIO2_INCLUDE_DIRS})
+
 set(CMAKE_AUTOMOC ON)
 
 set(LIBERTINE_COMMON libertine-common)

=== modified file 'debian/changelog'
--- debian/changelog	2017-03-20 15:34:36 +0000
+++ debian/changelog	2017-03-31 20:05:48 +0000
@@ -1,3 +1,40 @@
+libertine (1.7.1-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Chris Townsend ]
+  * When starting pasted, ensure DISPLAY is set and valid before continuing to
+    run. (LP: #1666472)
+  * Fix pasted to work with rootless Xmir. (LP: #1671257)
+  * Add a '-x' option to pkill so it only kills the libertined process(es)
+    and nothing else. (LP: #1676005)
+  * Remove hard-coded dependency on libraries.
+
+  [ Larry Price ]
+  * Bump version to 1.7.1
+  * Gracefully handle creating a LibertineContainer object when the container
+    backend is unavailable.
+  * Update libertine xmir components to not depend on container backends.
+    (LP: #1671938)
+  * Catch all errors and gracefully shutdown libertined. (LP: #1671009)
+  * Fix method call from ContainerControl d-bus to interfaces.
+  * Update signal handlers in test_libertine_service to reflect new API.
+  * Inject client for accessing ContainerControl within containers.
+  * Rearchitect libertine service python backend for simpler access to running
+    tasks. (LP: #1669091)
+  * Ignore completions from dependencies during snapcraft build.
+  * LXD needs to forward host environment to container when running arbitrary
+    commands.
+  * Add client object to list_app_ids_task to avoid making reentrant service
+    calls.
+  * Take advantage of new network subcommand during lxd init on newer
+    installs.
+  * Prevent installing empty package names and appropriately update status for
+    unstopped containers.
+  * Modifications to make test_libertine_service more stable.
+  * Reopen the database file after every failure to grab the lock.
+    (LP: #1662655)
+
+ -- Larry Price <[e-mail]>  Tue, 14 Mar 2017 11:35:33 -0400
+
 libertine (1.7+17.04.20170320.1-0ubuntu1) zesty; urgency=medium
 
   * No change rebuild

=== modified file 'debian/control'
--- debian/control	2017-03-13 14:01:08 +0000
+++ debian/control	2017-03-31 20:05:48 +0000
@@ -9,6 +9,7 @@
                gobject-introspection,
                intltool,
                libcontent-hub-dev (>= 0.2),
+               libdbustest1-dev (>= 14.04.0),
                libgirepository1.0-dev,
                libglib2.0-dev,
                libgtest-dev,
@@ -61,7 +62,6 @@
 Depends: libertine-qt-common,
          libertine-tools,
          python3-libertine-lxd,
-         libsystemsettings1,
          ${misc:Depends},
          ${shlibs:Depends}
 Enhances: ubuntu-system-settings
@@ -74,7 +74,7 @@
 Architecture: any
 Depends: qml-module-qtquick2,
          qml-module-qtquick-dialogs,
-         qtdeclarative5-ubuntu-ui-toolkit-plugin,
+         qtdeclarative5-ubuntu-ui-toolkit-plugin | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles,
          ${misc:Depends},
          ${shlibs:Depends}
 Description: common files for qt-based libertine applications
@@ -84,13 +84,14 @@
 
 Package: libertine-tools
 Architecture: any
-Depends: libglib2.0-bin,
+Depends: libertine-xmir-tools (>= 1.7.1) [amd64 armhf arm64 i386],
+         libglib2.0-bin,
          python3-dbus,
          python3-libertine,
          ${misc:Depends},
          ${python3:Depends},
          ${shlibs:Depends}
-Recommends: libertine-xmir-tools (>= 1.4.3)
+Recommends: python3-libertine-lxd
 Breaks: libertine-demo
 Replaces: libertine-demo
 Description: CLI tools for running deb-packaged X11 apps on Ubuntu Personal
@@ -98,17 +99,14 @@
  the Ubuntu Personal sandbox for legacy Deb-packaged X11 applicatons.
 
 Package: libertine-xmir-tools
-Architecture: amd64 armhf arm64 i386
-Depends: libcontent-hub0,
-         libqt5core5a,
-         libqt5gui5,
-         libqt5widgets5,
+Architecture: any
+Depends: python3-libertine,
          xmir [amd64 armhf arm64 i386],
          ${misc:Depends},
          ${python3:Depends},
          ${shlibs:Depends}
-Breaks: libertine-tools (<< 1.4.3)
-Replaces: libertine-tools (<< 1.4.3)
+Breaks: libertine-tools (<< 1.7.1)
+Replaces: libertine-tools (<< 1.7.1)
 Description: helper apps for using and interacting with Xmir
  Helper applications for using and interacting with Xmir such as launching
  Xmir and allowing copy and paste.

=== modified file 'debian/libertine-tools.install'
--- debian/libertine-tools.install	2017-01-20 18:43:08 +0000
+++ debian/libertine-tools.install	2017-03-31 20:05:48 +0000
@@ -1,4 +1,3 @@
 usr/bin/libertine-container-manager
-usr/bin/libertine-launch
 usr/share/bash-completion/completions/libertine-container-manager
-usr/share/man
+usr/share/man/*/libertine-container-manager.1

=== modified file 'debian/libertine-xmir-tools.install'
--- debian/libertine-xmir-tools.install	2016-10-26 20:48:08 +0000
+++ debian/libertine-xmir-tools.install	2017-03-31 20:05:48 +0000
@@ -1,3 +1,7 @@
+usr/bin/libertine-launch
 usr/bin/libertine-xmir
 usr/bin/pasted
+usr/lib/python*/*/libertine/launcher
+usr/share/man/*/libertine-launch.1
+usr/share/man/*/libertine-xmir.1
 usr/share/upstart/sessions/libertine-xmir.conf

=== modified file 'debian/libertined.preinst'
--- debian/libertined.preinst	2017-03-06 16:15:27 +0000
+++ debian/libertined.preinst	2017-03-31 20:05:48 +0000
@@ -16,7 +16,7 @@
 
 if [ "$1" = "upgrade" ]; then
     echo "Shutting down the libertined service..."
-    pkill libertined
+    pkill -x libertined
 fi
 
 #DEBHELPER#

=== modified file 'debian/libertined.prerm'
--- debian/libertined.prerm	2017-03-06 16:15:27 +0000
+++ debian/libertined.prerm	2017-03-31 20:05:48 +0000
@@ -16,7 +16,7 @@
 
 if [ "$1" = "remove" ]; then
     echo "Shutting down the libertined service..."
-    pkill libertined
+    pkill -x libertined
 fi
 
 #DEBHELPER#

=== modified file 'debian/python3-libertine.install'
--- debian/python3-libertine.install	2017-02-15 21:12:37 +0000
+++ debian/python3-libertine.install	2017-03-31 20:05:48 +0000
@@ -1,7 +1,6 @@
-usr/lib/python*/*/libertine/Client.py
+usr/lib/python*/*/libertine/ContainerControlClient.py
 usr/lib/python*/*/libertine/ContainersConfig.py
 usr/lib/python*/*/libertine/HostInfo.py
 usr/lib/python*/*/libertine/Libertine.py
 usr/lib/python*/*/libertine/__init__.py
-usr/lib/python*/*/libertine/launcher
 usr/lib/python*/*/libertine/utils.py

=== modified file 'liblibertine/libertined.cpp'
--- liblibertine/libertined.cpp	2017-02-23 21:08:28 +0000
+++ liblibertine/libertined.cpp	2017-03-31 20:05:48 +0000
@@ -25,12 +25,16 @@
 #include <QJsonArray>
 #include <QJsonObject>
 
+
 namespace
 {
-constexpr auto SERVICE_INTERFACE = "com.canonical.libertine.Service";
-constexpr auto PROGRESS_INTERFACE = "com.canonical.libertine.Service.Progress";
-constexpr auto SESSION_DBUS_ENV_VAR = "DBUS_SESSION_BUS_ADDRESS";
-constexpr auto SERVICE_NAME = "libertined";
+constexpr auto SERVICE_INTERFACE            = "com.canonical.libertine.Service";
+constexpr auto OPERATIONS_INTERFACE         = "com.canonical.libertine.Service.Operations";
+constexpr auto OPERATIONS_OBJECT            = "/com/canonical/libertine/Service/Operations";
+constexpr auto OPERATIONS_MONITOR_INTERFACE = "com.canonical.libertine.Service.OperationsMonitor";
+constexpr auto OPERATIONS_MONITOR_OBJECT    = "/com/canonical/libertine/Service/OperationsMonitor";
+constexpr auto SESSION_DBUS_ENV_VAR         = "DBUS_SESSION_BUS_ADDRESS";
+constexpr auto SERVICE_NAME                 = "libertined";
 
 
 class SessionBus
@@ -69,7 +73,7 @@
 static bool
 isRunning(QDBusConnection const& bus, QString const& path)
 {
-  auto args = dbusCall(bus, PROGRESS_INTERFACE, path, "running", QVariantList());
+  auto args = dbusCall(bus, OPERATIONS_MONITOR_INTERFACE, OPERATIONS_MONITOR_OBJECT, "running", QVariantList{path});
 
   if (args.isEmpty())
   {
@@ -83,12 +87,12 @@
 static QString
 result(QDBusConnection const& bus, QString const& path)
 {
-  auto args = dbusCall(bus, PROGRESS_INTERFACE, path, "result");
+  auto args = dbusCall(bus, OPERATIONS_MONITOR_INTERFACE, OPERATIONS_MONITOR_OBJECT, "result", QVariantList{path});
 
   if (args.isEmpty())
   {
     qWarning() << "lastError - no arguments?";
-    return "";
+    return QString();
   }
 
   return args.first().toString();
@@ -97,12 +101,12 @@
 static QString
 lastError(QDBusConnection const& bus, QString const& path)
 {
-  auto args = dbusCall(bus, PROGRESS_INTERFACE, path, "last_error");
+  auto args = dbusCall(bus, OPERATIONS_MONITOR_INTERFACE, OPERATIONS_MONITOR_OBJECT, "last_error", QVariantList{path});
 
   if (args.isEmpty())
   {
     qWarning() << "lastError - no arguments?";
-    return "";
+    return QString();
   }
 
   return args.first().toString();
@@ -111,7 +115,7 @@
 static QString
 call(QDBusConnection const& bus, QString const& method, QVariantList const& args)
 {
-  auto results = dbusCall(bus, SERVICE_INTERFACE, "/Manager", method, args);
+  auto results = dbusCall(bus, OPERATIONS_INTERFACE, OPERATIONS_OBJECT, method, args);
 
   if (results.isEmpty())
   {
@@ -158,6 +162,7 @@
 }
 }
 
+
 QJsonArray
 libertined_list()
 {

=== modified file 'pasted/pasted.cpp'
--- pasted/pasted.cpp	2016-09-12 17:59:56 +0000
+++ pasted/pasted.cpp	2017-03-31 20:05:48 +0000
@@ -36,9 +36,8 @@
 constexpr auto UNITY_FOCUSINFO_METHOD = "isSurfaceFocused";
 
 
-static QString getPersistentSurfaceId()
+static QString getPersistentSurfaceId(Display *dpy, const Window& id)
 {
-  Display *dpy  = XOpenDisplay(NULL);
   Atom prop = XInternAtom(dpy, MIR_WM_PERSISTENT_ID, 0),
        type; // unused
   int form, // unused
@@ -48,7 +47,7 @@
   unsigned char *data = nullptr;
   QString persistentSurfaceId;
 
-  status = XGetWindowProperty(dpy, XDefaultRootWindow(dpy), prop, 0, 1024, 0,
+  status = XGetWindowProperty(dpy, id, prop, 0, 1024, 0,
                               XA_STRING, &type, &form, &len, &remain, &data);
 
   if (status)
@@ -60,56 +59,109 @@
     persistentSurfaceId = (const char *)data;
   }
 
-  XCloseDisplay(dpy);
   XFree(data);
 
   return persistentSurfaceId;
 }
 
+
+Display *checkXServer()
+{
+  char *display = getenv("DISPLAY");
+
+  if (display == nullptr)
+  {
+    qCritical() << "DISPLAY environment variable not set!";
+    exit(-1);
+  }
+
+  Display *dpy = XOpenDisplay(display);
+  if (dpy == nullptr)
+  {
+    qCritical() << "Xmir is not running on DISPLAY" << display << "!";
+    exit(-1);
+  }
+
+  return dpy;
+}
+
 } //anonymous namespace
 
 
+XEventWorker::
+XEventWorker(Display *dpy)
+: dpy_(dpy)
+{
+  unityFocus_ = new QDBusInterface(UNITY_FOCUSINFO_SERVICE,
+                                   UNITY_FOCUSINFO_PATH,
+                                   UNITY_FOCUSINFO_INTERFACE,
+                                   QDBusConnection::sessionBus(),
+                                   this);
+}
+
+
+XEventWorker::
+~XEventWorker()
+{
+  XCloseDisplay(dpy_);
+}
+
+
+bool XEventWorker::
+isSurfaceFocused(const Window& focus_window)
+{
+  surfaceId_ = getPersistentSurfaceId(dpy_, focus_window);
+
+  QDBusReply<bool> isFocused = unityFocus_->call(UNITY_FOCUSINFO_METHOD, surfaceId_);
+
+  return isFocused;
+}
+
+
 void XEventWorker::
 checkForAppFocus()
 {
   bool hasFocus = false;
+  int focus_state;
+  Window focus_window;
+
+  XGetInputFocus(dpy_, &focus_window, &focus_state);
+
+  if (focus_window > PointerRoot)
+  {
+    if (isSurfaceFocused(focus_window))
+    {
+      focusChanged(surfaceId_);
+      hasFocus = true;
+    }
+  }
+
+  XSelectInput(dpy_, XDefaultRootWindow(dpy_), FocusChangeMask);
+  
+  bool focused = false;
   XEvent event;
 
-  QDBusInterface *unityFocus = new QDBusInterface(UNITY_FOCUSINFO_SERVICE,
-                                                  UNITY_FOCUSINFO_PATH,
-                                                  UNITY_FOCUSINFO_INTERFACE,
-                                                  QDBusConnection::sessionBus(),
-                                                  this);
-
-  QString surfaceId = getPersistentSurfaceId();
-
-  QDBusReply<bool> isFocused = unityFocus->call(UNITY_FOCUSINFO_METHOD, surfaceId);
-
-  if (isFocused == true)
-  {
-    focusChanged();
-    hasFocus = true;
-  }
-
-  Display *dpy = XOpenDisplay(NULL);
-  XSelectInput(dpy, XDefaultRootWindow(dpy), FocusChangeMask);
-  
   while (1)
   {
-    XNextEvent(dpy, &event);
-
-    isFocused = unityFocus->call(UNITY_FOCUSINFO_METHOD, surfaceId);
-
-    if (hasFocus == false && isFocused == true)
-    {
-      qDebug() << "Surface is focused";
-      focusChanged();
-      hasFocus = true;
-    }
-    else if (hasFocus == true && isFocused == false)
-    {
-      qDebug() << "Surface lost focus";
-      hasFocus = false;
+    XNextEvent(dpy_, &event);
+
+    XGetInputFocus(dpy_, &focus_window, &focus_state);
+
+    if (focus_window > PointerRoot)
+    {
+      focused = isSurfaceFocused(focus_window);
+
+      if (hasFocus == false && focused == true)
+      {
+        qDebug() << "Surface is focused";
+        focusChanged(surfaceId_);
+        hasFocus = true;
+      }
+      else if (hasFocus == true && focused == false)
+      {
+        qDebug() << "Surface lost focus";
+        hasFocus = false;
+      }
     }
   }
 }
@@ -230,19 +282,19 @@
 
 
 void Pasted::
-setPersistentSurfaceId()
+setPersistentSurfaceId(const QString& surfaceId)
 {
-  if (persistentSurfaceId_.isEmpty())
+  if (persistentSurfaceId_ != surfaceId)
   {
-    persistentSurfaceId_ = getPersistentSurfaceId();
+    persistentSurfaceId_ = surfaceId;
   }
 }
 
 
 void Pasted::
-appFocused()
+appFocused(const QString& surfaceId)
 {
-  setPersistentSurfaceId();
+  setPersistentSurfaceId(surfaceId);
   handleContentHubPasteboard();
 }
 
@@ -252,10 +304,12 @@
 {
   qSetMessagePattern(QString("%{appname}: %{message}"));
 
+  Display *dpy = checkXServer();
+
   Pasted pasted(argc, argv);
 
   QThread t;
-  XEventWorker worker;
+  XEventWorker worker(dpy);
 
   worker.moveToThread(&t);
 

=== modified file 'pasted/pasted.h'
--- pasted/pasted.h	2016-09-12 17:59:56 +0000
+++ pasted/pasted.h	2017-03-31 20:05:48 +0000
@@ -39,14 +39,22 @@
   Q_OBJECT
 
   public:
-    XEventWorker() = default;
-    virtual ~XEventWorker() = default;
+    XEventWorker(Display *dpy);
+    virtual ~XEventWorker();
+
+  private:
+    bool isSurfaceFocused(const Window& focus_window);
 
   signals:
-    void focusChanged();
+    void focusChanged(const QString& surfaceId);
 
   public slots:
     void checkForAppFocus();
+
+  private:
+    Display *dpy_;
+    QDBusInterface *unityFocus_; 
+    QString surfaceId_;
 };
 
 
@@ -60,13 +68,13 @@
     virtual ~Pasted() = default;
 
   public slots:
-    void appFocused();
+    void appFocused(const QString& surfaceId);
 
   private:
     void updateLastMimeData(const QMimeData *source);
     void updateXMimeData(const QMimeData *source);
     void handleContentHubPasteboard();
-    void setPersistentSurfaceId();
+    void setPersistentSurfaceId(const QString& surfaceId);
 
     static bool compareMimeData(const QMimeData *a, const QMimeData *b);
     static void copyMimeData(QMimeData& target, const QMimeData *source);

=== modified file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	2017-02-27 20:47:21 +0000
+++ python/libertine/ChrootContainer.py	2017-03-31 20:05:48 +0000
@@ -47,8 +47,8 @@
     A concrete container type implemented using a plain old chroot.
     """
 
-    def __init__(self, container_id, config):
-        super().__init__(container_id, 'chroot', config)
+    def __init__(self, container_id, config, service):
+        super().__init__(container_id, 'chroot', config, service)
         # FIXME: Disabling seccomp is a temporary measure until we fully understand why we need
         #        it or figure out when we need it.
         os.environ['PROOT_NO_SECCOMP'] = '1'

=== renamed file 'python/libertine/Client.py' => 'python/libertine/ContainerControlClient.py'
--- python/libertine/Client.py	2017-02-24 14:56:36 +0000
+++ python/libertine/ContainerControlClient.py	2017-03-31 20:05:48 +0000
@@ -19,19 +19,24 @@
 from . import utils
 
 
-class Client(object):
+class ContainerControlClient(object):
+    """
+    A client for ContainerControl using D-BUS, to be used in clients
+    external to the libertine service.
+    """
     def __init__(self):
         self._get_manager()
 
     def _get_manager(self):
-        self._manager = None
+        self._control = None
 
         try:
-            from .service.manager import LIBERTINE_MANAGER_NAME, LIBERTINE_MANAGER_OBJECT
+            from .service import constants
+
             if utils.set_session_dbus_env_var():
                 bus = dbus.SessionBus()
-                self._manager = bus.get_object(LIBERTINE_MANAGER_NAME, LIBERTINE_MANAGER_OBJECT)
-                self._interface = LIBERTINE_MANAGER_NAME
+                self._control = bus.get_object(constants.SERVICE_NAME, constants.CONTAINER_CONTROL_OBJECT)
+                self._interface = constants.CONTAINER_CONTROL_INTERFACE
         except ImportError as e:
             utils.get_logger().warning("Libertine service libraries not installed.")
         except dbus.exceptions.DBusException as e:
@@ -51,11 +56,11 @@
 
     @property
     def valid(self):
-        return self._manager is not None
+        return self._control is not None
 
     def container_operation_start(self, id):
         retries = 0
-        while not self._do_operation(lambda: self._manager.get_dbus_method('container_operation_start', self._interface)(id)):
+        while not self._do_operation(lambda: self._control.get_dbus_method('start', self._interface)(id)):
             retries += 1
             if retries > 5:
                 return False
@@ -64,7 +69,7 @@
         return True
 
     def container_operation_finished(self, id, app_name, pid):
-        return self._do_operation(lambda: self._manager.get_dbus_method("container_operation_finished", self._interface)(id, app_name, pid))
+        return self._do_operation(lambda: self._control.get_dbus_method('finished', self._interface)(id, app_name, pid))
 
     def container_stopped(self, id):
-        return self._do_operation(lambda: self._manager.get_dbus_method('container_stopped', self._interface)(id))
+        return self._do_operation(lambda: self._control.get_dbus_method('stopped', self._interface)(id))

=== modified file 'python/libertine/ContainersConfig.py'
--- python/libertine/ContainersConfig.py	2017-02-23 21:08:28 +0000
+++ python/libertine/ContainersConfig.py	2017-03-31 20:05:48 +0000
@@ -14,42 +14,77 @@
 
 import fcntl
 import json
-import libertine.utils
 import os
 import sys
+import errno
+import time
+
 from hashlib import md5
-from libertine.HostInfo import HostInfo
+from . import utils, HostInfo
+
+class _ContainersConfigFile(object):
+    def __init__(self, readonly=True):
+        self._readonly = readonly
+
+        if readonly:
+            self._flags = 'r'
+        else:
+            self._flags = 'w'
+
+        self._fd = None
+
+    def __enter__(self):
+        container_config_file = utils.get_libertine_database_file_path()
+        if self._readonly and (not os.path.exists(container_config_file) or
+                               os.path.getsize(container_config_file) == 0):
+            return None
+
+        retries = 0
+        while retries < 100:
+            try:
+                fd = open(container_config_file, self._flags)
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+                self._fd = fd
+                return self._fd
+            except IOError as e:
+                if e.errno != errno.EAGAIN:
+                    raise
+                else:
+                    fd.close()
+                    retries += 1
+                    time.sleep(0.05)
+
+    def __exit__(self, *args):
+        if self._fd:
+            self._fd.close()
 
 
 def read_container_config_file():
     container_list = {}
-    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, 'r') as fd:
-            fcntl.flock(fd, fcntl.LOCK_EX)
+    with _ContainersConfigFile() as fd:
+        if fd is not None:
             container_list = json.load(fd)
 
     return container_list
 
 
 def write_container_config_file(container_list):
-    container_config_file = libertine.utils.get_libertine_database_file_path()
+    container_config_file = utils.get_libertine_database_file_path()
 
     # Add a warning to adventurous users advising against mucking with this file
     if container_list is not None:
         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.flock(fd, fcntl.LOCK_EX)
-        json.dump(container_list, fd, sort_keys=True, indent=4)
-        fd.write('\n')
+    with _ContainersConfigFile(False) as fd:
+        if fd:
+            json.dump(container_list, fd, sort_keys=True, indent=4)
+            fd.write('\n')
 
 
 def container_config_hash():
     checksum = md5()
-    container_config_file = libertine.utils.get_libertine_database_file_path()
+    container_config_file = 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 fd:
             fcntl.flock(fd, fcntl.LOCK_EX)
@@ -214,12 +249,12 @@
 
     def check_container_id(self, container_id):
         if container_id and not self.container_exists(container_id):
-            libertine.utils.get_logger().error("Container id \'%s\' does not exist." % container_id)
+            utils.get_logger().error("Container id '{container_id}' does not exist.".format(container_id=container_id))
             sys.exit(1)
         elif not container_id:
             container_id = self.get_default_container_id()
             if container_id is None:
-                libertine.utils.get_logger().error("No default container available.")
+                utils.get_logger().error("No default container available.")
                 sys.exit(1)
 
         return container_id
@@ -263,7 +298,7 @@
 
     def delete_container(self, container_id):
         if not self.container_list:
-            libertine.utils.get_logger().error("Unable to delete container.  No containers defined.")
+            utils.get_logger().error("Unable to delete container. No containers defined.")
             sys.exit(1)
 
         container = self._get_container_entry(container_id)

=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2017-03-03 15:34:16 +0000
+++ python/libertine/Libertine.py	2017-03-31 20:05:48 +0000
@@ -17,7 +17,7 @@
 import os
 import shutil
 
-from . import utils
+from . import utils, ContainerControlClient
 from libertine.ContainersConfig import ContainersConfig
 from libertine.HostInfo import HostInfo
 
@@ -79,10 +79,11 @@
 
     :param container_id: The machine-readable container name.
     """
-    def __init__(self, container_id, container_type, config):
+    def __init__(self, container_id, container_type, config, service):
         self.container_type = container_type
         self.container_id = container_id
         self._config = config
+        self._service = service
         self._app_name = ''
         self._pid = 0
         self.root_path = utils.get_libertine_container_rootfs_path(self.container_id)
@@ -332,8 +333,8 @@
     """
     A concrete mock container type.  Used for unit testing.
     """
-    def __init__(self, container_id, config):
-        super().__init__(container_id, 'mock', config)
+    def __init__(self, container_id, config, service):
+        super().__init__(container_id, 'mock', config, service)
 
     def create_libertine_container(self, password=None, multiarch=False):
         return True
@@ -386,7 +387,7 @@
     A sandbox for DEB-packaged X11-based applications.
     """
 
-    def __init__(self, container_id, containers_config=None):
+    def __init__(self, container_id, containers_config=None, service=None):
         """
         Initializes the container object.
 
@@ -394,23 +395,22 @@
         """
         super().__init__()
 
-        if containers_config is None:
-            containers_config = ContainersConfig()
-        self.containers_config = containers_config
+        self.containers_config = containers_config or ContainersConfig()
+        service = service or ContainerControlClient.ContainerControlClient()
 
         container_type = self.containers_config.get_container_type(container_id)
 
         if container_type == "lxc":
             from  libertine.LxcContainer import LibertineLXC
-            self.container = LibertineLXC(container_id, self.containers_config)
+            self.container = LibertineLXC(container_id, self.containers_config, service)
         elif container_type == "lxd":
             from libertine.LxdContainer import LibertineLXD
-            self.container = LibertineLXD(container_id, self.containers_config)
+            self.container = LibertineLXD(container_id, self.containers_config, service)
         elif container_type == "chroot":
             from  libertine.ChrootContainer import LibertineChroot
-            self.container = LibertineChroot(container_id, self.containers_config)
+            self.container = LibertineChroot(container_id, self.containers_config, service)
         elif container_type == "mock":
-            self.container = LibertineMock(container_id, self.containers_config)
+            self.container = LibertineMock(container_id, self.containers_config, service)
         else:
             raise RuntimeError("Unsupported container type %s" % container_type)
 
@@ -463,7 +463,10 @@
         try:
             with ContainerRunning(self.container):
                 self.containers_config.update_container_install_status(self.container_id, "installing packages")
-                return self.container.install_package(package_name, no_dialog, update_cache)
+                retval = self.container.install_package(package_name, no_dialog, update_cache)
+
+                self.containers_config.update_container_install_status(self.container_id, "running")
+                return retval
         except RuntimeError as e:
             return handle_runtime_error(e)
 
@@ -479,7 +482,10 @@
                     os.environ['DEBIAN_FRONTEND'] = 'teletype'
 
                 self.containers_config.update_container_install_status(self.container_id, "removing packages")
-                return self.container.remove_package(package_name)
+                retval = self.container.remove_package(package_name)
+
+                self.containers_config.update_container_install_status(self.container_id, "running")
+                return retval
         except RuntimeError as e:
             return handle_runtime_error(e)
 
@@ -547,7 +553,7 @@
                 for root, dirs, files in os.walk(apps_dir):
                     app_ids.extend(["{}_{}_0.0".format(self.container_id, f[:-8]) for f in files if f.endswith(".desktop")])
 
-        return app_ids
+        return sorted(app_ids)
 
     def exec_command(self, exec_line):
         """

=== modified file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	2017-03-03 15:34:16 +0000
+++ python/libertine/LxcContainer.py	2017-03-31 20:05:48 +0000
@@ -23,7 +23,7 @@
 import tempfile
 
 from .Libertine import BaseContainer
-from . import utils, HostInfo, Client
+from . import utils, HostInfo
 
 
 home_path = os.environ['HOME']
@@ -157,14 +157,12 @@
     A concrete container type implemented using an LXC container.
     """
 
-    def __init__(self, container_id, config):
-        super().__init__(container_id, 'lxc', config)
+    def __init__(self, container_id, config, service):
+        super().__init__(container_id, 'lxc', config, service)
         self.container = lxc_container(container_id)
         self.host_info = HostInfo.HostInfo()
         self._freeze_on_stop = config.get_freeze_on_stop(self.container_id)
 
-        self._manager = Client.Client()
-
     def _setup_pulse(self):
         pulse_socket_path = os.path.join(utils.get_libertine_runtime_dir(), 'pulse_socket')
 
@@ -213,7 +211,7 @@
             return fd.read().strip('\n') != self.host_info.get_host_timezone()
 
     def start_container(self):
-        if not self._manager.container_operation_start(self.container_id):
+        if not self._service.container_operation_start(self.container_id):
             return False
 
         if self.container.state == 'RUNNING':
@@ -236,11 +234,11 @@
         stopped = False
         self._config.refresh_database()
 
-        if self._manager.container_operation_finished(self.container_id, self._app_name, self._pid):
+        if self._service.container_operation_finished(self.container_id, self._app_name, self._pid):
             self._config.update_container_install_status(self.container_id, self._get_stop_type_string(self._freeze_on_stop))
 
             if lxc_stop(self.container, self._freeze_on_stop):
-                stopped = self._manager.container_stopped(self.container_id)
+                stopped = self._service.container_stopped(self.container_id)
 
             self._config.update_container_install_status(self.container_id, self.container.state.lower())
 
@@ -397,7 +395,7 @@
         os.environ.update(environ)
 
         if not self.start_container():
-            self._manager.container_stopped(self.container_id)
+            self._service.container_stopped(self.container_id)
             return
 
         self._app_name = app_exec_line[0]

=== modified file 'python/libertine/LxdContainer.py'
--- python/libertine/LxdContainer.py	2017-03-03 15:34:16 +0000
+++ python/libertine/LxdContainer.py	2017-03-31 20:05:48 +0000
@@ -22,7 +22,7 @@
 import subprocess
 import time
 
-from . import Libertine, utils, HostInfo, Client
+from . import Libertine, utils, HostInfo
 
 
 def _get_devices_map():
@@ -62,10 +62,11 @@
 
 def _setup_lxd():
     if utils.is_snap_environment():
-        utils.get_logger().warning("Running in snap environment, skipping automatic lxd setup.")
+        utils.get_logger().warning("Snapped libertine detected, you may need to run `sudo lxd init` manually.")
         return True
 
-    utils.get_logger().info("Running LXD setup.")
+    utils.get_logger().debug("Running LXD setup.")
+
     import pexpect
     child = pexpect.spawnu('sudo libertine-lxd-setup {}'.format(os.environ['USER']), env={'TERM': 'dumb'})
 
@@ -74,6 +75,7 @@
                               # The following are required for lxd=2.0.x
                               '.+\[yes/no\].*',
                               '.+\(e.g. (?P<example>[a-z0-9\.:]+)\).+'])
+
         if index == 0:
             child.sendline()
         elif index == 1:
@@ -383,8 +385,8 @@
 
 
 class LibertineLXD(Libertine.BaseContainer):
-    def __init__(self, name, config):
-        super().__init__(name, 'lxd', config)
+    def __init__(self, name, config, service):
+        super().__init__(name, 'lxd', config, service)
         self._host_info = HostInfo.HostInfo()
         self._container = None
         self._freeze_on_stop = config.get_freeze_on_stop(self.container_id)
@@ -392,15 +394,14 @@
         if not _setup_lxd():
             raise Exception("Failed to setup lxd.")
 
-        self._client = pylxd.Client()
-        self._manager = Client.Client()
+        self._lxd_client = pylxd.Client()
 
     def create_libertine_container(self, password=None, multiarch=False):
         if self._try_get_container():
             utils.get_logger().error("Container already exists")
             return False
 
-        update_libertine_profile(self._client)
+        update_libertine_profile(self._lxd_client)
 
         utils.get_logger().info("Creating container '%s' with distro '%s'" % (self.container_id, self.installed_release))
         create = subprocess.Popen(shlex.split('lxc launch ubuntu-daily:{distro} {id} --profile '
@@ -498,13 +499,13 @@
         return _lxc_args(self.container_id, command, environ)
 
     def run_in_container(self, command):
-        return subprocess.Popen(self._lxc_args(command)).wait()
+        return subprocess.Popen(self._lxc_args(command, os.environ.copy())).wait()
 
     def start_container(self, home=env_home_path()):
         if not self._try_get_container():
             return False
 
-        if not self._manager.container_operation_start(self.container_id):
+        if not self._service.container_operation_start(self.container_id):
             return False
 
         if self._container.status == 'Running':
@@ -513,12 +514,12 @@
         requires_remount = self._container.status == 'Stopped'
 
         if requires_remount:
-            update_libertine_profile(self._client)
+            update_libertine_profile(self._lxd_client)
             update_bind_mounts(self._container, self._config, home)
 
         self._config.update_container_install_status(self.container_id, "starting")
         if not lxd_start(self._container):
-            self._manager.container_stopped()
+            self._service.container_stopped()
             self._config.update_container_install_status(self.container_id, self._container.status.lower())
             return False
 
@@ -539,11 +540,11 @@
         stopped = False
         self._config.refresh_database()
 
-        if self._manager.container_operation_finished(self.container_id, self._app_name, self._pid):
+        if self._service.container_operation_finished(self.container_id, self._app_name, self._pid):
             self._config.update_container_install_status(self.container_id, self._get_stop_type_string(self._freeze_on_stop))
- 
+
             if lxd_stop(self._container, freeze_on_stop=self._freeze_on_stop):
-                stopped = self._manager.container_stopped(self.container_id)
+                stopped = self._service.container_stopped(self.container_id)
 
             self._config.update_container_install_status(self.container_id, self._container.status.lower())
 
@@ -598,6 +599,6 @@
 
     def _try_get_container(self):
         if self._container is None:
-            self._container = lxd_container(self._client, self.container_id)
+            self._container = lxd_container(self._lxd_client, self.container_id)
 
         return self._container is not None

=== added file 'python/libertine/service/constants.py'
--- python/libertine/service/constants.py	1970-01-01 00:00:00 +0000
+++ python/libertine/service/constants.py	2017-03-31 20:05:48 +0000
@@ -0,0 +1,27 @@
+# Copyright 2017 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/>.
+
+SERVICE_NAME                 = "com.canonical.libertine.Service"
+
+OPERATIONS_INTERFACE         = "com.canonical.libertine.Service.Operations"
+OPERATIONS_OBJECT            = "/com/canonical/libertine/Service/Operations"
+
+DOWNLOAD_INTERFACE           = "com.canonical.applications.Service.Download"
+DOWNLOAD_OBJECT              = "/com/canonical/libertine/Service/Download/%s"
+
+OPERATIONS_MONITOR_INTERFACE = "com.canonical.libertine.Service.OperationsMonitor"
+OPERATIONS_MONITOR_OBJECT    = "/com/canonical/libertine/Service/OperationsMonitor"
+
+CONTAINER_CONTROL_INTERFACE  = "com.canonical.libertine.Service.ContainerControl"
+CONTAINER_CONTROL_OBJECT     = "/com/canonical/libertine/Service/ContainerControl"

=== modified file 'python/libertine/service/container.py'
--- python/libertine/service/container.py	2017-02-07 12:35:48 +0000
+++ python/libertine/service/container.py	2017-03-31 20:05:48 +0000
@@ -22,11 +22,13 @@
 
 
 class Container(object):
-    def __init__(self, container_id, config, connection, callback):
+    def __init__(self, container_id, config, monitor, client, callback):
         self._id = container_id
-        self._connection = connection
+        self._config = config
+        self._monitor = monitor
+        self._client = client
         self._callback = callback
-        self._config = config
+
         self._lock = Lock()
         self._tasks = []
 
@@ -53,31 +55,6 @@
     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))
-
-        if utils.is_snap_environment():
-            raise Exception("This operation is not currently supported within the snap")
-
-        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))
-
-        if utils.is_snap_environment():
-            raise Exception("This operation is not currently supported within the snap")
-
-        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))
 
@@ -86,7 +63,7 @@
             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)
+        task = InstallTask(package_name, self.id, self._config, self._lock, self._monitor, self._client, self._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -99,7 +76,7 @@
             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)
+        task = RemoveTask(package_name, self.id, self._config, self._lock, self._monitor, self._client, self._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -113,7 +90,7 @@
             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._config, self._lock, self._monitor, self._client, self._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -126,7 +103,7 @@
             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)
+        task = DestroyTask(self.id, self._config, self._lock, self._monitor, self._client, self._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -139,15 +116,42 @@
             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)
+        task = UpdateTask(self.id, self._config, self._lock, self._monitor, self._client, self._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
 
+    # Tasks which don't require starting/stopping the container
+
     def list_app_ids(self):
         utils.get_logger().debug("List all app ids in container '%s'" % self.id)
 
-        task = ListAppIdsTask(self.id, self._config, self._connection, self._cleanup_task)
+        task = ListAppIdsTask(self.id, self._config, self._monitor, self._client, self._cleanup_task)
+
+        self._tasks.append(task)
+        task.start()
+        return task.id
+
+    def search(self, query):
+        utils.get_logger().debug("search container '%s' for package '%s'" % (self.id, query))
+
+        if utils.is_snap_environment():
+            raise Exception("This operation is not currently supported within the snap")
+
+        task = SearchTask(self.id, self._cache, query, self._monitor, 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))
+
+        if utils.is_snap_environment():
+            raise Exception("This operation is not currently supported within the snap")
+
+        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._monitor, self._cleanup_task)
 
         self._tasks.append(task)
         task.start()

=== renamed file 'python/libertine/service/operations_state.py' => 'python/libertine/service/container_control.py'
--- python/libertine/service/operations_state.py	2017-02-23 15:25:17 +0000
+++ python/libertine/service/container_control.py	2017-03-31 20:05:48 +0000
@@ -12,64 +12,35 @@
 # 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
-import psutil
-
-from collections import Counter
+
+import dbus
+
+from . import constants
 from libertine import utils
 
 
-class OperationsState(object):
-    def __init__(self):
-        self._get_running_apps_per_container()
-
-    def _get_running_apps_per_container(self):
-        self._invalid_apps = dict()
-        self._operations = Counter()
-        config = libertine.ContainersConfig.ContainersConfig()
-
-        for container in config.get_containers():
-            running_apps = config.get_running_apps(container).copy()
-
-            for app in running_apps:
-                try:
-                    proc = psutil.Process(app['pid'])
-                    if app['appExecName'] in proc.cmdline():
-                        self._operations[container] += 1
-                    else:
-                        raise
-                except:
-                    utils.get_logger().error("Container app {} is not valid.".format(app['appExecName']))
-                    if container not in self._invalid_apps:
-                        self._invalid_apps[container] = [{app['appExecName'], app['pid']}]
-                    else:
-                        self._invalid_apps[container].append({app['appExecName'], app['pid']})
-                    config.delete_running_app(container, app)
-                    continue
-
-    def operation_start(self, container):
-        if self._operations[container] == -1:
-            return False
-
-        self._operations[container] += 1
-
-        return True
-
-    def operation_finished(self, container, app_name, pid):
-        if container in self._invalid_apps and {app_name, pid} in self._invalid_apps[container]:
-            self._invalid_apps[container].remove({app_name, pid})
-            if not self._invalid_apps[container]:
-                del self._invalid_apps[container]
-        else:
-            self._operations[container] -= 1
-
-        if self._operations[container] == 0:
-            self._operations[container] = -1
-            return True
-
-        return False
-
-    def operation_stopped(self, container):
-        del self._operations[container]
-
-        return True
+class ContainerControl(dbus.service.Object):
+    def __init__(self, connection, client):
+        dbus.service.Object.__init__(self, conn=connection, object_path=constants.CONTAINER_CONTROL_OBJECT)
+        self._client = client
+
+    @dbus.service.method(constants.CONTAINER_CONTROL_INTERFACE,
+                         in_signature='s',
+                         out_signature='b')
+    def start(self, container):
+        utils.get_logger().debug("start({})".format(container))
+        return self._client.container_operation_start(container)
+
+    @dbus.service.method(constants.CONTAINER_CONTROL_INTERFACE,
+                         in_signature='ssi',
+                         out_signature='b')
+    def finished(self, container, app_name, pid):
+        utils.get_logger().debug("finished({})".format(container))
+        return self._client.container_operation_finished(container, app_name, pid)
+
+    @dbus.service.method(constants.CONTAINER_CONTROL_INTERFACE,
+                         in_signature='s',
+                         out_signature='b')
+    def stopped(self, container):
+        utils.get_logger().debug("stopped({})".format(container))
+        return self._client.container_stopped(container)

=== added file 'python/libertine/service/container_control_client.py'
--- python/libertine/service/container_control_client.py	1970-01-01 00:00:00 +0000
+++ python/libertine/service/container_control_client.py	2017-03-31 20:05:48 +0000
@@ -0,0 +1,75 @@
+# Copyright 2017 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
+import psutil
+
+from collections import Counter
+from libertine import utils
+
+
+class ContainerControlClient(object):
+    def __init__(self):
+        self._get_running_apps_per_container()
+
+    def _get_running_apps_per_container(self):
+        self._invalid_apps = dict()
+        self._operations = Counter()
+        config = libertine.ContainersConfig.ContainersConfig()
+
+        for container in config.get_containers():
+            running_apps = config.get_running_apps(container).copy()
+
+            for app in running_apps:
+                try:
+                    proc = psutil.Process(app['pid'])
+                    if app['appExecName'] in proc.cmdline():
+                        self._operations[container] += 1
+                    else:
+                        raise
+                except:
+                    utils.get_logger().error("Container app {} is not valid.".format(app['appExecName']))
+                    if container not in self._invalid_apps:
+                        self._invalid_apps[container] = [{app['appExecName'], app['pid']}]
+                    else:
+                        self._invalid_apps[container].append({app['appExecName'], app['pid']})
+                    config.delete_running_app(container, app)
+                    continue
+
+    def container_operation_start(self, container):
+        if self._operations[container] == -1:
+            return False
+
+        self._operations[container] += 1
+
+        return True
+
+    def container_operation_finished(self, container, app_name, pid):
+        if container in self._invalid_apps and {app_name, pid} in self._invalid_apps[container]:
+            self._invalid_apps[container].remove({app_name, pid})
+            if not self._invalid_apps[container]:
+                del self._invalid_apps[container]
+        else:
+            self._operations[container] -= 1
+
+        if self._operations[container] == 0:
+            self._operations[container] = -1
+            return True
+
+        return False
+
+    def container_stopped(self, container):
+        del self._operations[container]
+        return True

=== renamed file 'python/libertine/service/progress.py' => 'python/libertine/service/download.py'
--- python/libertine/service/progress.py	2017-01-24 18:00:57 +0000
+++ python/libertine/service/download.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016-2017 Canonical Ltd.
+# Copyright 2017 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
@@ -12,73 +12,68 @@
 # 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 . import constants
 from libertine import utils
 from time import time
 
-DOWNLOAD_INTERFACE = "com.canonical.applications.Download"
-PROGRESS_INTERFACE = "com.canonical.libertine.Service.Progress"
 
-class Progress(dbus.service.Object):
-    def __init__(self, connection):
-        utils.get_logger().debug("creating a Progress object")
+class Download(dbus.service.Object):
+    def __init__(self, connection, id):
         self._finished = False
-        self._result = []
+        self._result = ''
         self._error = ''
-        dbus.service.Object.__init__(self, conn=connection, object_path=("/Progress/%s" % hex(int(time()*10000000))[2:]))
-
-        # self.emit_processing() # Disabled until something requires the Download interface
-
-    @property
-    def id(self):
-        return self._object_path
-
+        dbus.service.Object.__init__(self, conn=connection, object_path=(constants.DOWNLOAD_OBJECT % id))
+
+        # Disabled until something requires the Download interface
+        # self.emit_processing()
+
+    # This is currently how services using the Ubuntu SDK to show progress
+    # determine whether or not an operation is running.
     def emit_processing(self):
         if not self.done:
             self.processing(self.id)
             threading.Timer(0.5, self.emit_processing).start()
 
     @property
+    def id(self):
+        return self._object_path
+
+    @property
     def done(self):
         return self._finished
 
-    @dbus.service.signal(DOWNLOAD_INTERFACE)
+    @property
+    def result(self):
+        return self._result.strip()
+
+    @property
+    def last_error(self):
+        return self._error
+
+    def data(self, message):
+        self._result += message + '\n'
+
+    # Signals to satisfy the download interface
+
+    @dbus.service.signal(constants.DOWNLOAD_INTERFACE, signature='o')
     def processing(self, path):
         utils.get_logger().debug("emit processing('%s')" % path)
 
-    @dbus.service.signal(DOWNLOAD_INTERFACE)
+    @dbus.service.signal(constants.DOWNLOAD_INTERFACE, signature='o')
     def finished(self, path):
         utils.get_logger().debug("emit finished('%s')" % path)
         self._finished = True
 
-    @dbus.service.signal(DOWNLOAD_INTERFACE)
+    @dbus.service.signal(constants.DOWNLOAD_INTERFACE)
     def progress(self, received, total):
         utils.get_logger().debug("emit progress(%d, %d)" % (received, total))
 
-    @dbus.service.signal(DOWNLOAD_INTERFACE)
+    @dbus.service.signal(constants.DOWNLOAD_INTERFACE, signature='s')
     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(not self.done)
-        return not self.done
-
-    @dbus.service.method(PROGRESS_INTERFACE, out_signature='s')
-    def result(self):
-        full_result = "\n".join(self._result)
-        utils.get_logger().debug(full_result)
-        return full_result
-
-    @dbus.service.method(PROGRESS_INTERFACE, out_signature='s')
-    def last_error(self):
-        utils.get_logger().debug(self._error)
-        return self._error

=== renamed file 'python/libertine/service/manager.py' => 'python/libertine/service/operations.py'
--- python/libertine/service/manager.py	2017-02-21 18:20:21 +0000
+++ python/libertine/service/operations.py	2017-03-31 20:05:48 +0000
@@ -12,69 +12,51 @@
 # 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
-import libertine.service.operations_state
-from dbus.mainloop.glib import DBusGMainLoop
-from libertine.service import container
+
+from . import constants, operations_monitor, task_dispatcher
 from libertine import utils
 
 
-LIBERTINE_MANAGER_NAME      = "com.canonical.libertine.Service"
-LIBERTINE_MANAGER_INTERFACE = LIBERTINE_MANAGER_NAME
-LIBERTINE_MANAGER_OBJECT    = "/Manager"
-
-
-class Manager(dbus.service.Object):
-    def __init__(self):
-        utils.get_logger().debug("creating service")
-        DBusGMainLoop(set_as_default=True)
-        self._operations_state = libertine.service.operations_state.OperationsState()
-
-        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_MANAGER_OBJECT)
-
-        self._dispatcher = libertine.service.task_dispatcher.TaskDispatcher(self.connection)
+class Operations(dbus.service.Object):
+    def __init__(self, bus_name, client):
+        super().__init__(bus_name, constants.OPERATIONS_OBJECT)
+
+        self._dispatcher = task_dispatcher.TaskDispatcher(operations_monitor.OperationsMonitor(self.connection), client)
 
     # Information
 
-    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
+    @dbus.service.method(constants.OPERATIONS_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,
+    @dbus.service.method(constants.OPERATIONS_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,
+    @dbus.service.method(constants.OPERATIONS_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,
+    @dbus.service.method(constants.OPERATIONS_INTERFACE,
                          in_signature='s',
                          out_signature='o')
     def list_app_ids(self, container_id):
         utils.get_logger().debug("list_app_ids('{}')".format(container_id))
         return self._dispatcher.list_app_ids(container_id)
 
-    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
+    @dbus.service.method(constants.OPERATIONS_INTERFACE,
                          out_signature='o')
     def list(self):
         utils.get_logger().debug("list()")
@@ -82,63 +64,37 @@
 
     # Operations
 
-    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
+    @dbus.service.method(constants.OPERATIONS_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,
+    @dbus.service.method(constants.OPERATIONS_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,
+    @dbus.service.method(constants.OPERATIONS_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,
+    @dbus.service.method(constants.OPERATIONS_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,
+    @dbus.service.method(constants.OPERATIONS_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)
-
-    # Container Lifecycle
-
-    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
-                         in_signature='s',
-                         out_signature='b')
-    def container_operation_start(self, container):
-        utils.get_logger().debug("container_operation_start({})".format(container))
-
-        return self._operations_state.operation_start(container)
-
-    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
-                         in_signature='ssi',
-                         out_signature='b')
-    def container_operation_finished(self, container, app_name='', pid=0):
-        utils.get_logger().debug("container_operation_finished({})".format(container))
-
-        return self._operations_state.operation_finished(container, app_name, pid)
-
-    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
-                         in_signature='s',
-                         out_signature='b')
-    def container_stopped(self, container):
-        utils.get_logger().debug("container_stopped({})".format(container))
-
-        return self._operations_state.operation_stopped(container)

=== added file 'python/libertine/service/operations_monitor.py'
--- python/libertine/service/operations_monitor.py	1970-01-01 00:00:00 +0000
+++ python/libertine/service/operations_monitor.py	2017-03-31 20:05:48 +0000
@@ -0,0 +1,93 @@
+# Copyright 2017 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
+import uuid
+
+from . import constants, download
+from libertine import utils
+from time import time
+
+
+class OperationsMonitor(dbus.service.Object):
+    def __init__(self, connection):
+        self._operations = []
+        dbus.service.Object.__init__(self, conn=connection, object_path=constants.OPERATIONS_MONITOR_OBJECT)
+
+    def new_operation(self):
+        self._operations.append(download.Download(self.connection, str(uuid.uuid4().fields[-1])))
+        return self._operations[-1].id
+
+    def remove_from_connection(self, path):
+        operation = self._operation(path)
+        self._operations.remove(operation)
+        operation.remove_from_connection()
+
+    def done(self, path):
+        op = self._operation(path)
+        if op:
+            return op.done
+        else:
+            return False
+
+    def _operation(self, path):
+        operations = [op for op in self._operations if op.id == path]
+        if not operations:
+            return None
+
+        return operations[0]
+
+    @dbus.service.signal(constants.OPERATIONS_MONITOR_INTERFACE, signature='o')
+    def finished(self, path):
+        op = self._operation(path)
+        if op:
+            op.finished(path)
+
+    @dbus.service.signal(constants.OPERATIONS_MONITOR_INTERFACE, signature='os')
+    def error(self, path, message):
+        op = self._operation(path)
+        if op:
+            op.error(message)
+
+    @dbus.service.signal(constants.OPERATIONS_MONITOR_INTERFACE, signature='os')
+    def data(self, path, message):
+        op = self._operation(path)
+        if op:
+            op.data(message)
+
+    @dbus.service.method(constants.OPERATIONS_MONITOR_INTERFACE, in_signature='o', out_signature='b')
+    def running(self, path):
+        op = self._operation(path)
+        if op:
+            return not op.done
+        else:
+            return False
+
+    @dbus.service.method(constants.OPERATIONS_MONITOR_INTERFACE, in_signature='o', out_signature='s')
+    def result(self, path):
+        op = self._operation(path)
+        if op:
+            return op.result
+        else:
+            return ''
+
+    @dbus.service.method(constants.OPERATIONS_MONITOR_INTERFACE, in_signature='o', out_signature='s')
+    def last_error(self, path):
+        op = self._operation(path)
+        if op:
+            return op.last_error
+        else:
+            return ''

=== modified file 'python/libertine/service/task_dispatcher.py'
--- python/libertine/service/task_dispatcher.py	2017-02-23 20:47:39 +0000
+++ python/libertine/service/task_dispatcher.py	2017-03-31 20:05:48 +0000
@@ -16,22 +16,13 @@
 import libertine.ContainersConfig
 from libertine.service.container import Container
 from libertine.service.tasks import *
-from threading import Lock
 from libertine import utils
 
 
-# Decorator to refresh database before making a call
-def _refresh_config(func):
-    def wrapper(*args, **kwargs):
-        args[0]._config.refresh_database()
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
 class TaskDispatcher(object):
-    def __init__(self, connection):
-        self._connection = connection
+    def __init__(self, monitor, client):
+        self._monitor = monitor
+        self._client = client
         self._config = libertine.ContainersConfig.ContainersConfig()
         self._containerless_tasks = []
         self._tasks = []
@@ -49,11 +40,13 @@
 
     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._connection, self._cleanup_container)
+
+        container = Container(container_id, self._config, self._monitor, self._client, self._cleanup_container)
         self._containers.append(container)
 
         return container
@@ -65,49 +58,40 @@
 
     # Tasks (usually) run within a container
 
-    @_refresh_config
     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)
 
-    @_refresh_config
     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)
 
-    @_refresh_config
     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)
 
-    @_refresh_config
     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)
 
-    @_refresh_config
     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)
 
-    @_refresh_config
     def destroy(self, container_id):
         utils.get_logger().debug("dispatching destroy container '%s'" % container_id)
         return self._find_or_create_container(container_id).destroy()
 
-    @_refresh_config
     def update(self, container_id):
         utils.get_logger().debug("dispatching update container '%s'" % container_id)
         return self._find_or_create_container(container_id).update()
 
-    @_refresh_config
     def list_app_ids(self, container_id):
         utils.get_logger().debug("dispatching list apps ids in container '%s'" % container_id)
         return self._find_or_create_container(container_id).list_app_ids()
 
     # Containerless Tasks
 
-    @_refresh_config
     def container_info(self, container_id):
         utils.get_logger().debug("dispatching get info for container '%s'" % container_id)
 
@@ -115,17 +99,16 @@
         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)
+        task = ContainerInfoTask(container_id, related_task_ids, self._config, self._monitor, self._cleanup_task)
         self._tasks.append(task)
         task.start()
 
         return task.id
 
-    @_refresh_config
     def list(self):
         utils.get_logger().debug("dispatching list all containers")
 
-        task = ListTask(self._config, self._connection, self._cleanup_task)
+        task = ListTask(self._config, self._monitor, self._cleanup_task)
         self._tasks.append(task)
         task.start()
 

=== modified file 'python/libertine/service/tasks/__init__.py'
--- python/libertine/service/tasks/__init__.py	2017-02-07 12:35:48 +0000
+++ python/libertine/service/tasks/__init__.py	2017-03-31 20:05:48 +0000
@@ -12,7 +12,7 @@
 # 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 .base_task import BaseTask, ContainerBaseTask
 from .app_info_task import AppInfoTask
 from .container_info_task import ContainerInfoTask
 from .create_task import CreateTask
@@ -27,6 +27,7 @@
 __all__ = [
           'AppInfoTask',
           'BaseTask',
+          'ContainerBaseTask',
           'ContainerInfoTask',
           'CreateTask',
           'DestroyTask',

=== modified file 'python/libertine/service/tasks/app_info_task.py'
--- python/libertine/service/tasks/app_info_task.py	2016-11-01 17:38:38 +0000
+++ python/libertine/service/tasks/app_info_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -18,8 +18,8 @@
 
 
 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)
+    def __init__(self, container_id, cache, app_id, tasks, config, monitor, callback):
+        super().__init__(lock=None, container_id=container_id, config=config, monitor=monitor, callback=callback)
         self._cache = cache
         self._app_id = app_id
         self._tasks = tasks
@@ -27,9 +27,9 @@
     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))
+            self._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))
+        self._data(str(app))

=== modified file 'python/libertine/service/tasks/base_task.py'
--- python/libertine/service/tasks/base_task.py	2017-02-17 17:39:13 +0000
+++ python/libertine/service/tasks/base_task.py	2017-03-31 20:05:48 +0000
@@ -12,8 +12,9 @@
 # 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
 
 
@@ -24,24 +25,21 @@
     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):
+    def __init__(self, lock, container_id, config, monitor, callback):
         self._lock = lock
         self._container = container_id
         self._config = config
         self._callback = callback
-        self._connection = connection
-        self._progress = None
-        self._instant_callback = False
+        self._monitor = monitor
+        self._operation_id = None
+        self._instant_callback = False # for testing
 
     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
+        return self._operation_id
 
     @property
     def container(self):
@@ -53,40 +51,67 @@
 
     @property
     def running(self):
-        return not self._progress.done
+        return not self._monitor.done(self._operation_id)
 
     def _delayed_callback(self):
         if self._instant_callback:
             self._callback(self)
         else:
-            threading.Timer(10, lambda: (self._progress.remove_from_connection(), self._callback(self))).start()
+            threading.Timer(10, lambda: (self._monitor.remove_from_connection(self._operation_id), self._callback(self))).start()
 
     def start(self):
-        self._progress = libertine.service.progress.Progress(self._connection)
+        self._operation_id = self._monitor.new_operation()
         thread = threading.Thread(target=self.run)
         thread.start()
         return thread
 
     def run(self):
+        self._refresh_database()
+
         if not self._before():
-            self._progress.finished(self.container)
+            self._monitor.finished(self._operation_id)
             self._delayed_callback()
             return
 
         if self._lock is not None:
             with self._lock:
+                self._refresh_database(False)
                 self._run()
         else:
+            self._refresh_database()
             self._run()
 
         if self.running:
-            self._progress.finished(self.container)
+            self._finished()
 
         self._delayed_callback()
 
+    def _refresh_database(self, require_lock=True):
+        if self._config:
+            if require_lock and self._lock is not None:
+                with self._lock:
+                    self._config.refresh_database()
+            else:
+                self._config.refresh_database()
+
     @abstractmethod
     def _run(self):
         pass
 
     def _before(self):
         return True
+
+    def _data(self, message):
+        self._monitor.data(self._operation_id, message)
+
+    def _finished(self):
+        self._monitor.finished(self._operation_id)
+
+    def _error(self, message):
+        self._monitor.error(self._operation_id, message)
+
+
+class ContainerBaseTask(BaseTask):
+    def __init__(self, lock, container_id, config, monitor, client, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config, monitor=monitor, callback=callback)
+        self._client = client

=== modified file 'python/libertine/service/tasks/container_info_task.py'
--- python/libertine/service/tasks/container_info_task.py	2017-01-18 20:08:47 +0000
+++ python/libertine/service/tasks/container_info_task.py	2017-03-31 20:05:48 +0000
@@ -20,8 +20,8 @@
 
 
 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)
+    def __init__(self, container_id, tasks, config, monitor, callback):
+        super().__init__(lock=None, container_id=container_id, config=config, monitor=monitor, callback=callback)
         self._tasks = tasks
 
     def _run(self):
@@ -35,11 +35,11 @@
         container['root'] = utils.get_libertine_container_rootfs_path(self._container)
         container['home'] = utils.get_libertine_container_home_dir(self._container)
 
-        self._progress.data(json.dumps(container))
+        self._data(json.dumps(container))
 
     def _before(self):
         if not self._config.container_exists(self._container):
-            self._progress.error("Container '%s' does not exist, ignoring info request" % self._container)
+            self._error("Container '%s' does not exist, ignoring info request" % self._container)
             return False
 
         return True

=== modified file 'python/libertine/service/tasks/create_task.py'
--- python/libertine/service/tasks/create_task.py	2017-02-24 15:05:33 +0000
+++ python/libertine/service/tasks/create_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -13,14 +13,16 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-from .base_task import BaseTask
+from .base_task import ContainerBaseTask
 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)
+class CreateTask(ContainerBaseTask):
+    def __init__(self, container_id, container_name, distro, container_type, enable_multiarch,
+                       config, lock, monitor, client, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config,
+                         monitor=monitor, client=client, callback=callback)
         self._name = container_name
         self._distro = distro
         self._type = container_type
@@ -30,35 +32,36 @@
         utils.get_logger().debug("Creating container '%s'" % self._container)
 
         try:
-            container = LibertineContainer(self._container, self._config)
+            container = LibertineContainer(self._container, self._config, self._client)
 
             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)
+                self._error("Creating container '%s' failed" % self._container)
             else:
                 self._config.update_container_install_status(self._container, "ready")
+                self._finished()
         except RuntimeError as e:
-            self._progress.error(str(e))
             self._config.delete_container(self._container)
+            self._error(str(e))
 
     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)
+            self._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)
+            self._error("Invalid distro '%s'." % self._distro)
             return False
 
         if not self._type:
             self._type = info.select_container_type_by_kernel()
         elif (self._type == 'lxd' and not info.has_lxd_support()) or \
              (self._type == 'lxc' and not info.has_lxc_support()):
-            self._progress.error("System kernel does not support %s type containers. "
+            self._error("System kernel does not support %s type containers. "
                                  "Please either use chroot or leave empty." % self._type)
             return False
 

=== modified file 'python/libertine/service/tasks/destroy_task.py'
--- python/libertine/service/tasks/destroy_task.py	2016-11-01 17:38:38 +0000
+++ python/libertine/service/tasks/destroy_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -13,29 +13,31 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-from .base_task import BaseTask
+from .base_task import ContainerBaseTask
 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)
+class DestroyTask(ContainerBaseTask):
+    def __init__(self, container_id, config, lock, monitor, client, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config,
+                         monitor=monitor, client=client, callback=callback)
 
     def _run(self):
         utils.get_logger().debug("Destroying container '%s'" % self._container)
 
-        container = LibertineContainer(self._container, self._config)
+        container = LibertineContainer(self._container, self._config, self._client)
         if not container.destroy_libertine_container():
-            self._progress.error("Destroying container '%s' failed" % self._container)
+            self._error("Destroying container '%s' failed" % self._container)
             self._config.update_container_install_status(self._container, "ready")
             return
 
         self._config.delete_container(self._container)
+        self._finished()
 
     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)
+            self._error("Container '%s' does not exist" % self._container)
             return False
 
         self._config.update_container_install_status(self._container, 'removing')

=== modified file 'python/libertine/service/tasks/install_task.py'
--- python/libertine/service/tasks/install_task.py	2016-11-08 15:45:54 +0000
+++ python/libertine/service/tasks/install_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -13,13 +13,14 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-from .base_task import BaseTask
+from .base_task import ContainerBaseTask
 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)
+class InstallTask(ContainerBaseTask):
+    def __init__(self, package_name, container_id, config, lock, monitor, client, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config,
+                         monitor=monitor, client=client, callback=callback)
         self._package = package_name
 
     def matches(self, package, klass):
@@ -31,17 +32,18 @@
 
     def _run(self):
         utils.get_logger().debug("Installing package '%s'" % self._package)
-        container = LibertineContainer(self._container, self._config)
+        container = LibertineContainer(self._container, self._config, self._client)
         if container.install_package(self._package):
             self._config.update_package_install_status(self._container, self._package, "installed")
+            self._finished()
         else:
             self._config.delete_package(self._container, self._package)
-            self._progress.error("Package installation failed for '%s'" % self._package)
+            self._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)
+            self._error("Package '%s' already exists, skipping install" % self._package)
             return False
         else:
             self._config.add_new_package(self._container, self._package)

=== modified file 'python/libertine/service/tasks/list_app_ids_task.py'
--- python/libertine/service/tasks/list_app_ids_task.py	2017-01-20 15:20:13 +0000
+++ python/libertine/service/tasks/list_app_ids_task.py	2017-03-31 20:05:48 +0000
@@ -14,22 +14,22 @@
 
 
 import json
-from .base_task import BaseTask
+from .base_task import ContainerBaseTask
 from libertine import LibertineContainer, utils
 import time
 
 
-class ListAppIdsTask(BaseTask):
-    def __init__(self, container_id, config, connection, callback):
-        super().__init__(lock=None, container_id=container_id, config=config, connection=connection, callback=callback)
+class ListAppIdsTask(ContainerBaseTask):
+    def __init__(self, container_id, config, monitor, client, callback):
+        super().__init__(lock=None, container_id=container_id, config=config, monitor=monitor, client=client, callback=callback)
 
     def _run(self):
         utils.get_logger().debug("Listing app ids from container '%s'" % self._container)
-        self._progress.data(json.dumps(LibertineContainer(self._container, self._config).list_app_ids()))
+        self._data(json.dumps(LibertineContainer(self._container, self._config, self._client).list_app_ids()))
 
     def _before(self):
         if not self._config.container_exists(self._container):
-            self._progress.error("Container '%s' does not exist, skipping list" % self._container)
+            self._error("Container '%s' does not exist, skipping list" % self._container)
             return False
 
         return True

=== modified file 'python/libertine/service/tasks/list_task.py'
--- python/libertine/service/tasks/list_task.py	2017-01-18 20:08:47 +0000
+++ python/libertine/service/tasks/list_task.py	2017-03-31 20:05:48 +0000
@@ -20,8 +20,9 @@
 
 
 class ListTask(BaseTask):
-    def __init__(self, config, connection, callback):
-        super().__init__(lock=None, container_id=None, config=config, connection=connection, callback=callback)
+    def __init__(self, config, monitor, callback):
+        super().__init__(lock=None, container_id=None, config=config, monitor=monitor, callback=callback)
 
     def _run(self):
-        self._progress.data(json.dumps(self._config.get_containers()))
+        self._data(json.dumps(self._config.get_containers()))
+        self._finished()

=== modified file 'python/libertine/service/tasks/remove_task.py'
--- python/libertine/service/tasks/remove_task.py	2016-11-08 15:45:54 +0000
+++ python/libertine/service/tasks/remove_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -13,13 +13,13 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-from .base_task import BaseTask
+from .base_task import ContainerBaseTask
 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)
+class RemoveTask(ContainerBaseTask):
+    def __init__(self, package_name, container_id, config, lock, monitor, client, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config, monitor=monitor, client=client, callback=callback)
         self._package = package_name
 
     def matches(self, package, klass):
@@ -31,12 +31,13 @@
 
     def _run(self):
         utils.get_logger().debug("Removing package '%s'" % self._package)
-        container = LibertineContainer(self._container, self._config)
+        container = LibertineContainer(self._container, self._config, self._client)
         if container.remove_package(self._package):
             self._config.delete_package(self._container, self._package)
+            self._finished()
         else:
             self._config.update_package_install_status(self._container, self._package, 'installed')
-            self._progress.error("Package removal failed for '%s'" % self._package)
+            self._error("Package removal failed for '%s'" % self._package)
 
     def _before(self):
         utils.get_logger().debug("RemoveTask::_before")
@@ -44,5 +45,5 @@
             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)
+            self._error("Package '%s' not installed, skipping remove" % self._package)
             return False

=== modified file 'python/libertine/service/tasks/search_task.py'
--- python/libertine/service/tasks/search_task.py	2016-11-01 19:49:32 +0000
+++ python/libertine/service/tasks/search_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -18,10 +18,10 @@
 
 
 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)
+    def __init__(self, container_id, cache, query, monitor, callback):
+        super().__init__(lock=None, container_id=container_id, config=None, monitor=monitor, callback=callback)
         self._cache = cache
         self._query = query
 
     def _run(self):
-        self._progress.data(str(self._cache.search(self._query)))
+        self._data(str(self._cache.search(self._query)))

=== modified file 'python/libertine/service/tasks/update_task.py'
--- python/libertine/service/tasks/update_task.py	2016-11-08 15:37:58 +0000
+++ python/libertine/service/tasks/update_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -13,27 +13,28 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-from .base_task import BaseTask
+from .base_task import ContainerBaseTask
 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)
+class UpdateTask(ContainerBaseTask):
+    def __init__(self, container_id, config, lock, monitor, client, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config,
+                         monitor=monitor, client=client, callback=callback)
 
     def _run(self):
         utils.get_logger().debug("Updating container '%s'" % self._container)
-        container = LibertineContainer(self._container, self._config)
+        container = LibertineContainer(self._container, self._config, self._client)
         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._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)
+            self._error("Container '%s' does not exist, skipping update" % self._container)
             return False
-        else:
-            return True
+
+        return True

=== modified file 'snap/plugins/x-libertine-deps.py'
--- snap/plugins/x-libertine-deps.py	2017-02-14 19:17:30 +0000
+++ snap/plugins/x-libertine-deps.py	2017-03-31 20:05:48 +0000
@@ -145,7 +145,8 @@
             '-usr/lib/{}/liblibertine.so*'.format(self._arch),
             '-usr/bin/libertine*',
             '-etc/sudoers.d/libertine*',
-            '-usr/lib/python3/dist-packages/libertine'
+            '-usr/lib/python3/dist-packages/libertine',
+            '-usr/share/bash-completion/completions/*'
         ])
 
     def build(self):

=== modified file 'snap/snap-runner.wrapper' (properties changed: -x to +x)
=== modified file 'tests/integration/CMakeLists.txt'
--- tests/integration/CMakeLists.txt	2017-03-06 15:33:12 +0000
+++ tests/integration/CMakeLists.txt	2017-03-31 20:05:48 +0000
@@ -1,4 +1,24 @@
 add_test(test_libertine_service dbus-run-session -- /usr/bin/python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_libertine_service.py)
 set_tests_properties(test_libertine_service
                      PROPERTIES ENVIRONMENT
-                   "PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;LIBERTINE_DATA_DIR=${CMAKE_CURRENT_SOURCE_DIR};PATH=${CMAKE_SOURCE_DIR}/tools:$ENV{PATH};")
+                   "LIBERTINE_DEBUG=2;PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;;PATH=${CMAKE_SOURCE_DIR}/tools:$ENV{PATH};XDG_DATA_HOME=/tmp")
+
+add_executable(
+  test_liblibertine
+  test_liblibertine.cpp
+)
+
+target_link_libraries(
+  test_liblibertine
+  ${LIBERTINE_CORE}
+  gtest gtest_main
+  ${DBUSTEST_LIBRARIES}
+  ${GIO2_LIBRARIES}
+  Qt5::Core
+)
+
+add_test(test_liblibertine test_liblibertine)
+
+set_tests_properties(test_liblibertine
+                     PROPERTIES ENVIRONMENT
+                   "PYTHONPATH=${CMAKE_SOURCE_DIR}/python;PATH=${CMAKE_SOURCE_DIR}/tools:$ENV{PATH};XDG_DATA_HOME=${CMAKE_CURRENT_SOURCE_DIR}/data;XDG_CACHE_HOME=${CMAKE_CURRENT_SOURCE_DIR}/data")

=== added directory 'tests/integration/data'
=== added directory 'tests/integration/data/libertine'
=== added directory 'tests/integration/data/libertine-container'
=== added directory 'tests/integration/data/libertine-container/padme'
=== added directory 'tests/integration/data/libertine-container/padme/rootfs'
=== added directory 'tests/integration/data/libertine-container/padme/rootfs/usr'
=== added directory 'tests/integration/data/libertine-container/padme/rootfs/usr/share'
=== added directory 'tests/integration/data/libertine-container/padme/rootfs/usr/share/applications'
=== added file 'tests/integration/data/libertine-container/padme/rootfs/usr/share/applications/dagobah.desktop'
=== added file 'tests/integration/data/libertine-container/padme/rootfs/usr/share/applications/tatooine.desktop'
=== added directory 'tests/integration/data/libertine-container/user-data'
=== added directory 'tests/integration/data/libertine-container/user-data/padme'
=== added file 'tests/integration/data/libertine/ContainersConfig.json'
--- tests/integration/data/libertine/ContainersConfig.json	1970-01-01 00:00:00 +0000
+++ tests/integration/data/libertine/ContainersConfig.json	2017-03-31 20:05:48 +0000
@@ -0,0 +1,19 @@
+{
+  "containerList": [
+    {
+      "id": "jarjar",
+      "name": "JarJar Binks",
+      "type": "mock"
+    },
+    {
+      "id": "padme",
+      "name": "Padme Amedala",
+      "type": "mock"
+    },
+    {
+      "id": "anakin",
+      "name": "Anakin Skywalker",
+      "type": "mock"
+    }
+  ]
+}

=== modified file 'tests/integration/test_libertine_service.py'
--- tests/integration/test_libertine_service.py	2017-03-06 15:33:12 +0000
+++ tests/integration/test_libertine_service.py	2017-03-31 20:05:48 +0000
@@ -26,7 +26,7 @@
 
 from gi.repository import GLib
 from libertine import utils
-from libertine.service import tasks, apt
+from libertine.service import tasks, apt, constants
 from libertine.ContainersConfig import ContainersConfig
 from subprocess import Popen, PIPE
 from unittest import TestCase
@@ -42,18 +42,14 @@
     def setUpClass(cls):
         cls._tempdir = tempfile.TemporaryDirectory()
 
-        environ = os.environ.copy()
-        environ['XDG_DATA_HOME'] = cls._tempdir.name
-
-        cls._process = pexpect.spawnu('libertined --debug', env=environ)
+        os.environ['XDG_DATA_HOME'] = cls._tempdir.name
+        cls._process = pexpect.spawnu('libertined --debug', env=os.environ.copy())
         cls._process.logfile = sys.stdout
 
         # give libertined enough time to start the whole process
-        verbosity = environ.get('LIBERTINE_DEBUG', '1')
-        if verbosity == '1':
-            cls._process.expect(['.+\n', pexpect.TIMEOUT], timeout=1)
-        elif environ['LIBERTINE_DEBUG'] == '2':
-            cls._process.expect(['.+\n.+\n.+\n', pexpect.TIMEOUT], timeout=1)
+        verbosity = os.environ.get('LIBERTINE_DEBUG', '1')
+        if verbosity != '0':
+            cls._process.expect(['libertined ready', pexpect.TIMEOUT], timeout=5)
 
         dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
         cls._loop = GLib.MainLoop()
@@ -68,14 +64,25 @@
         cls._tempdir.cleanup()
 
     def setUp(self):
+        os.environ['XDG_DATA_HOME'] = TestLibertineService._tempdir.name
         self.error = None
         self.result = None
         self.event = threading.Event()
+        self.signals = []
 
         for retries in range(1, 11):
             try:
                 self._bus =  dbus.SessionBus()
-                self._libertined = self._bus.get_object('com.canonical.libertine.Service', '/Manager')
+                self.path = None
+
+                self._libertined = self._bus.get_object(constants.SERVICE_NAME, constants.OPERATIONS_OBJECT)
+
+                self.signals.append(self._bus.add_signal_receiver(path=constants.OPERATIONS_MONITOR_OBJECT, handler_function=self._finished_handler,
+                                        dbus_interface=constants.OPERATIONS_MONITOR_INTERFACE, signal_name='finished'))
+                self.signals.append(self._bus.add_signal_receiver(path=constants.OPERATIONS_MONITOR_OBJECT, handler_function=self._data_handler,
+                                         dbus_interface=constants.OPERATIONS_MONITOR_INTERFACE, signal_name='data'))
+                self.signals.append(self._bus.add_signal_receiver(path=constants.OPERATIONS_MONITOR_OBJECT, handler_function=self._error_handler,
+                                         dbus_interface=constants.OPERATIONS_MONITOR_INTERFACE, signal_name='error'))
                 break
             except dbus.DBusException as e:
                 print("Service not available (attempt %i/10). Exception: %s" % (retries, str(e)))
@@ -85,39 +92,35 @@
             except Exception as e:
                 self.fail('Exception occurred during connection: %s' % str(e))
 
+    def tearDown(self):
+        for signal in self.signals:
+            signal.remove()
+
     def _finished_handler(self, path):
-        self.event.set()
-
-    def _data_handler(self, message):
-        self.result = message
-
-    def _error_handler(self, message):
-        self.error = message
-        self.event.set()
+        if self.path == path:
+            self.event.set()
+
+    def _data_handler(self, path, message):
+        if self.path == path:
+            self.result = message
+
+    def _error_handler(self, path, message):
+        if self.path == path:
+            self.error = message
+            self.event.set()
 
     def _send(self, func):
         self.event.clear()
         self.result = None
 
-        obj_path = func()
-        signals = []
-        signals.append(self._bus.add_signal_receiver(path=obj_path, handler_function=self._finished_handler,
-                                dbus_interface='com.canonical.applications.Download', signal_name='finished'))
-        signals.append(self._bus.add_signal_receiver(path=obj_path, handler_function=self._data_handler,
-                                 dbus_interface='com.canonical.libertine.Service.Progress', signal_name='data'))
-        signals.append(self._bus.add_signal_receiver(path=obj_path, handler_function=self._error_handler,
-                                 dbus_interface='com.canonical.applications.Download', signal_name='error'))
-
-        task = self._bus.get_object('com.canonical.libertine.Service', obj_path)
-        if task.running():
-            self.event.wait(5)
-            self.assertIsNone(self.error)
-
-        self.assertEqual('', task.get_dbus_method('last_error', 'com.canonical.libertine.Service.Progress')())
-        self.result = task.get_dbus_method('result', 'com.canonical.libertine.Service.Progress')()
-
-        for signal in signals:
-            self._bus._clean_up_signal_match(signal)
+        monitor = self._bus.get_object(constants.SERVICE_NAME, constants.OPERATIONS_MONITOR_OBJECT)
+        self.path = func()
+
+        while monitor.running(self.path):
+            self.event.wait(.1)
+
+        self.assertEqual('', monitor.last_error(self.path))
+        self.result = monitor.result(self.path)
 
         return self.result
 

=== added file 'tests/integration/test_liblibertine.cpp'
--- tests/integration/test_liblibertine.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration/test_liblibertine.cpp	2017-03-31 20:05:48 +0000
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2017 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 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/>.
+ */
+
+#include "liblibertine/libertine.h"
+#include <cstdlib>
+#include <gio/gio.h>
+#include <gtest/gtest.h>
+#include <libdbustest/dbus-test.h>
+#include <memory>
+#include <QtCore/QByteArray>
+#include <QtCore/QJsonDocument>
+#include <QtCore/QJsonParseError>
+
+class LiblibertineTest : public ::testing::Test
+{
+protected:
+  static void SetUpTestCase()
+  {
+    process = dbus_test_process_new("libertined");
+    dbus_test_process_append_param(process, "--debug");
+
+    dbus_test_task_set_bus(DBUS_TEST_TASK(process), DBUS_TEST_SERVICE_BUS_SESSION);
+    dbus_test_task_set_name(DBUS_TEST_TASK(process), "libertine");
+    dbus_test_task_set_return(DBUS_TEST_TASK(process), DBUS_TEST_TASK_RETURN_IGNORE);
+    dbus_test_task_set_wait_finished(DBUS_TEST_TASK(process), FALSE);
+
+    wait = dbus_test_task_new();
+    dbus_test_task_set_wait_for(wait, "com.canonical.libertine.Service");
+
+    service = dbus_test_service_new(nullptr);
+    dbus_test_service_add_task(service, DBUS_TEST_TASK(process));
+    dbus_test_service_add_task(service, wait);
+
+    dbus_test_service_start_tasks(service);
+
+    bus = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, nullptr);
+    g_dbus_connection_set_exit_on_close(bus, FALSE);
+    g_object_add_weak_pointer(G_OBJECT(bus), (gpointer*)&bus);
+  }
+
+  static void TearDownTestCase()
+  {
+    g_clear_object(&process);
+    g_clear_object(&wait);
+
+    g_clear_object(&service);
+    g_object_unref(bus);
+  }
+
+private:
+  static DbusTestProcess* process;
+  static DbusTestTask* wait;
+  static DbusTestService* service;
+  static GDBusConnection* bus;
+};
+
+
+DbusTestProcess* LiblibertineTest::process = nullptr;
+DbusTestTask* LiblibertineTest::wait = nullptr;
+DbusTestService* LiblibertineTest::service = nullptr;
+GDBusConnection* LiblibertineTest::bus = nullptr;
+
+
+TEST_F(LiblibertineTest, libertine_list_containers)
+{
+  auto scontainers = std::shared_ptr<gchar*>(libertine_list_containers(), g_strfreev);
+  auto containers = scontainers.get();
+
+  ASSERT_NE(containers[0], nullptr);
+  EXPECT_STREQ(containers[0], "jarjar");
+
+  ASSERT_NE(containers[1], nullptr);
+  EXPECT_STREQ(containers[1], "padme");
+
+  ASSERT_NE(containers[2], nullptr);
+  EXPECT_STREQ(containers[2], "anakin");
+
+  ASSERT_EQ(containers[3], nullptr);
+}
+
+
+TEST_F(LiblibertineTest, libertine_list_app_ids)
+{
+  auto sapps = std::shared_ptr<gchar*>(libertine_list_apps_for_container("padme"), g_strfreev);
+  auto apps = sapps.get();
+
+  ASSERT_NE(apps[0], nullptr);
+  EXPECT_STREQ(apps[0], "padme_dagobah_0.0");
+
+  ASSERT_NE(apps[1], nullptr);
+  EXPECT_STREQ(apps[1], "padme_tatooine_0.0");
+
+  ASSERT_EQ(apps[2], nullptr);
+}
+
+
+TEST_F(LiblibertineTest, libertine_container_name)
+{
+  auto actual = libertine_container_name("padme");
+  EXPECT_STREQ("Padme Amedala", actual);
+  g_free(actual);
+}
+
+
+TEST_F(LiblibertineTest, libertine_container_path)
+{
+  auto actual = libertine_container_path("padme");
+  auto expected = QString(getenv("XDG_CACHE_HOME")) + "/libertine-container/padme/rootfs";
+  EXPECT_STREQ(expected.toUtf8(), actual);
+  g_free(actual);
+}
+
+
+TEST_F(LiblibertineTest, libertine_container_path_returns_empty)
+{
+  EXPECT_EQ(nullptr, libertine_container_path("jarjar"));
+}
+
+
+TEST_F(LiblibertineTest, libertine_container_home_path)
+{
+  auto actual = libertine_container_home_path("padme");
+  auto expected = QString(getenv("XDG_DATA_HOME")) + "/libertine-container/user-data/padme";
+  EXPECT_STREQ(expected.toUtf8(), actual);
+  g_free(actual);
+}
+
+
+TEST_F(LiblibertineTest, libertine_container_home_path_returns_empty)
+{
+  EXPECT_EQ(nullptr, libertine_container_home_path("jarjar"));
+}

=== modified file 'tests/unit/CMakeLists.txt'
--- tests/unit/CMakeLists.txt	2017-02-13 21:41:36 +0000
+++ tests/unit/CMakeLists.txt	2017-03-31 20:05:48 +0000
@@ -8,9 +8,10 @@
   ContainerConfigListTests.cpp
   ContainersConfigTests.cpp
 )
+
 target_link_libraries(
   test_container_config
-  libertine-common
+  ${LIBERTINE_COMMON}
   gtest gtest_main
   Qt5::Core
 )

=== modified file 'tests/unit/ContainerConfigListTests.cpp'
--- tests/unit/ContainerConfigListTests.cpp	2017-02-08 14:57:34 +0000
+++ tests/unit/ContainerConfigListTests.cpp	2017-03-31 20:05:48 +0000
@@ -34,6 +34,7 @@
   EXPECT_EQ(container_configs.size(), 0);
 }
 
+
 /** Verify constructing a ContainerConfig from JSON DTRT. */
 TEST(LibertineContainerConfigList, constructFromJson)
 {

=== modified file 'tests/unit/service/CMakeLists.txt'
--- tests/unit/service/CMakeLists.txt	2016-11-04 13:49:40 +0000
+++ tests/unit/service/CMakeLists.txt	2017-03-31 20:05:48 +0000
@@ -1,5 +1,5 @@
 function(create_service_unit_test test_name)
-  add_test(${test_name} /usr/bin/python3 -m testtools.run ${test_name})
+  add_test(${test_name} /usr/bin/python3 ${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.py)
   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}")
@@ -8,5 +8,6 @@
 create_service_unit_test(test_container)
 create_service_unit_test(test_apt)
 create_service_unit_test(test_task_dispatcher)
+create_service_unit_test(test_operations_monitor)
 
 add_subdirectory(tasks)

=== modified file 'tests/unit/service/tasks/test_app_info_task.py'
--- tests/unit/service/tasks/test_app_info_task.py	2016-11-07 18:51:17 +0000
+++ tests/unit/service/tasks/test_app_info_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -15,7 +15,7 @@
 
 import unittest.mock
 from unittest import TestCase
-from libertine.service import tasks, apt
+from libertine.service import tasks, apt, operations_monitor
 from libertine.ContainersConfig import ContainersConfig
 
 
@@ -23,39 +23,37 @@
     def setUp(self):
         self.config     = unittest.mock.create_autospec(ContainersConfig)
         self.cache      = unittest.mock.create_autospec(apt.AptCache)
-        self.connection = unittest.mock.Mock()
+        self.monitor    = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
 
     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)
+        self.cache.app_info.return_value = {}
+        task = tasks.AppInfoTask('palpatine', self.cache, 'lightside', [1, 2], self.config, self.monitor, callback)
+        task._instant_callback = True
+        task.start().join()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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)
+        self.monitor.done.return_value = 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.monitor, callback)
+        task._instant_callback = True
+        task.start().join()
+
+        self.monitor.data.assert_called_once_with(self.monitor.new_operation.return_value, str({'package': 'darkside-common', 'status': 'installed', 'task_ids': [1, 2, 3]}))
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+
+        self.assertEqual(task, self.called_with)

=== modified file 'tests/unit/service/tasks/test_container_info_task.py'
--- tests/unit/service/tasks/test_container_info_task.py	2017-01-27 16:42:22 +0000
+++ tests/unit/service/tasks/test_container_info_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -17,40 +17,39 @@
 import unittest.mock
 from unittest import TestCase
 from libertine import utils
-from libertine.service import tasks
+from libertine.service import tasks, operations_monitor
 from libertine.ContainersConfig import ContainersConfig
 
 
 class TestContainerInfoTask(TestCase):
     def setUp(self):
-        self.config     = unittest.mock.create_autospec(ContainersConfig)
-        self.connection = unittest.mock.Mock()
+        self.config   = unittest.mock.create_autospec(ContainersConfig)
+        self.monitor  = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
 
     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_container_install_status.return_value = 'ready'
-            self.config.get_container_name.return_value = 'Palpatine'
-            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(unittest.mock.ANY)
-            args, kwargs = progress.data.call_args
-            self.assertEqual({'id': 'palpatine',
-                              'status': 'ready',
-                              'task_ids': [1, 2, 3],
-                              'name': 'Palpatine',
-                              'root': utils.get_libertine_container_rootfs_path('palpatine'),
-                              'home': utils.get_libertine_container_home_dir('palpatine')},
-                        ast.literal_eval(args[0]))
-
-            progress.finished.assert_called_once_with('palpatine')
-
-            self.assertEqual(task, self.called_with)
+        self.monitor.done.return_value = False
+
+        self.config.get_container_install_status.return_value = 'ready'
+        self.config.get_container_name.return_value = 'Palpatine'
+        task = tasks.ContainerInfoTask('palpatine', [1, 2, 3], self.config, self.monitor, callback)
+        task._instant_callback = True
+        task.start().join()
+
+        self.monitor.data.assert_called_once_with(self.monitor.new_operation.return_value, unittest.mock.ANY)
+        args, kwargs = self.monitor.data.call_args
+        self.assertEqual({'id': 'palpatine',
+                          'status': 'ready',
+                          'task_ids': [1, 2, 3],
+                          'name': 'Palpatine',
+                          'root': utils.get_libertine_container_rootfs_path('palpatine'),
+                          'home': utils.get_libertine_container_home_dir('palpatine')},
+                    ast.literal_eval(args[1]))
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+
+        self.assertEqual(task, self.called_with)

=== modified file 'tests/unit/service/tasks/test_create_task.py'
--- tests/unit/service/tasks/test_create_task.py	2016-11-07 18:51:17 +0000
+++ tests/unit/service/tasks/test_create_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -15,15 +15,18 @@
 
 import unittest.mock
 from unittest import TestCase
-from libertine.service import tasks
+from libertine.service import tasks, operations_monitor
 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.config  = unittest.mock.create_autospec(ContainersConfig)
+        self.lock    = unittest.mock.MagicMock()
+        self.client  = unittest.mock.Mock()
+        self.monitor = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
         self.called_with = None
 
     def callback(self, task):
@@ -31,204 +34,195 @@
 
     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)
+        self.monitor.done.return_value = False
+        task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False,
+                                self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)
+        self.monitor.done.return_value = False
+        task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'chroot', False,
+                                self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)
+        task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False,
+                                self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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()
+        task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False,
+                                self.config, self.lock, self.monitor, self.client, 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)
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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()
+        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.monitor, self.client, self.callback)
+            task._instant_callback = True
+            task.start().join()
 
-            progress.error.assert_called_once_with('Invalid distro \'vesty\'.')
-            self.assertEqual(task, self.called_with)
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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()
+        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.monitor, self.client, 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)
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, \
+                '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)
+        self.monitor.done.return_value = False
+        task = tasks.CreateTask('palpatine', None, 'zesty', 'chroot', False, self.config,
+                                self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)
+        self.monitor.done.return_value = False
+        task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'chroot', True,
+                                self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)
+        self.monitor.done.return_value = False
+        task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', None, False,
+                                self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)
+        self.monitor.done.return_value = False
+        task = tasks.CreateTask('palpatine', 'Emperor Palpatine', None, 'lxc', False,
+                                self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)

=== modified file 'tests/unit/service/tasks/test_destroy_task.py'
--- tests/unit/service/tasks/test_destroy_task.py	2016-11-07 18:51:17 +0000
+++ tests/unit/service/tasks/test_destroy_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -15,15 +15,18 @@
 
 import unittest.mock
 from unittest import TestCase
-from libertine.service import tasks
+from libertine.service import tasks, operations_monitor
 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.config  = unittest.mock.create_autospec(ContainersConfig)
+        self.lock    = unittest.mock.MagicMock()
+        self.client  = unittest.mock.Mock()
+        self.monitor = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
         self.called_with = None
 
     def callback(self, task):
@@ -31,50 +34,45 @@
 
     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)
+        self.monitor.done.return_value = False
+        task = tasks.DestroyTask('palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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)
+        task = tasks.DestroyTask('palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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)
+        self.monitor.done.return_value = False
+        task = tasks.DestroyTask('palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)

=== modified file 'tests/unit/service/tasks/test_install_task.py'
--- tests/unit/service/tasks/test_install_task.py	2016-11-08 15:20:20 +0000
+++ tests/unit/service/tasks/test_install_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -15,15 +15,18 @@
 
 import unittest.mock
 from unittest import TestCase
-from libertine.service import tasks
+from libertine.service import tasks, operations_monitor
 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.config  = unittest.mock.create_autospec(ContainersConfig)
+        self.lock    = unittest.mock.MagicMock()
+        self.client  = unittest.mock.Mock()
+        self.monitor = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
         self.called_with = None
 
     def callback(self, task):
@@ -31,46 +34,40 @@
 
     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()
+        task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.monitor, self.client, 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)
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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)
+        task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, "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)
+        self.monitor.done.return_value = False
+        task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)

=== modified file 'tests/unit/service/tasks/test_list_app_ids_task.py'
--- tests/unit/service/tasks/test_list_app_ids_task.py	2017-02-07 12:35:48 +0000
+++ tests/unit/service/tasks/test_list_app_ids_task.py	2017-03-31 20:05:48 +0000
@@ -15,15 +15,17 @@
 import json
 import unittest.mock
 from unittest import TestCase
-from libertine.service import tasks
+from libertine.service import tasks, operations_monitor
 from libertine.ContainersConfig import ContainersConfig
 
 
 class TestListAppIdsTask(TestCase):
     def setUp(self):
         self.config      = unittest.mock.create_autospec(ContainersConfig)
-        self.connection  = unittest.mock.Mock()
         self.lock      = unittest.mock.MagicMock()
+        self.monitor    = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
         self.called_with = None
 
     def callback(self, task):
@@ -31,29 +33,25 @@
 
     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.ListAppIdsTask('palpatine', self.config, self.connection, self.callback)
-            task._instant_callback = True
-
-            with unittest.mock.patch('libertine.service.tasks.list_app_ids_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)
+        task = tasks.ListAppIdsTask('palpatine', self.config, self.monitor, self.callback)
+        task._instant_callback = True
+
+        with unittest.mock.patch('libertine.service.tasks.list_app_ids_task.LibertineContainer') as MockContainer:
+            task.start().join()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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.ListAppIdsTask('palpatine', self.config, self.connection, self.callback)
-            task._instant_callback = True
-
-            with unittest.mock.patch('libertine.service.tasks.list_app_ids_task.LibertineContainer') as MockContainer:
-                MockContainer.return_value.list_app_ids.return_value = '["palpatine_gedit_0.0","palpatine_xterm_0.0"]'
-                task.start().join()
-
-            progress.finished.assert_called_once_with('palpatine')
-            progress.data.assert_called_once_with(json.dumps('["palpatine_gedit_0.0","palpatine_xterm_0.0"]'))
-            self.assertEqual(task, self.called_with)
+        self.monitor.done.return_value = False
+        task = tasks.ListAppIdsTask('palpatine', self.config, self.monitor, self.callback)
+        task._instant_callback = True
+
+        with unittest.mock.patch('libertine.service.tasks.list_app_ids_task.LibertineContainer') as MockContainer:
+            MockContainer.return_value.list_app_ids.return_value = '["palpatine_gedit_0.0","palpatine_xterm_0.0"]'
+            task.start().join()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        self.monitor.data.assert_called_once_with(self.monitor.new_operation.return_value, json.dumps('["palpatine_gedit_0.0","palpatine_xterm_0.0"]'))
+        self.assertEqual(task, self.called_with)

=== modified file 'tests/unit/service/tasks/test_list_task.py'
--- tests/unit/service/tasks/test_list_task.py	2017-01-24 18:00:57 +0000
+++ tests/unit/service/tasks/test_list_task.py	2017-03-31 20:05:48 +0000
@@ -17,31 +17,30 @@
 import unittest.mock
 
 from unittest import TestCase
-from libertine.service import tasks
+from libertine.service import tasks, operations_monitor
 from libertine.ContainersConfig import ContainersConfig
 
 
 class TestListTask(TestCase):
     def setUp(self):
         self.config     = unittest.mock.create_autospec(ContainersConfig)
-        self.connection = unittest.mock.Mock()
+        self.monitor    = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
 
     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.config, self.connection, callback)
-            task._instant_callback = True
-
-            self.config.get_containers.return_value = ['palatine', 'vader', 'maul']
-            task.start().join()
-
-            progress.data.assert_called_once_with(json.dumps(['palatine', 'vader', 'maul']))
-            progress.finished.assert_called_once_with('')
-
-            self.assertEqual(task, self.called_with)
+        self.monitor.done.return_value = False
+
+        task = tasks.ListTask(self.config, self.monitor, callback)
+        task._instant_callback = True
+
+        self.config.get_containers.return_value = ['palatine', 'vader', 'maul']
+        task.start().join()
+
+        self.monitor.data.assert_called_once_with(self.monitor.new_operation.return_value, json.dumps(['palatine', 'vader', 'maul']))
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+
+        self.assertEqual(task, self.called_with)

=== modified file 'tests/unit/service/tasks/test_remove_task.py'
--- tests/unit/service/tasks/test_remove_task.py	2016-11-08 15:20:20 +0000
+++ tests/unit/service/tasks/test_remove_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -15,15 +15,18 @@
 
 import unittest.mock
 from unittest import TestCase
-from libertine.service import tasks
+from libertine.service import tasks, operations_monitor
 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.config  = unittest.mock.create_autospec(ContainersConfig)
+        self.lock    = unittest.mock.MagicMock()
+        self.client = unittest.mock.Mock()
+        self.monitor = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
         self.called_with = None
 
     def callback(self, task):
@@ -31,46 +34,40 @@
 
     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()
+        task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.monitor, self.client, 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)
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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)
+        task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, "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)
+        self.monitor.done.return_value = False
+        task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)

=== modified file 'tests/unit/service/tasks/test_search_task.py'
--- tests/unit/service/tasks/test_search_task.py	2016-11-07 18:51:17 +0000
+++ tests/unit/service/tasks/test_search_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -15,29 +15,29 @@
 
 import unittest.mock
 from unittest import TestCase
-from libertine.service import tasks, apt
+from libertine.service import tasks, apt, operations_monitor
 
 
 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.monitor    = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
         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)
+            self.monitor.done.return_value = False
+            task = tasks.SearchTask('palpatine', self.cache, 'jarjar', self.monitor, 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.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+            self.monitor.data.assert_called_once_with(self.monitor.new_operation.return_value, str(['jarjar', 'sidius']))
             self.assertEqual(task, self.called_with)

=== modified file 'tests/unit/service/tasks/test_update_task.py'
--- tests/unit/service/tasks/test_update_task.py	2016-11-08 15:20:20 +0000
+++ tests/unit/service/tasks/test_update_task.py	2017-03-31 20:05:48 +0000
@@ -1,4 +1,4 @@
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -15,15 +15,18 @@
 
 import unittest.mock
 from unittest import TestCase
-from libertine.service import tasks
+from libertine.service import tasks, operations_monitor
 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.config  = unittest.mock.create_autospec(ContainersConfig)
+        self.lock    = unittest.mock.MagicMock()
+        self.client  = unittest.mock.Mock()
+        self.monitor = unittest.mock.create_autospec(operations_monitor.OperationsMonitor)
+
+        self.monitor.new_operation.return_value = "/com/canonical/libertine/Service/Download/123456"
         self.called_with = None
 
     def callback(self, task):
@@ -31,50 +34,47 @@
 
     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)
+        task = tasks.UpdateTask('palpatine', self.config, self.lock, self.monitor, self.client, self.callback)
+        task._instant_callback = True
+
+        with unittest.mock.patch('libertine.service.tasks.update_task.LibertineContainer') as MockContainer:
+            task.start().join()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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)
+        task = tasks.UpdateTask('palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.error.assert_called_once_with(self.monitor.new_operation.return_value, '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)
+        self.monitor.done.return_value = False
+        task = tasks.UpdateTask('palpatine', self.config, self.lock, self.monitor, self.client, 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()
+
+        self.monitor.finished.assert_called_once_with(self.monitor.new_operation.return_value)
+        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)

=== modified file 'tests/unit/service/test_container.py'
--- tests/unit/service/test_container.py	2017-02-07 12:35:48 +0000
+++ tests/unit/service/test_container.py	2017-03-31 20:05:48 +0000
@@ -20,31 +20,32 @@
 
 class TestContainer(TestCase):
     def setUp(self):
-        self._connection = unittest.mock.Mock()
+        self._monitor = unittest.mock.Mock()
         self._config = unittest.mock.Mock()
+        self._client = 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._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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.assert_called_once_with('palpatine', cache, 'darkseid', self._monitor, 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._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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.assert_called_once_with('palpatine', cache, 'force', [], self._config, self._monitor, 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._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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
@@ -55,111 +56,111 @@
                 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)
+                                                            self._config, self._monitor, unittest.mock.ANY)
 
     def test_install_creates_install_task(self):
         with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                MockInstallTask.assert_called_once_with('force', 'palpatine', self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                MockInstallTask.assert_called_once_with('darkside', 'palpatine', self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                MockRemoveTask.assert_called_once_with('force', 'palpatine', self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                MockRemoveTask.assert_called_once_with('darkside', 'palpatine', self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                                                       self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                                                       self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, lambda task: task)
             with unittest.mock.patch('libertine.service.container.DestroyTask') as MockDestroyTask:
                 c.destroy()
-                MockDestroyTask.assert_called_once_with('palpatine', self._config, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                MockDestroyTask.assert_called_once_with('palpatine', self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                MockDestroyTask.assert_called_once_with('palpatine', self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, lambda task: task)
             with unittest.mock.patch('libertine.service.container.UpdateTask') as MockUpdateTask:
                 c.update()
-                MockUpdateTask.assert_called_once_with('palpatine', self._config, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                MockUpdateTask.assert_called_once_with('palpatine', self._config, unittest.mock.ANY, self._monitor, self._client, 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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, 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, unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                MockUpdateTask.assert_called_once_with('palpatine', self._config, unittest.mock.ANY, self._monitor, self._client, unittest.mock.ANY)
                 MockUpdateTask.return_value.start.assert_called_once_with()
 
     def test_list_app_ids_creates_list_app_ids_task(self):
         with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, lambda task: task)
             with unittest.mock.patch('libertine.service.container.ListAppIdsTask') as MockListAppIdsTask:
                 c.list_app_ids()
-                MockListAppIdsTask.assert_called_once_with('palpatine', self._config, self._connection, unittest.mock.ANY)
+                MockListAppIdsTask.assert_called_once_with('palpatine', self._config, self._monitor, self._client, unittest.mock.ANY)
                 MockListAppIdsTask.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:
-            c = container.Container('palpatine', self._config, self._connection, lambda task: task)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, lambda task: task)
             with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
                 MockInstallTask.return_value.package = 'force'
                 c.install('force')
@@ -176,7 +177,7 @@
             self._container_id = None
             def callback(container):
                 self._container_id = container.id
-            c = container.Container('palpatine', self._config, self._connection, callback)
+            c = container.Container('palpatine', self._config, self._monitor, self._client, callback)
             with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
                 c.install('force')
                 name, args, kwargs = MockInstallTask.mock_calls[0]

=== added file 'tests/unit/service/test_operations_monitor.py'
--- tests/unit/service/test_operations_monitor.py	1970-01-01 00:00:00 +0000
+++ tests/unit/service/test_operations_monitor.py	2017-03-31 20:05:48 +0000
@@ -0,0 +1,146 @@
+# Copyright 2017 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 operations_monitor, download
+
+
+class TestOperationsMonitor(TestCase):
+    def setUp(self):
+        self._connection = unittest.mock.Mock()
+
+    def test_new_operation_returns_some_id(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                self.assertIsNotNone(monitor.new_operation())
+
+    def test_remove_connection(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                monitor.remove_from_connection(monitor.new_operation())
+                MockDownload.return_value.remove_from_connection.assert_called_once_with()
+
+    def test_returns_done_for_operation(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                MockDownload.return_value.done = True
+                self.assertTrue(monitor.done(monitor.new_operation()))
+
+                MockDownload.return_value.done = False
+                self.assertFalse(monitor.done(monitor.new_operation()))
+
+                # non-existent operation
+                self.assertFalse(monitor.done("123456"))
+
+    def test_running_returns_download_state(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                MockDownload.return_value.done = True
+                self.assertFalse(monitor.running(monitor.new_operation()))
+
+                MockDownload.return_value.done = False
+                self.assertTrue(monitor.running(monitor.new_operation()))
+
+                # non-existent operation
+                self.assertFalse(monitor.running("123456"))
+
+    def test_result_returns_download_results(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                MockDownload.return_value.result = "pokemongus"
+                self.assertEqual("pokemongus", monitor.result(monitor.new_operation()))
+
+                # non-existent operation
+                self.assertEqual("", monitor.result("123456"))
+
+    def test_last_error_returns_download_last_errors(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                MockDownload.return_value.last_error = "pokemongus"
+                self.assertEqual("pokemongus", monitor.last_error(monitor.new_operation()))
+
+                # non-existent operation
+                self.assertEqual("", monitor.last_error("123456"))
+
+    def test_forwards_finished(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+            monitor._locations = []
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                path = monitor.new_operation()
+                monitor.finished(path)
+                MockDownload.return_value.finished.assert_called_once_with(path)
+
+                # test does not crash on empty
+                MockDownload.reset_mock()
+                monitor.finished("some/junk")
+                MockDownload.return_value.finished.assert_not_called()
+
+    def test_forwards_error(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+            monitor._locations = []
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                path = monitor.new_operation()
+                monitor.error(path, "something messed up")
+                MockDownload.return_value.error.assert_called_once_with("something messed up")
+
+                # test does not crash on empty
+                MockDownload.reset_mock()
+                monitor.error("some/junk", "something messed up")
+                MockDownload.return_value.error.assert_not_called()
+
+    def test_forwards_data(self):
+        with unittest.mock.patch('dbus.service.Object'):
+            monitor = operations_monitor.OperationsMonitor(self._connection)
+            monitor._connection = self._connection
+            monitor._locations = []
+
+            with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
+                path = monitor.new_operation()
+                monitor.data(path, "some of that gud data")
+                MockDownload.return_value.data.assert_called_once_with("some of that gud data")
+
+                # test does not crash on empty
+                MockDownload.reset_mock()
+                monitor.data("some/junk", "some of that gud data")
+                MockDownload.return_value.data.assert_not_called()
+
+
+
+if __name__ == '__main__':
+    unittest.main()

=== modified file 'tests/unit/service/test_task_dispatcher.py'
--- tests/unit/service/test_task_dispatcher.py	2017-02-07 12:35:48 +0000
+++ tests/unit/service/test_task_dispatcher.py	2017-03-31 20:05:48 +0000
@@ -20,9 +20,10 @@
 class TestTaskDispatcher(TestCase):
     def setUp(self):
         self._connection = unittest.mock.Mock()
+        self._client = 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)
+        self._dispatcher = task_dispatcher.TaskDispatcher(self._connection, self._client)
 
     def tearDown(self):
         self._config_patcher.stop()
@@ -90,20 +91,20 @@
             self._dispatcher.list_app_ids('palpatine')
             self._dispatcher.list_app_ids('palpatine')
             self._dispatcher.list_app_ids('palpatine')
-            MockContainer.assert_called_once_with('palpatine', unittest.mock.ANY, self._connection, unittest.mock.ANY)
+            MockContainer.assert_called_once_with('palpatine', unittest.mock.ANY, self._connection, self._client, 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_app_ids('palpatine')
-            MockContainer.assert_called_once_with('palpatine', unittest.mock.ANY, self._connection, unittest.mock.ANY)
+            MockContainer.assert_called_once_with('palpatine', unittest.mock.ANY, self._connection, self._client, unittest.mock.ANY)
             name, args, kwargs = MockContainer.mock_calls[0]
             args[len(args)-1](MockContainer.return_value)
             self._dispatcher.list_app_ids('palpatine')
             MockContainer.assert_has_calls([ # verify container constructed twice
-                unittest.mock.call('palpatine', unittest.mock.ANY, self._connection, unittest.mock.ANY),
-                unittest.mock.call('palpatine', unittest.mock.ANY, self._connection, unittest.mock.ANY)
+                unittest.mock.call('palpatine', unittest.mock.ANY, self._connection, self._client, unittest.mock.ANY),
+                unittest.mock.call('palpatine', unittest.mock.ANY, self._connection, self._client, unittest.mock.ANY)
             ], any_order=True)
 
     def test_container_info_creates_container_info_task(self):

=== modified file 'tools/libertine-container-manager'
--- tools/libertine-container-manager	2017-03-03 18:34:34 +0000
+++ tools/libertine-container-manager	2017-03-31 20:05:48 +0000
@@ -24,6 +24,10 @@
 import sys
 import re
 
+import gettext
+gettext.textdomain('libertine')
+_ = gettext.gettext
+
 from libertine import ContainerRunning, LibertineContainer
 from libertine.ContainersConfig import ContainersConfig
 from libertine.HostInfo import HostInfo
@@ -35,6 +39,16 @@
         self.containers_config = ContainersConfig()
         self.host_info = HostInfo()
 
+
+    def _container(self, container_id):
+        try:
+            return LibertineContainer(container_id, self.containers_config)
+        except ImportError as e:
+            container_type = self.containers_config.get_container_type(container_id)
+            libertine.utils.get_logger().error(_("Backend for container '{id}' not installed. Install "
+                                               "'python3-libertine-{type}' and try again.").format(id=container_id, type=container_type))
+            sys.exit(1)
+
     def _get_updated_locale(self, container_id):
         host_locale = self.host_info.get_host_locale()
 
@@ -99,16 +113,18 @@
 
         try:
             self.containers_config.update_container_locale(args.id, self.host_info.get_host_locale())
-            container = LibertineContainer(args.id)
-            self.containers_config.update_container_install_status(args.id, "installing")
-            if not container.create_libertine_container(password, args.multiarch):
-                libertine.utils.get_logger().error("Failed to create container")
-                self.containers_config.delete_container(args.id)
-                sys.exit(1)
+            container = LibertineContainer(args.id, self.containers_config)
+            try:
+                self.containers_config.update_container_install_status(args.id, "installing")
+                if not container.create_libertine_container(password, args.multiarch):
+                    libertine.utils.get_logger().error("Failed to create container")
+                    self.containers_config.delete_container(args.id)
+                    sys.exit(1)
+            except Exception as e:
+                container.destroy_libertine_container(force=True)
+                raise
         except Exception as e:
             libertine.utils.get_logger().error("Failed to create container: '{}'".format(str(e)))
-            if container:
-                container.destroy_libertine_container(force=True)
 
             self.containers_config.delete_container(args.id)
             sys.exit(1)
@@ -130,7 +146,7 @@
 
     def destroy(self, args):
         container_id = self.containers_config.check_container_id(args.id)
-        container = LibertineContainer(container_id, self.containers_config)
+        container = self._container(container_id)
 
         self.destroy_container(container, args.force)
 
@@ -138,11 +154,14 @@
 
     def install_package(self, args):
         container_id = self.containers_config.check_container_id(args.id)
-        container = LibertineContainer(container_id, self.containers_config)
+        container = self._container(container_id)
         failure = False
 
         with ContainerRunning(container.container):
             for i, pkg in enumerate(args.package):
+                if not pkg:
+                    continue
+
                 is_debian_package = pkg.endswith('.deb')
 
                 if is_debian_package:
@@ -193,11 +212,14 @@
 
     def remove_package(self, args):
         container_id = self.containers_config.check_container_id(args.id)
-        container = LibertineContainer(container_id)
+        container = self._container(container_id)
         failure = False
 
         with ContainerRunning(container.container):
             for pkg in args.package:
+                if not pkg:
+                    continue
+
                 if self.containers_config.get_package_install_status(container_id, pkg) != 'installed':
                     libertine.utils.get_logger().error("Package \'%s\' is not installed." % pkg)
                     failure = True
@@ -216,8 +238,8 @@
 
     def search_cache(self, args):
         container_id = self.containers_config.check_container_id(args.id)
+        container = self._container(container_id)
 
-        container = LibertineContainer(container_id)
         if container.search_package_cache(args.search_string) is not 0:
             libertine.utils.get_logger().error("Search for '{}' in container '{}' exited with non-zero status"
                                                .format(args.id, args.search_string))
@@ -225,10 +247,10 @@
 
     def update(self, args):
         container_id = self.containers_config.check_container_id(args.id)
+        container = self._container(container_id)
+
         new_locale = self._get_updated_locale(container_id)
 
-        container = LibertineContainer(container_id)
-
         if not container.update_libertine_container(new_locale):
             sys.exit(1)
 
@@ -242,7 +264,7 @@
     def list_apps(self, args):
         container_id = self.containers_config.check_container_id(args.id)
 
-        app_ids = LibertineContainer(container_id).list_app_ids()
+        app_ids = self._container(container_id).list_app_ids()
         if args.json:
             print(json.dumps(app_ids))
         else:
@@ -252,7 +274,7 @@
     def exec(self, args):
         container_id = self.containers_config.check_container_id(args.id)
 
-        container = LibertineContainer(container_id)
+        container = self._container(container_id)
 
         if not container.exec_command(args.command):
             sys.exit(1)
@@ -269,7 +291,7 @@
 
     def configure(self, args):
         container_id = self.containers_config.check_container_id(args.id)
-        container = LibertineContainer(container_id)
+        container = self._container(container_id)
 
         if args.multiarch and self.host_info.get_host_architecture() == 'amd64':
             multiarch = 'disabled'
@@ -377,7 +399,7 @@
     def fix_integrity(self, args):
         if 'containerList' in self.containers_config.container_list:
             for container in self.containers_config.container_list['containerList']:
-                libertine_container = LibertineContainer(container['id'])
+                libertine_container = self._container(container['id'])
 
                 if 'installStatus' not in container or container['installStatus'] == 'removing':
                     self.destroy_container(libertine_container)
@@ -411,7 +433,7 @@
             libertine.utils.get_logger().error("The restart subcommand is only valid for LXC and LXD type containers.")
             sys.exit(1)
 
-        container = LibertineContainer(container_id)
+        container = self._container(container_id)
 
         container.restart_libertine_container()
 

=== modified file 'tools/libertine-launch'
--- tools/libertine-launch	2017-02-23 18:18:29 +0000
+++ tools/libertine-launch	2017-03-31 20:05:48 +0000
@@ -19,6 +19,10 @@
 import os
 import sys
 
+import gettext
+gettext.textdomain('libertine')
+_ = gettext.gettext
+
 from libertine import launcher
 
 def main():
@@ -30,8 +34,14 @@
             utils.get_logger().error("No container with id '%s'" % config.container_id)
             sys.exit(1)
 
-        from libertine import LibertineContainer
-        container = LibertineContainer(container_id=config.container_id)
+        try:
+            from libertine import LibertineContainer
+            container = LibertineContainer(container_id=config.container_id)
+        except ImportError as e:
+            container_type = self.containers_config.get_container_type(container_id)
+            libertine.utils.get_logger().error(_("Backend for container '{id}' not installed. Install "
+                                               "'python3-libertine-{type}' and try again.").format(id=config.container_id, type=container_type))
+            sys.exit(1)
     else:
         from libertine import NoContainer
 

=== modified file 'tools/libertine-lxd-setup'
--- tools/libertine-lxd-setup	2017-01-06 15:32:00 +0000
+++ tools/libertine-lxd-setup	2017-03-31 20:05:48 +0000
@@ -20,20 +20,43 @@
   echo ${idmap} | tee -a /etc/subuid /etc/subgid
 fi
 
-# find the right lxc command
-lxc=`which lxc`
-if [ -z "${lxc}" ]; then
-  if [ -n `which lxd.lxc` ]; then
-    lxc=`which lxd.lxc`
-  else
-    echo "No lxc command found on this system."
-    exit 1
-  fi
-fi
-
-# Run lxd init if there are no containers already on the system
-if [ 2 -ge `${lxc} list | grep -e "^+" | wc -l` ]; then
-  lxd init
+
+lxc profile device list default | grep "nic\|disk" > /dev/null
+requires_init=$?
+version=`lxd --version`
+if [ ${version%%.*} -lt 2 -o ${version#*.} -lt 3 ]; then
+  if [ "$requires_init" -ne "0" ]; then
+    # Running lxd init without args to force the caller to pick the options
+    lxd init
+  fi
+else
+  if [ "$requires_init" -ne "0" ]; then
+    # Running lxd init with auto flag to choose most of the right options
+    lxd init --auto
+  fi
+
+  # networking
+  ifconfig lxdbr0 > /dev/null
+  bridge_exists=$?
+
+  lxc network show lxdbr0 > /dev/null
+  network_exists=$?
+
+  # no managed network, no bridge means we need to create a managed network
+  if [ "$bridge_exists" -ne "0" ]; then
+    if [ "$network_exists" -ne "0" ]; then
+      lxc network create lxdbr0
+
+      network_name=`lxc profile device get default eth0 parent`
+      if [ "$network_name" != "lxdbr0" ]; then
+        lxc network attach-profile lxdbr0 default eth0
+      fi
+    else
+      # a managed network and no bridge means the bridge should be recreated
+      # when we restart the lxd service
+      service lxd restart
+    fi
+  fi
 fi
 
 mkdir -p /home/$USERNAME/.config/lxc

=== modified file 'tools/libertined'
--- tools/libertined	2017-02-15 21:12:37 +0000
+++ tools/libertined	2017-03-31 20:05:48 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/python3
 # -*- coding: utf-8 -*-
 
-# Copyright 2016 Canonical Ltd.
+# Copyright 2016-2017 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
@@ -15,13 +15,17 @@
 # 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 dbus
+import os
 import signal
 import sys
-import os
-from gi.repository import GLib, GObject
+
+from dbus.mainloop.glib import DBusGMainLoop
+from gi.repository import GLib
 from libertine import utils
-from libertine.service import manager
+from libertine.service import constants, operations, container_control, container_control_client
 
 
 class OutputRedirector(object):
@@ -116,6 +120,7 @@
                          signal.SIGTERM,
                          self.sigterm,
                          None)
+        DBusGMainLoop(set_as_default=True)
         self.loop = GLib.MainLoop()
 
     def sigterm(self, code):
@@ -135,13 +140,29 @@
     config = Config()
 
     with OutputRedirector(config):
-        utils.get_logger().info("Starting libertine service")
-        service = manager.Manager()
+        utils.get_logger().info("Initializing libertined...")
         loop = Loop()
-        try:
+
+        try:
+            bus_name = dbus.service.BusName(constants.SERVICE_NAME,
+                                            bus=dbus.SessionBus(),
+                                            do_not_queue=True)
+        except dbus.exceptions.NameExistsException:
+            utils.get_logger().warning("service is already running")
+            raise
+
+        client = container_control_client.ContainerControlClient()
+        manager = operations.Operations(bus_name, client)
+        container_control.ContainerControl(manager.connection, client)
+
+        try:
+            utils.get_logger().info("libertined ready")
             loop.run()
         except KeyboardInterrupt:
             utils.get_logger().debug("keyboard interrupt received")
+        except Exception as e:
+            utils.get_logger().error("Unexpected exception occurred: '{}'".format(str(e)))
+        finally:
             loop.shutdown()