Merge lp:~larryprice/libertine/always-progress into lp:libertine

[Larry Price]

Rearchitect libertine service python backend for simpler access to running tasks.

Rearchitect libertine service python backend for simpler access to running tasks.

This came about because of the intermittent jenkins failure we've been seeing. Hopefully this addresses our issues. If nothing else, it's done a nice job of abstracting away the (currently unused) Download interface, separated the container operations methods, and added some much-needed integration tests for liblibertine.

[lp:~larryprice/libertine/always-progress]

412. By Larry Price on 2017-03-07

update control

413. By Larry Price on 2017-03-07

update copyright

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:412
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/446/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/libertine/job/build/829
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=xenial+overlay,testname=default/683
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=zesty,testname=default/683
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=xenial+overlay,testname=default/683
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=zesty,testname=default/683
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-0-fetch/839
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/831
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/831/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/831
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/831/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/831
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/831/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/831
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/831/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:413
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/447/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/libertine/job/build/830
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=xenial+overlay,testname=default/684
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=zesty,testname=default/684
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=xenial+overlay,testname=default/684
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=zesty,testname=default/684
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-0-fetch/840
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/832
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/832/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/832
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/832/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/832
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/832/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/832
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/832/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~larryprice/libertine/always-progress]

414. By Larry Price on 2017-03-07

sort app ids

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:414
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/448/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/libertine/job/build/831
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=xenial+overlay,testname=default/685
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=zesty,testname=default/685
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=xenial+overlay,testname=default/685
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=zesty,testname=default/685
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-0-fetch/841
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/833
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/833/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/833
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/833/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/833
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/833/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/833
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/833/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~larryprice/libertine/always-progress]

415. By Larry Price on 2017-03-07

rm qdebug

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:415
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/449/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/libertine/job/build/832
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=xenial+overlay,testname=default/686
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=zesty,testname=default/686
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=xenial+overlay,testname=default/686
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=zesty,testname=default/686
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-0-fetch/842
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/834
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/834/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/834
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/834/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/834
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/834/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/834
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/834/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Christopher Townsend (townsend)]

lgtm, +1

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-02-08 19:55:41 +0000
+++ CMakeLists.txt	2017-03-07 21:54:49 +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/control'
--- debian/control	2017-03-06 15:14:55 +0000
+++ debian/control	2017-03-07 21:54:49 +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,

=== modified file 'liblibertine/libertined.cpp'
--- liblibertine/libertined.cpp	2017-02-23 21:08:28 +0000
+++ liblibertine/libertined.cpp	2017-03-07 21:54:49 +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 'python/libertine/Client.py'
--- python/libertine/Client.py	2017-02-24 14:56:36 +0000
+++ python/libertine/Client.py	2017-03-07 21:54:49 +0000
@@ -24,14 +24,15 @@
         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 +52,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 +65,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/Libertine.py'
--- python/libertine/Libertine.py	2017-03-03 15:34:16 +0000
+++ python/libertine/Libertine.py	2017-03-07 21:54:49 +0000
@@ -547,7 +547,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):
         """

=== 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-07 21:54:49 +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-07 21:54:49 +0000
@@ -22,9 +22,9 @@
 
 
 class Container(object):
-    def __init__(self, container_id, config, connection, callback):
+    def __init__(self, container_id, config, monitor, callback):
         self._id = container_id
-        self._connection = connection
+        self._monitor = monitor
         self._callback = callback
         self._config = config
         self._lock = Lock()
@@ -59,7 +59,7 @@
         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)
+        task = SearchTask(self.id, self._cache, query, self._monitor, self._cleanup_task)
         self._tasks.append(task)
         task.start()
 
@@ -72,7 +72,7 @@
             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)
+        task = AppInfoTask(self.id, self._cache, package_name, related_task_ids, self._config, self._monitor, self._cleanup_task)
 
         self._tasks.append(task)
         task.start()
@@ -86,7 +86,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._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -99,7 +99,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._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -113,7 +113,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._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -126,7 +126,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._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -139,7 +139,7 @@
             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._cleanup_task)
         self._tasks.append(task)
         task.start()
         return task.id
@@ -147,7 +147,7 @@
     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._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-07 21:54:49 +0000
@@ -12,17 +12,22 @@
 # 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 libertine.ContainersConfig
 import psutil
 
+from . import constants
 from collections import Counter
 from libertine import utils
 
 
-class OperationsState(object):
-    def __init__(self):
+class ContainerControl(dbus.service.Object):
+    def __init__(self, connection):
         self._get_running_apps_per_container()
 
+        dbus.service.Object.__init__(self, conn=connection, object_path=constants.CONTAINER_CONTROL_OBJECT)
+
     def _get_running_apps_per_container(self):
         self._invalid_apps = dict()
         self._operations = Counter()
@@ -47,7 +52,12 @@
                     config.delete_running_app(container, app)
                     continue
 
-    def operation_start(self, container):
+
+    @dbus.service.method(constants.CONTAINER_CONTROL_INTERFACE,
+                         in_signature='s',
+                         out_signature='b')
+    def start(self, container):
+        utils.get_logger().debug("start({})".format(container))
         if self._operations[container] == -1:
             return False
 
@@ -55,7 +65,13 @@
 
         return True
 
-    def operation_finished(self, container, app_name, pid):
+
+    @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))
+
         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]:
@@ -69,7 +85,11 @@
 
         return False
 
-    def operation_stopped(self, container):
+    @dbus.service.method(constants.CONTAINER_CONTROL_INTERFACE,
+                         in_signature='s',
+                         out_signature='b')
+    def stopped(self, container):
+        utils.get_logger().debug("stopped({})".format(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-07 21:54:49 +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-07 21:54:49 +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):
+        super().__init__(bus_name, constants.OPERATIONS_OBJECT)
+
+        self._dispatcher = task_dispatcher.TaskDispatcher(operations_monitor.OperationsMonitor(self.connection))
 
     # 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-07 21:54:49 +0000
@@ -0,0 +1,92 @@
+# 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
+
+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, hex(int(time()*10000000))[2:]))
+        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-07 21:54:49 +0000
@@ -30,8 +30,8 @@
 
 
 class TaskDispatcher(object):
-    def __init__(self, connection):
-        self._connection = connection
+    def __init__(self, monitor):
+        self._monitor = monitor
         self._config = libertine.ContainersConfig.ContainersConfig()
         self._containerless_tasks = []
         self._tasks = []
@@ -49,11 +49,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._cleanup_container)
         self._containers.append(container)
 
         return container
@@ -115,7 +117,7 @@
         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()
 
@@ -125,7 +127,7 @@
     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/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-07 21:54:49 +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-07 21:54:49 +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,23 +51,23 @@
 
     @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):
         if not self._before():
-            self._progress.finished(self.container)
+            self._monitor.finished(self._operation_id)
             self._delayed_callback()
             return
 
@@ -80,7 +78,7 @@
             self._run()
 
         if self.running:
-            self._progress.finished(self.container)
+            self._monitor.finished(self._operation_id)
 
         self._delayed_callback()
 
@@ -90,3 +88,9 @@
 
     def _before(self):
         return True
+
+    def _data(self, message):
+        self._monitor.data(self._operation_id, message)
+
+    def _error(self, message):
+        self._monitor.error(self._operation_id, message)

=== 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-07 21:54:49 +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-07 21:54:49 +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
@@ -19,8 +19,8 @@
 
 
 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)
+    def __init__(self, container_id, container_name, distro, container_type, enable_multiarch, config, lock, monitor, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config, monitor=monitor, callback=callback)
         self._name = container_name
         self._distro = distro
         self._type = container_type
@@ -34,31 +34,31 @@
 
             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")
         except RuntimeError as e:
-            self._progress.error(str(e))
+            self._error(str(e))
             self._config.delete_container(self._container)
 
     def _before(self):
         utils.get_logger().debug("CreateTask::_before")
         if self._config.container_exists(self._container):
-            self._progress.error("Container '%s' already exists" % self._container)
+            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-07 21:54:49 +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,15 +18,15 @@
 
 
 class DestroyTask(BaseTask):
-    def __init__(self, container_id, config, lock, connection, callback):
-        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
+    def __init__(self, container_id, config, lock, monitor, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config, monitor=monitor, callback=callback)
 
     def _run(self):
         utils.get_logger().debug("Destroying container '%s'" % self._container)
 
         container = LibertineContainer(self._container, self._config)
         if not container.destroy_libertine_container():
-            self._progress.error("Destroying container '%s' failed" % self._container)
+            self._error("Destroying container '%s' failed" % self._container)
             self._config.update_container_install_status(self._container, "ready")
             return
 
@@ -35,7 +35,7 @@
     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-07 21:54:49 +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 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)
+    def __init__(self, package_name, container_id, config, lock, monitor, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config, monitor=monitor, callback=callback)
         self._package = package_name
 
     def matches(self, package, klass):
@@ -36,12 +36,12 @@
             self._config.update_package_install_status(self._container, self._package, "installed")
         else:
             self._config.delete_package(self._container, self._package)
-            self._progress.error("Package installation failed for '%s'" % self._package)
+            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-07 21:54:49 +0000
@@ -20,16 +20,16 @@
 
 
 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)
+    def __init__(self, container_id, config, monitor, callback):
+        super().__init__(lock=None, container_id=container_id, config=config, monitor=monitor, 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).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-07 21:54:49 +0000
@@ -20,8 +20,8 @@
 
 
 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()))

=== 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-07 21:54:49 +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 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)
+    def __init__(self, package_name, container_id, config, lock, monitor, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config, monitor=monitor, callback=callback)
         self._package = package_name
 
     def matches(self, package, klass):
@@ -36,7 +36,7 @@
             self._config.delete_package(self._container, self._package)
         else:
             self._config.update_package_install_status(self._container, self._package, 'installed')
-            self._progress.error("Package removal failed for '%s'" % self._package)
+            self._error("Package removal failed for '%s'" % self._package)
 
     def _before(self):
         utils.get_logger().debug("RemoveTask::_before")
@@ -44,5 +44,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-07 21:54:49 +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-07 21:54:49 +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,22 +18,22 @@
 
 
 class UpdateTask(BaseTask):
-    def __init__(self, container_id, config, lock, connection, callback):
-        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
+    def __init__(self, container_id, config, lock, monitor, callback):
+        super().__init__(lock=lock, container_id=container_id, config=config, monitor=monitor, callback=callback)
 
     def _run(self):
         utils.get_logger().debug("Updating container '%s'" % self._container)
         container = LibertineContainer(self._container, self._config)
         self._config.update_container_install_status(self._container, "updating")
         if not container.update_libertine_container():
-            self._progress.error("Failed to update container '%s'" % self._container)
+            self._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 'tests/integration/CMakeLists.txt'
--- tests/integration/CMakeLists.txt	2017-03-06 15:33:12 +0000
+++ tests/integration/CMakeLists.txt	2017-03-07 21:54:49 +0000
@@ -2,3 +2,23 @@
 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};")
+
+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-07 21:54:49 +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-07 21:54:49 +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
@@ -75,7 +75,7 @@
         for retries in range(1, 11):
             try:
                 self._bus =  dbus.SessionBus()
-                self._libertined = self._bus.get_object('com.canonical.libertine.Service', '/Manager')
+                self._libertined = self._bus.get_object(constants.SERVICE_NAME, constants.OPERATIONS_OBJECT)
                 break
             except dbus.DBusException as e:
                 print("Service not available (attempt %i/10). Exception: %s" % (retries, str(e)))
@@ -101,20 +101,20 @@
 
         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'))
+        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'))
+        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'))
+        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'))
 
-        task = self._bus.get_object('com.canonical.libertine.Service', obj_path)
-        if task.running():
+        monitor = self._bus.get_object(constants.SERVICE_NAME, constants.OPERATIONS_MONITOR_OBJECT)
+        if monitor.running(obj_path):
             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')()
+        self.assertEqual('', monitor.last_error(obj_path))
+        self.result = monitor.result(obj_path)
 
         for signal in signals:
             self._bus._clean_up_signal_match(signal)

=== 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-07 21:54:49 +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-07 21:54:49 +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-07 21:54:49 +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-07 21:54:49 +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-07 21:54:49 +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-07 21:54:49 +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-07 21:54:49 +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,17 @@
 
 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.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 +33,185 @@
 
     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.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.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.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.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.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.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.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.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.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.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-07 21:54:49 +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,17 @@
 
 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.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 +33,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.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.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.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-07 21:54:49 +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,17 @@
 
 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.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 +33,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.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.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.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-07 21:54:49 +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-07 21:54:49 +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-07 21:54:49 +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,17 @@
 
 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.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 +33,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.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.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.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-07 21:54:49 +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-07 21:54:49 +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,17 @@
 
 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.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 +33,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.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.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.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-07 21:54:49 +0000
@@ -20,31 +20,31 @@
 
 class TestContainer(TestCase):
     def setUp(self):
-        self._connection = unittest.mock.Mock()
+        self._monitor = unittest.mock.Mock()
         self._config = 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, 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, 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, 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 +55,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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, lambda task: task)
             with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
                 MockInstallTask.return_value.package = 'force'
                 c.install('force')
@@ -176,7 +176,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, 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-07 21:54:49 +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 'tools/libertined'
--- tools/libertined	2017-02-15 21:12:37 +0000
+++ tools/libertined	2017-03-07 21:54:49 +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
 
 
 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):
@@ -136,8 +141,19 @@
 
     with OutputRedirector(config):
         utils.get_logger().info("Starting libertine service")
-        service = manager.Manager()
         loop = Loop()
+
+        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
+
+        manager = operations.Operations(bus_name)
+        container_control.ContainerControl(manager.connection)
+        
         try:
             loop.run()
         except KeyboardInterrupt: