Merge lp:~townsend/libertine/1.4.3-release into lp:libertine/trunk

[Christopher Townsend]

* Use libertine-lxc-manager when starting/stopping a container for libertine-container-manager operations if the session DBus is available. If not, fallback to l-c-m starting/stopping the container. (LP: #1628587)
* Add a new entry to ContainersConfig for keeping track of running processes in a container. (LP: #1632729)
* libertine-launch: refactored core components of application session management.
* Split out Xmir helper apps into their own package.
* Add support for starting pasted and matchbox for snap based/ containerless apps in U8. (LP: #1637535)
* Add implementation for libertine gui as a system-settings plugin. (LP: #1623946)
* Manually require archive name during archive configuration.
* Add a warning to the top of ContainersConfig.json advising users not to edit the file.
* Missing error dialogs in PackageInfoView when fetching version results in an error.
* Avoid searching for apps based on empty directories.
* Bump version to 1.4.3.

[lp:~townsend/libertine/1.4.3-release]

173. By Christopher Townsend on 2016-11-03

Merge in lp:libertine for fixes.

174. By Christopher Townsend on 2016-11-03

Set cmake project version to 1.4.3.

[Larry Price (larryprice)]

lgtm!

review: Approve

[lp:~townsend/libertine/1.4.3-release]

175. By Christopher Townsend on 2016-11-03

Merge lp:libertine for an additional fix.

176. By Christopher Townsend on 2016-11-17

Add arm64 to xmir and restrict the archs the libertine-xmir-package is built for.

177. By Christopher Townsend on 2016-11-18

Move libertine-xmir-tools to Recommends instead of Depends for libertine-tools.

178. By Christopher Townsend on 2016-11-21

Set libertine package breaks/replaces to less then 1.4.3.

179. By Christopher Townsend on 2016-11-21

Fix old libertine package breaks/replaces version for proper upgrading.

180. By Christopher Townsend on 2016-11-21

Merge lp:libertine/trunk.

=== modified file '.bzrignore'
--- .bzrignore	2016-02-29 18:07:02 +0000
+++ .bzrignore	2016-11-21 19:42:42 +0000
@@ -1,2 +1,4 @@
 po/POTFILES.in
 po/Makefile.in.in
+__pycache__
+tests/unit/.cache

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-09-13 18:17:52 +0000
+++ CMakeLists.txt	2016-11-21 19:42:42 +0000
@@ -1,8 +1,8 @@
 cmake_minimum_required(VERSION 3.0.2)
 cmake_policy(SET CMP0048 NEW)
 
-project(libertine 
-        VERSION 1.4.1)
+project(libertine
+        VERSION 1.4.3)
 
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}")
 
@@ -32,13 +32,21 @@
 
 set(CMAKE_AUTOMOC ON)
 
+set(LIBERTINE_COMMON libertine-common)
+set(LIBERTINE_CORE libertine)
+set(LIBERTINE_EXE_NAME libertine-manager-app)
+set(LIBERTINE_QML_PATH ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/${CMAKE_PROJECT_NAME}/qml)
+
+add_subdirectory(qml)
+add_subdirectory(liblibertine)
+add_subdirectory(common)
 add_subdirectory(libertine)
+add_subdirectory(system-settings-plugin)
 add_subdirectory(python)
 add_subdirectory(data)
 add_subdirectory(tools)
-add_subdirectory(liblibertine)
+add_subdirectory(pasted)
 add_subdirectory(po)
-add_subdirectory(pasted)
 
 include(CTest)
 add_subdirectory(tests)
@@ -50,4 +58,3 @@
      | xz >${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar.xz
   && rm .gitattributes
   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-

=== added directory 'common'
=== added file 'common/CMakeLists.txt'
--- common/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ common/CMakeLists.txt	2016-11-21 19:42:42 +0000
@@ -0,0 +1,13 @@
+add_library(${LIBERTINE_COMMON}
+    ContainerAppsList.cpp
+    ContainerArchivesList.cpp
+    ContainerConfig.cpp
+    ContainerConfigList.cpp
+    ContainerManager.cpp
+    LibertineConfig.cpp
+    PackageOperationDetails.cpp
+)
+
+target_link_libraries(${LIBERTINE_COMMON} ${LIBERTINE_CORE} Qt5::Core)
+
+install(TARGETS ${LIBERTINE_COMMON_NAME} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})

=== renamed file 'libertine/ContainerAppsList.cpp' => 'common/ContainerAppsList.cpp'
--- libertine/ContainerAppsList.cpp	2016-08-12 19:39:50 +0000
+++ common/ContainerAppsList.cpp	2016-11-21 19:42:42 +0000
@@ -16,8 +16,10 @@
  * 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 "libertine/ContainerAppsList.h"
-#include "libertine/ContainerConfigList.h"
+#include "common/ContainerAppsList.h"
+
+#include "common/ContainerConfig.h"
+#include "common/ContainerConfigList.h"
 
 ContainerAppsList::
 ContainerAppsList(ContainerConfigList* container_config_list,

=== renamed file 'libertine/ContainerAppsList.h' => 'common/ContainerAppsList.h'
--- libertine/ContainerAppsList.h	2016-08-12 19:39:50 +0000
+++ common/ContainerAppsList.h	2016-11-21 19:42:42 +0000
@@ -3,7 +3,7 @@
  * @brief Libertine Manager list of container applications
  */
 /*
- * Copyright 2015 Canonical Ltd
+ * Copyright 2015-2016 Canonical Ltd
  *
  * Libertine 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
@@ -19,8 +19,6 @@
 #ifndef _CONTAINER_APPS_LIST_H_
 #define _CONTAINER_APPS_LIST_H_
 
-#include "libertine/ContainerConfig.h"
-
 #include <QtCore/QAbstractListModel>
 #include <QtCore/QList>
 #include <QtCore/QObject>
@@ -30,6 +28,7 @@
 class ContainerApps;
 class ContainerConfigList;
 
+
 class ContainerAppsList
 : public QAbstractListModel
 {

=== renamed file 'libertine/ContainerArchivesList.cpp' => 'common/ContainerArchivesList.cpp'
--- libertine/ContainerArchivesList.cpp	2016-08-12 19:39:50 +0000
+++ common/ContainerArchivesList.cpp	2016-11-21 19:42:42 +0000
@@ -16,8 +16,10 @@
  * 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 "libertine/ContainerArchivesList.h"
-#include "libertine/ContainerConfigList.h"
+#include "common/ContainerArchivesList.h"
+
+#include "common/ContainerConfig.h"
+#include "common/ContainerConfigList.h"
 
 ContainerArchivesList::
 ContainerArchivesList(ContainerConfigList* container_config_list,

=== renamed file 'libertine/ContainerArchivesList.h' => 'common/ContainerArchivesList.h'
--- libertine/ContainerArchivesList.h	2016-08-12 19:39:50 +0000
+++ common/ContainerArchivesList.h	2016-11-21 19:42:42 +0000
@@ -19,8 +19,6 @@
 #ifndef _CONTAINER_ARCHIVES_LIST_H_
 #define _CONTAINER_ARCHIVES_LIST_H_
 
-#include "libertine/ContainerConfig.h"
-
 #include <QtCore/QAbstractListModel>
 #include <QtCore/QList>
 #include <QtCore/QObject>

=== renamed file 'libertine/ContainerConfig.cpp' => 'common/ContainerConfig.cpp'
--- libertine/ContainerConfig.cpp	2016-04-13 18:02:56 +0000
+++ common/ContainerConfig.cpp	2016-11-21 19:42:42 +0000
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "libertine/ContainerConfig.h"
+#include "common/ContainerConfig.h"
 
 #include <QtCore/QDebug>
 #include <QtCore/QJsonArray>
@@ -73,7 +73,7 @@
         }
       }
     }
-    
+
     return name;
   }
 

=== renamed file 'libertine/ContainerConfig.h' => 'common/ContainerConfig.h'
=== renamed file 'libertine/ContainerConfigList.cpp' => 'common/ContainerConfigList.cpp'
--- libertine/ContainerConfigList.cpp	2016-08-22 18:20:43 +0000
+++ common/ContainerConfigList.cpp	2016-11-21 19:42:42 +0000
@@ -16,12 +16,11 @@
  * 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 "libertine/ContainerManager.h"
-#include "libertine/ContainerConfigList.h"
-#include "libertine/LibertineConfig.h"
+#include "common/ContainerConfigList.h"
 
+#include "common/ContainerConfig.h"
+#include "common/LibertineConfig.h"
 #include <algorithm>
-#include "libertine/ContainerConfig.h"
 #include <QtCore/QDebug>
 #include <QtCore/QDir>
 #include <QtCore/QFile>
@@ -95,7 +94,7 @@
 reloadContainerList()
 {
   beginResetModel();
-  endResetModel();  
+  endResetModel();
 }
 
 
@@ -128,7 +127,7 @@
 deleteContainer()
 {
   beginResetModel();
-  endResetModel();  
+  endResetModel();
 }
 
 
@@ -360,7 +359,7 @@
 getHostDistroDescription()
 {
   QSettings distro_info("/etc/lsb-release", QSettings::NativeFormat);
- 
+
   return distro_info.value("DISTRIB_DESCRIPTION").toString().section(' ', 0, 2);
 }
 

=== renamed file 'libertine/ContainerConfigList.h' => 'common/ContainerConfigList.h'
=== renamed file 'libertine/ContainerManager.cpp' => 'common/ContainerManager.cpp'
--- libertine/ContainerManager.cpp	2016-09-30 18:55:22 +0000
+++ common/ContainerManager.cpp	2016-11-21 19:42:42 +0000
@@ -16,7 +16,8 @@
  * 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 "libertine/ContainerManager.h"
+#include "common/ContainerManager.h"
+
 #include <QTemporaryFile>
 
 
@@ -32,6 +33,7 @@
 static const QString RUN_COMMAND_FAILED = QObject::tr("Running command %1 failed");
 static const QString CONTAINER_CONFIGURE_FAILED = QObject::tr("Attempt to configure container %1 failed");
 static const QString SET_DEFAULT_CONTAINER_FAILED = QObject::tr("Attempt to set container as default failed");
+static const QString GENERAL_ERROR = QObject::tr("An error occurred");
 constexpr auto libertine_container_manager_tool = "libertine-container-manager";
 
 
@@ -66,6 +68,15 @@
 ContainerManagerWorker()
 {
   connect(&process_, static_cast<void(QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), this, &QObject::deleteLater);
+  connect(&process_,
+#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
+          &QProcess::errorOccurred,
+#else
+          static_cast<void(QProcess::*)(QProcess::ProcessError)>(&QProcess::error),
+#endif
+          [=](QProcess::ProcessError) {
+            emit error(GENERAL_ERROR, process_.errorString());
+  });
 }
 
 

=== renamed file 'libertine/ContainerManager.h' => 'common/ContainerManager.h'
=== renamed file 'libertine/LibertineConfig.cpp' => 'common/LibertineConfig.cpp'
--- libertine/LibertineConfig.cpp	2016-04-06 19:14:10 +0000
+++ common/LibertineConfig.cpp	2016-11-21 19:42:42 +0000
@@ -16,38 +16,13 @@
  * 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 "libertine/LibertineConfig.h"
+#include "common/LibertineConfig.h"
 
-#include "libertine/libertine.h"
-#include <QtCore/QCommandLineParser>
 #include <QtCore/QDir>
 #include <QtCore/QFile>
 #include <QtCore/QStandardPaths>
 
 
-LibertineConfig::
-LibertineConfig(Libertine const& libertine)
-{
-  QCommandLineParser commandlineParser;
-  commandlineParser.setApplicationDescription("manage sandboxes for running legacy DEB-packaged X11-based applications");
-  commandlineParser.addHelpOption();
-  commandlineParser.addVersionOption();
-  commandlineParser.process(libertine);
-}
-
-
-LibertineConfig::
-LibertineConfig()
-{
-}
-
-
-LibertineConfig::
-~LibertineConfig()
-{
-}
-
-
 QString LibertineConfig::
 containers_config_file_name() const
 {
@@ -67,6 +42,6 @@
     file.open(QIODevice::WriteOnly);
     file.close();
   }
-  
+
   return file_name;
 }

=== renamed file 'libertine/LibertineConfig.h' => 'common/LibertineConfig.h'
--- libertine/LibertineConfig.h	2015-06-22 12:31:13 +0000
+++ common/LibertineConfig.h	2016-11-21 19:42:42 +0000
@@ -3,7 +3,7 @@
  * @brief Libertine Manager application-wide configuration module
  */
 /*
- * Copyright 2015 Canonical Ltd
+ * Copyright 2015-2016 Canonical Ltd
  *
  * Libertine 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
@@ -22,18 +22,14 @@
 #include <QtCore/QString>
 
 
-class Libertine;
-
-
 /**
  * The runtime configuration of the Libertine tools.
  */
 class LibertineConfig
 {
 public:
-  LibertineConfig(Libertine const& libertine);
-  LibertineConfig();
-  ~LibertineConfig();
+  explicit LibertineConfig() = default;
+  virtual ~LibertineConfig() = default;
 
   QString
   containers_config_file_name() const;

=== added file 'common/PackageOperationDetails.cpp'
--- common/PackageOperationDetails.cpp	1970-01-01 00:00:00 +0000
+++ common/PackageOperationDetails.cpp	2016-11-21 19:42:42 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2016 Canonical Ltd
+ *
+ * Libertine 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.
+ *
+ * Libertine 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 "PackageOperationDetails.h"
+
+namespace
+{
+static bool has_key(QMap<QString, QMap<QString, QString> > details,
+                    QString const& container_id, QString const& package_id)
+{
+  return details.constFind(container_id) != details.constEnd() &&
+      details[container_id].constFind(package_id) != details[container_id].constEnd();
+}
+}
+
+
+PackageOperationDetails::
+PackageOperationDetails(QObject* parent)
+  : QObject(parent)
+{
+}
+
+
+QString PackageOperationDetails::
+details(QString const& container_id, QString const& package_id) const
+{
+  if (has_key(details_, container_id, package_id))
+  {
+    return details_[container_id][package_id];
+  }
+  return "";
+}
+
+
+void PackageOperationDetails::
+clear(QString const& container_id, QString const& package_id)
+{
+  if (has_key(details_, container_id, package_id))
+  {
+    details_[container_id].remove(package_id);
+    if (details_[container_id].empty())
+    {
+      details_.remove(container_id);
+    }
+  }
+}
+
+
+void PackageOperationDetails::
+update(QString const& container_id, QString const& package_id, QString const& new_details)
+{
+  if (has_key(details_, container_id, package_id))
+  {
+    details_[container_id][package_id] += new_details;
+  }
+  else
+  {
+    if (details_.constFind(container_id) == details_.constEnd())
+    {
+      details_[container_id] = QMap<QString, QString>{{package_id, new_details}};
+    }
+  }
+
+  emit updated(container_id, package_id, new_details);
+}

=== added file 'common/PackageOperationDetails.h'
--- common/PackageOperationDetails.h	1970-01-01 00:00:00 +0000
+++ common/PackageOperationDetails.h	2016-11-21 19:42:42 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016 Canonical Ltd
+ *
+ * Libertine 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.
+ *
+ * Libertine 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/>.
+ */
+
+#pragma once
+
+#include <QObject>
+#include <QMap>
+
+
+class PackageOperationDetails : public QObject
+{
+  Q_OBJECT
+
+public:
+  explicit PackageOperationDetails(QObject* parent = nullptr);
+  virtual ~PackageOperationDetails() = default;
+
+  Q_INVOKABLE QString details(QString const& container_id, QString const& package_id) const;
+  Q_INVOKABLE void clear(QString const& container_id, QString const& package_id);
+
+public slots:
+  void update(QString const& container_id, QString const& package_id, QString const& new_details);
+
+signals:
+  void updated(QString const& container_id, QString const& package_id, QString const& new_details);
+  void send(QString const& input);
+  void error(QString const& short_description, QString const& details);
+
+private:
+  QMap<QString, QMap<QString, QString> > details_;
+};

=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2016-09-06 12:36:47 +0000
+++ data/CMakeLists.txt	2016-11-21 19:42:42 +0000
@@ -1,6 +1,6 @@
 set(CMAKE_INSTALL_SYSCONFDIR "/etc")
 
-install(FILES libertine.desktop
+install(FILES libertine-manager-app.desktop
         DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
 install(FILES libertine_64.png libertine-lxc.conf
   DESTINATION ${CMAKE_INSTALL_DATADIR}/${CMAKE_PROJECT_NAME})

=== renamed file 'data/libertine.desktop' => 'data/libertine-manager-app.desktop'
--- data/libertine.desktop	2016-02-20 22:23:41 +0000
+++ data/libertine-manager-app.desktop	2016-11-21 19:42:42 +0000
@@ -1,8 +1,8 @@
 [Desktop Entry]
 Version=1.0
-Name=Libertine
+Name=Libertine Manager
 Comment=Legacy Application Sandbox
-Exec=libertine
+Exec=libertine-manager-app
 Terminal=false
 Type=Application
 Icon=/usr/share/libertine/libertine_64.png

=== modified file 'debian/changelog'
--- debian/changelog	2016-11-21 19:37:59 +0000
+++ debian/changelog	2016-11-21 19:42:42 +0000
@@ -1,3 +1,10 @@
+libertine (1.4.3-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Fix old libertine package breaks/replaces version for proper
+    upgrading. 
+
+ -- Chris Townsend <[e-mail]>  Mon, 21 Nov 2016 12:51:42 -0500
+
 libertine (1.4.3+17.04.20161118.1-0ubuntu1) zesty; urgency=medium
 
   [ Chris Townsend]

=== modified file 'debian/control'
--- debian/control	2016-09-12 17:59:56 +0000
+++ debian/control	2016-11-21 19:42:42 +0000
@@ -13,33 +13,74 @@
                libgirepository1.0-dev,
                libglib2.0-dev,
                libgtest-dev,
+               libsystemsettings-dev,
                libx11-dev,
                lsb-release,
+               pkg-config,
                python3-apt,
+               python3-dbus,
+               python3-dbusmock,
                python3-dev,
                python3-distro-info,
                python3-gi,
                python3-lxc,
                python3-psutil,
+               python3-pytest,
                python3-testtools,
                python3-xdg,
-               python3-dbus,
                qtdeclarative5-dev
-Standards-Version: 3.9.6
+Standards-Version: 3.9.8
 Homepage: https://launchpad.net/libertine
 
+Package: libertine-manager-app
+Architecture: any
+Replaces: libertine (<= 1.4.3+17.04.20161118.1-0ubuntu1)
+Breaks: libertine (<= 1.4.3+17.04.20161118.1-0ubuntu1)
+Depends: libertine-qt-common,
+         libertine-tools,
+         python3-libertine-lxc,
+         ${misc:Depends},
+         ${shlibs:Depends}
+Description: sandbox for running deb-packaged X11 apps on Ubuntu Personal
+ Provides a container and related tools to be able to create, maintain, and
+ integrate legacy deb-packaged applications generally based around the X11
+ display manager on an Ubuntu "Snappy Personal" system.
+
 Package: libertine
+Depends: libertine-manager-app,
+         ${misc:Depends}
+Architecture: all
+Priority: extra
+Section: oldlibs
+Description: transitional dummy package for libertine-manager-app
+ This is a transitional package to rename libertine as libertine-manager-app.
+ It can safely be removed.
+
+Package: ubuntu-system-settings-libertine
 Architecture: any
-Depends: libertine-tools,
+Depends: libertine-qt-common,
+         libertine-tools,
          python3-libertine-lxc,
          qml-module-qtquick2,
          qtdeclarative5-ubuntu-ui-toolkit-plugin,
          ${misc:Depends},
          ${shlibs:Depends}
-Description: sandbox for running deb-packaged X11 apps on Ubuntu Personal
- Provides a container and releated tools to be able to create, maintain, and
- integrate legacy deb-packaged applications generally based around the X11
- display manager on a Ubuntu "Snappy Personal" system.
+Enhances: ubuntu-system-settings
+Description: system settings plugin for managing container-based applications
+ System Settings graphical interface to assist in the maintenance of legacy
+ deb-packaged applications generally based around the X11 display manager on
+ an Ubuntu "Snappy Personal" system.
+
+Package: libertine-qt-common
+Architecture: any
+Depends: qml-module-qtquick2,
+         qtdeclarative5-ubuntu-ui-toolkit-plugin,
+         ${misc:Depends},
+         ${shlibs:Depends}
+Description: common files for qt-based libertine applications
+ Common QML source files and translations for managing libertine containers
+ and packages used in the standalone libertine application and system settings
+ plugin.
 
 Package: libertine-tools
 Architecture: any
@@ -52,12 +93,30 @@
          ${misc:Depends},
          ${python3:Depends},
          ${shlibs:Depends}
+Recommends: libertine-xmir-tools (>= 1.4.3)
 Breaks: libertine-demo
 Replaces: libertine-demo
 Description: CLI tools for running deb-packaged X11 apps on Ubuntu Personal
  Command-line tools that can be used for creating, manipulating, and using
  the Ubuntu Personal sandbox for legacy Deb-packaged X11 applicatons.
 
+Package: libertine-xmir-tools
+Architecture: amd64 armhf arm64 i386
+Depends: libcontent-hub0,
+         libqt5core5a,
+         libqt5gui5,
+         libqt5widgets5,
+         matchbox-window-manager,
+         xmir [amd64 armhf arm64 i386],
+         ${misc:Depends},
+         ${python3:Depends},
+         ${shlibs:Depends}
+Breaks: libertine-tools (<< 1.4.3)
+Replaces: libertine-tools (<< 1.4.3)
+Description: helper apps for using and interacting with Xmir
+ Helper applications for using and interacting with Xmir such as launching
+ Xmir and allowing copy and paste.
+
 Package: liblibertine1
 Architecture: any
 Multi-Arch: same

=== renamed file 'debian/libertine.install' => 'debian/libertine-manager-app.install'
--- debian/libertine.install	2016-05-02 20:45:21 +0000
+++ debian/libertine-manager-app.install	2016-11-21 19:42:42 +0000
@@ -1,5 +1,4 @@
-usr/bin/libertine
-usr/share/applications/libertine.desktop
+usr/bin/libertine-manager-app
+usr/share/applications/libertine-manager-app.desktop
 usr/share/libertine/libertine_64.png
-usr/share/libertine/qml/*
-usr/share/locale/*/LC_MESSAGES
+usr/share/libertine/qml/gui/*

=== added file 'debian/libertine-qt-common.install'
--- debian/libertine-qt-common.install	1970-01-01 00:00:00 +0000
+++ debian/libertine-qt-common.install	2016-11-21 19:42:42 +0000
@@ -0,0 +1,2 @@
+usr/share/libertine/qml/common/*
+usr/share/locale/*/LC_MESSAGES

=== modified file 'debian/libertine-tools.install'
--- debian/libertine-tools.install	2016-09-06 12:36:47 +0000
+++ debian/libertine-tools.install	2016-11-21 19:42:42 +0000
@@ -1,7 +1,4 @@
+usr/bin/libertine-container-manager
 usr/bin/libertine-launch
-usr/bin/libertine-container-manager
-usr/bin/libertine-xmir
-usr/bin/pasted
 usr/share/bash-completion/completions/libertine-container-manager
 usr/share/man
-usr/share/upstart/sessions/libertine-xmir.conf

=== added file 'debian/libertine-xmir-tools.install'
--- debian/libertine-xmir-tools.install	1970-01-01 00:00:00 +0000
+++ debian/libertine-xmir-tools.install	2016-11-21 19:42:42 +0000
@@ -0,0 +1,3 @@
+usr/bin/libertine-xmir
+usr/bin/pasted
+usr/share/upstart/sessions/libertine-xmir.conf

=== modified file 'debian/python3-libertine-chroot.install'
--- debian/python3-libertine-chroot.install	2016-09-06 12:36:47 +0000
+++ debian/python3-libertine-chroot.install	2016-11-21 19:42:42 +0000
@@ -1,2 +1,2 @@
+usr/lib/*/libertine/update-puritine-containers
 usr/lib/python*/*/libertine/ChrootContainer.py
-usr/lib/*/libertine/update-puritine-containers

=== modified file 'debian/python3-libertine-lxc.install'
--- debian/python3-libertine-lxc.install	2016-08-19 13:33:27 +0000
+++ debian/python3-libertine-lxc.install	2016-11-21 19:42:42 +0000
@@ -1,6 +1,6 @@
+etc/sudoers.d/libertine-lxc-sudo
+usr/bin/libertine-lxc-manager
+usr/bin/libertine-lxc-setup
 usr/lib/python*/*/libertine/LxcContainer.py
-usr/bin/libertine-lxc-manager
 usr/share/dbus-1/services/com.canonical.libertine.LxcManager.service
 usr/share/libertine/libertine-lxc.conf
-etc/sudoers.d/libertine-lxc-sudo
-usr/bin/libertine-lxc-setup

=== modified file 'debian/python3-libertine.install'
--- debian/python3-libertine.install	2016-06-28 14:30:01 +0000
+++ debian/python3-libertine.install	2016-11-21 19:42:42 +0000
@@ -1,6 +1,7 @@
 usr/lib/python*/*/libertine/AppDiscovery.py
-usr/lib/python*/*/libertine/Libertine.py
 usr/lib/python*/*/libertine/ContainersConfig.py
 usr/lib/python*/*/libertine/HostInfo.py
+usr/lib/python*/*/libertine/Libertine.py
+usr/lib/python*/*/libertine/__init__.py
+usr/lib/python*/*/libertine/launcher
 usr/lib/python*/*/libertine/utils.py
-usr/lib/python*/*/libertine/__init__.py

=== added file 'debian/ubuntu-system-settings-libertine.install'
--- debian/ubuntu-system-settings-libertine.install	1970-01-01 00:00:00 +0000
+++ debian/ubuntu-system-settings-libertine.install	2016-11-21 19:42:42 +0000
@@ -0,0 +1,4 @@
+usr/lib/*/ubuntu-system-settings/liblibertine-plugin.so*
+usr/share/libertine/qml/plugin/*
+usr/share/ubuntu/settings/system/icons/libertine-plugin.png
+usr/share/ubuntu/settings/system/libertine.settings

=== modified file 'libertine/CMakeLists.txt'
--- libertine/CMakeLists.txt	2015-10-07 18:59:50 +0000
+++ libertine/CMakeLists.txt	2016-11-21 19:42:42 +0000
@@ -1,14 +1,19 @@
 configure_file(config.h.in config.h)
 
-file(GLOB_RECURSE QML_SRC *.qml *.js *.json)
+file(GLOB_RECURSE QML_SRC
+  ${CMAKE_SOURCE_DIR}/qml/common/*.qml
+  ${CMAKE_SOURCE_DIR}/qml/gui/*.qml
+)
 set(libertine_SRC
     libertine.cpp
     main.cpp
-    ${QML_SRC}
+
+    ${QML_SRC} # so the QML files show up in Qt Creator
 )
 
-add_executable(libertine ${libertine_SRC})
-target_link_libraries(libertine libertine-common Qt5::Core Qt5::Quick Qt5::Gui)
+add_executable(${LIBERTINE_EXE_NAME} ${libertine_SRC})
+target_link_libraries(${LIBERTINE_EXE_NAME} ${LIBERTINE_COMMON} ${LIBERTINE_CORE} Qt5::Core Qt5::Quick Qt5::Gui)
 
 install(DIRECTORY qml DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${CMAKE_PROJECT_NAME})
-install(TARGETS libertine RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+install(TARGETS ${LIBERTINE_EXE_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

=== modified file 'libertine/config.h.in'
--- libertine/config.h.in	2015-06-02 02:33:28 +0000
+++ libertine/config.h.in	2016-11-21 19:42:42 +0000
@@ -19,6 +19,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define LIBERTINE_APPLICATION_NAME "@PROJECT_NAME@"
+#define LIBERTINE_APPLICATION_NAME "@LIBERTINE_EXE_NAME@"
 #define LIBERTINE_VERSION          "@PROJECT_VERSION@"
 

=== modified file 'libertine/libertine.cpp'
--- libertine/libertine.cpp	2016-10-03 15:54:26 +0000
+++ libertine/libertine.cpp	2016-11-21 19:42:42 +0000
@@ -3,7 +3,7 @@
  * @brief Libertine app wrapper
  */
 /*
- * Copyright 2015 Canonical Ltd
+ * Copyright 2015-2016 Canonical Ltd
  *
  * Libertine 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
@@ -16,16 +16,18 @@
  * 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 "libertine/libertine.h"
+
+#include "common/ContainerManager.h"
+#include "common/ContainerAppsList.h"
+#include "common/ContainerArchivesList.h"
+#include "common/ContainerConfig.h"
+#include "common/ContainerConfigList.h"
+#include "common/LibertineConfig.h"
+#include "common/PackageOperationDetails.h"
 #include "libertine/config.h"
-
 #include <cstdlib>
-#include "libertine/ContainerManager.h"
-#include "libertine/ContainerAppsList.h"
-#include "libertine/ContainerArchivesList.h"
-#include "libertine/ContainerConfig.h"
-#include "libertine/ContainerConfigList.h"
-#include "libertine/libertine.h"
-#include "libertine/LibertineConfig.h"
+#include <QtCore/QCommandLineParser>
 #include <QtCore/QDebug>
 #include <QtCore/QDir>
 #include <QtCore/QFile>
@@ -38,7 +40,7 @@
 
 namespace
 {
-static QString const s_main_QML_source_file = "qml/libertine.qml";
+static QString const s_main_QML_source_file = "qml/gui/libertine.qml";
 
 /**
  * Searches for the main QML source file.
@@ -55,7 +57,7 @@
 find_main_qml_source_file()
 {
   static const QStringList sub_paths = { "", "libertine/" };
-  QStringList paths = QStandardPaths::standardLocations(QStandardPaths::DataLocation);
+  auto paths = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);
   paths.prepend(QDir::currentPath());
   paths.prepend(QCoreApplication::applicationDirPath());
   for (auto const& path: paths)
@@ -88,11 +90,20 @@
 : QGuiApplication(argc, argv)
 , main_qml_source_file_(find_main_qml_source_file())
 {
+  qmlRegisterType<ContainerConfig>("Libertine", 1, 0, "ContainerConfig");
+  qmlRegisterType<ContainerManagerWorker>("Libertine", 1, 0, "ContainerManagerWorker");
+  qmlRegisterType<PackageOperationDetails>("Libertine", 1, 0, "PackageOperationDetails");
+
   setApplicationName(LIBERTINE_APPLICATION_NAME);
   setApplicationVersion(LIBERTINE_VERSION);
-  config_.reset(new LibertineConfig(*this));
-  qmlRegisterType<ContainerConfig>("Libertine", 1, 0, "ContainerConfig");
-  qmlRegisterType<ContainerManagerWorker>("Libertine", 1, 0, "ContainerManagerWorker");
+
+  QCommandLineParser commandlineParser;
+  commandlineParser.setApplicationDescription("manage sandboxes for running legacy DEB-packaged X11-based applications");
+  commandlineParser.addHelpOption();
+  commandlineParser.addVersionOption();
+  commandlineParser.process(*this);
+
+  config_.reset(new LibertineConfig());
 
   watcher_.addPath(config_.data()->containers_config_file_name());
   connect(&watcher_, SIGNAL(fileChanged(QString)), SLOT(reload_config(QString)));
@@ -105,6 +116,7 @@
   containers_ = new ContainerConfigList(config_.data(), this);
   container_apps_ = new ContainerAppsList(containers_, this);
   container_archives_ = new ContainerArchivesList(containers_, this);
+  package_operation_details_ = new PackageOperationDetails(this);
 
   initialize_view();
   view_.show();
@@ -131,6 +143,7 @@
   ctxt->setContextProperty("containerConfigList", containers_);
   ctxt->setContextProperty("containerAppsList", container_apps_);
   ctxt->setContextProperty("containerArchivesList", container_archives_);
+  ctxt->setContextProperty("packageOperationDetails", package_operation_details_);
 
   view_.setSource(QUrl::fromLocalFile(main_qml_source_file_));
   connect(view_.engine(), SIGNAL(quit()), SLOT(quit()));

=== modified file 'libertine/libertine.h'
--- libertine/libertine.h	2016-10-03 15:48:22 +0000
+++ libertine/libertine.h	2016-11-21 19:42:42 +0000
@@ -30,6 +30,7 @@
 class LibertineConfig;
 class ContainerAppsList;
 class ContainerArchivesList;
+class PackageOperationDetails;
 
 
 class Libertine
@@ -56,6 +57,7 @@
     ContainerConfigList*            containers_;
     ContainerAppsList*              container_apps_;
     ContainerArchivesList*          container_archives_;
+    PackageOperationDetails*        package_operation_details_;
     QQuickView                      view_;
 };
 

=== modified file 'liblibertine/CMakeLists.txt'
--- liblibertine/CMakeLists.txt	2016-09-06 12:36:47 +0000
+++ liblibertine/CMakeLists.txt	2016-11-21 19:42:42 +0000
@@ -1,32 +1,33 @@
 set(API_VERSION 1)
 set(ABI_VERSION 1)
 
-set(libertine_src ${CMAKE_SOURCE_DIR}/libertine)
+set(COMMON_DIR ${CMAKE_SOURCE_DIR}/common)
 
 add_library(
-  libertine-common SHARED
+  ${LIBERTINE_CORE} SHARED
   libertine.cpp
-  ${libertine_src}/ContainerConfigList.cpp
-  ${libertine_src}/LibertineConfig.cpp
-  ${libertine_src}/ContainerConfig.cpp
-  ${libertine_src}/ContainerManager.cpp
-  ${libertine_src}/ContainerAppsList.cpp
-  ${libertine_src}/ContainerArchivesList.cpp
+
+  ${COMMON_DIR}/ContainerConfig.cpp
+  ${COMMON_DIR}/ContainerConfigList.cpp
+  ${COMMON_DIR}/LibertineConfig.cpp
 )
-set_target_properties(libertine-common PROPERTIES
+
+set_target_properties(${LIBERTINE_CORE} PROPERTIES
   VERSION ${ABI_VERSION}.0.0
   SOVERSION ${ABI_VERSION}
   OUTPUT_NAME "libertine"
 )
-target_link_libraries(libertine-common
+
+target_link_libraries(${LIBERTINE_CORE}
   ${GLIB2_LIBRARIES}
   ${PYTHON3_LIBRARIES}
   Qt5::Core
 )
 
+# "liblibertine_headers_path" is used in libertine.pc.in
 set(liblibertine_headers_path "${CMAKE_INSTALL_FULL_INCLUDEDIR}/liblibertine")
 install(FILES libertine.h DESTINATION ${liblibertine_headers_path})
-install(TARGETS libertine-common LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(TARGETS ${LIBERTINE_CORE} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
 configure_file(libertine.pc.in ${CMAKE_BINARY_DIR}/libertine.pc @ONLY)
 install(FILES ${CMAKE_BINARY_DIR}/libertine.pc

=== modified file 'liblibertine/libertine.cpp'
--- liblibertine/libertine.cpp	2016-09-06 12:36:47 +0000
+++ liblibertine/libertine.cpp	2016-11-21 19:42:42 +0000
@@ -18,8 +18,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include "liblibertine/libertine.h"
-#include "libertine/ContainerConfigList.h"
-#include "libertine/LibertineConfig.h"
+
+#include "common/ContainerConfigList.h"
+#include "common/LibertineConfig.h"
 
 
 namespace
@@ -77,29 +78,35 @@
   GError* error = nullptr;
   GArray* apps = g_array_new(TRUE, TRUE, sizeof(gchar*));
 
-  auto globalPath = g_build_filename("/", g_strdup(path), GLOBAL_APPLICATIONS, nullptr);
-  error = list_apps_from_path(globalPath, container_id, apps);
-  if (error != nullptr)
+  if (path != nullptr)
   {
-    g_free(globalPath);
-    g_free(path);
-    g_error_free(error);
-    return (gchar**)g_array_free(apps, FALSE);
+      auto global_path = g_build_filename("/", g_strdup(path), GLOBAL_APPLICATIONS, nullptr);
+      error = list_apps_from_path(global_path, container_id, apps);
+      if (error != nullptr)
+      {
+        g_free(global_path);
+        g_free(path);
+        g_error_free(error);
+        return (gchar**)g_array_free(apps, FALSE);
+      }
+      g_free(global_path);
   }
-  g_free(globalPath);
+  g_free(path);
 
   auto home_path = libertine_container_home_path(container_id);
-  auto local_path = g_build_filename(home_path, LOCAL_APPLICATIONS, nullptr);
+  if (home_path != nullptr)
+  {
+      auto local_path = g_build_filename(home_path, LOCAL_APPLICATIONS, nullptr);
+
+      error = list_apps_from_path(local_path, container_id, apps);
+      if (error != nullptr)
+      {
+        g_error_free(error); // free error, but return previously found apps
+      }
+      g_free(local_path);
+  }
   g_free(home_path);
 
-  error = list_apps_from_path(local_path, container_id, apps);
-  if (error != nullptr)
-  {
-    g_error_free(error); // free error, but return previously found apps
-  }
-  g_free(local_path);
-
-  g_free(path);
   return (gchar**)g_array_free(apps, FALSE);
 }
 
@@ -130,10 +137,10 @@
 gchar *
 libertine_container_path(const gchar * container_id)
 {
-  gchar * path = NULL;
-  g_return_val_if_fail(container_id != NULL, NULL);
+  gchar * path = nullptr;
+  g_return_val_if_fail(container_id != nullptr, nullptr);
 
-  path = g_build_filename(g_get_user_cache_dir(), "libertine-container", container_id, "rootfs", NULL);
+  path = g_build_filename(g_get_user_cache_dir(), "libertine-container", container_id, "rootfs", nullptr);
 
   if (g_file_test(path, G_FILE_TEST_EXISTS))
   {
@@ -142,7 +149,7 @@
   else
   {
     g_free(path);
-    return NULL;
+    return nullptr;
   }
 }
 
@@ -150,10 +157,10 @@
 gchar *
 libertine_container_home_path(const gchar * container_id)
 {
-  gchar * path = NULL;
-  g_return_val_if_fail(container_id != NULL, NULL);
+  gchar * path = nullptr;
+  g_return_val_if_fail(container_id != nullptr, nullptr);
 
-  path = g_build_filename(g_get_user_data_dir(), "libertine-container", "user-data", container_id, NULL);
+  path = g_build_filename(g_get_user_data_dir(), "libertine-container", "user-data", container_id, nullptr);
 
   if (g_file_test(path, G_FILE_TEST_EXISTS))
   {
@@ -162,7 +169,7 @@
   else
   {
     g_free(path);
-    return NULL;
+    return nullptr;
   }
 
 }
@@ -173,7 +180,7 @@
 {
   guint container_count;
   guint i;
-  gchar * container_name = NULL;
+  gchar * container_name = nullptr;
   LibertineConfig config;
   ContainerConfigList container_list(&config);
   QVariant id;

=== modified file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	2016-09-30 18:55:22 +0000
+++ python/libertine/ChrootContainer.py	2016-11-21 19:42:42 +0000
@@ -199,26 +199,29 @@
 
         return proot_cmd
 
-    def launch_application(self, app_exec_line):
+    def start_application(self, app_exec_line, environ):
         # FIXME: Disabling seccomp is a temporary measure until we fully understand why we need
         #        it or figure out when we need it.
-        os.environ['PROOT_NO_SECCOMP'] = '1'
+        environ['PROOT_NO_SECCOMP'] = '1'
 
         # Workaround issue where a custom dconf profile is on the machine
-        if 'DCONF_PROFILE' in os.environ:
-            del os.environ['DCONF_PROFILE']
+        if 'DCONF_PROFILE' in environ:
+            del environ['DCONF_PROFILE']
 
         proot_cmd = self._build_proot_command()
 
         args = shlex.split(proot_cmd)
         args.extend(utils.setup_window_manager(self.container_id, enable_toolbars=True))
-        window_manager = psutil.Popen(args)
+        window_manager = psutil.Popen(args, env=environ)
 
         args = shlex.split(proot_cmd)
         args.extend(app_exec_line)
-        psutil.Popen(args).wait()
+        app = psutil.Popen(args, env=environ)
+        return app
 
+    def finish_application(self, app):
         utils.terminate_window_manager(window_manager)
+        app.wait()
 
     def _run_ldconfig(self, verbosity=1):
         if verbosity == 1:
@@ -227,4 +230,8 @@
         command_line = self._build_privileged_proot_cmd() + " ldconfig.REAL"
 
         args = shlex.split(command_line)
-        subprocess.Popen(args).wait()
+        app = subprocess.Popen(args)
+        return app
+
+    def finish_application(self, app):
+        app.wait()

=== modified file 'python/libertine/ContainersConfig.py'
--- python/libertine/ContainersConfig.py	2016-08-25 11:55:05 +0000
+++ python/libertine/ContainersConfig.py	2016-11-21 19:42:42 +0000
@@ -36,6 +36,10 @@
 def write_container_config_file(container_list):
     container_config_file = libertine.utils.get_libertine_database_file_path()
 
+    # Add a warning to adventurous users advising against mucking with this file
+    if container_list is not None:
+        container_list["_warning"] = "This file is automatically generated by Libertine and should not be manually edited."
+
     with open(container_config_file, 'w') as fd:
         fcntl.lockf(fd, fcntl.LOCK_EX)
         json.dump(container_list, fd, sort_keys=True, indent=4)
@@ -322,6 +326,17 @@
                                                         package_name)
 
     """
+    Operations for running apps in a Libertine container.
+    """
+    def add_running_app(self, container_id, app_exec_name, pid=0):
+        app_obj = {'appExecName': app_exec_name, 'pid': pid}
+        self._set_value_by_key(container_id, 'runningApps', app_obj)
+
+    def delete_running_app(self, container_id, app_exec_name):
+        self._delete_array_object_by_key_value(container_id, 'runningApps',
+                                               'appExecName', app_exec_name)
+
+    """
     Fetcher functions for various configuration information.
     """
     def get_container_distro(self, container_id):

=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2016-09-30 18:55:22 +0000
+++ python/libertine/Libertine.py	2016-11-21 19:42:42 +0000
@@ -14,19 +14,11 @@
 
 from .AppDiscovery import AppLauncherCache
 from gi.repository import Libertine
-from multiprocessing import Process, active_children
-from socket import *
 import abc
 import contextlib
 import libertine.utils
 import os
-import psutil
-import select
 import shutil
-import shlex
-import signal
-import sys
-import time
 
 from libertine.ContainersConfig import ContainersConfig
 from libertine.HostInfo import HostInfo
@@ -56,6 +48,32 @@
     return False
 
 
+class NoContainer(object):
+    """
+    A containerless class used for launching apps with libertine-launch.
+    """
+    def connect(self):
+        """
+        A no-op function used by the Session class.
+        """
+        pass
+
+    def disconnect(self):
+        """
+        A no-op function used by the Session class.
+        """
+        pass 
+
+    def start_application(self, app_exec_line, environ):
+        import psutil
+
+        app = psutil.Popen(app_exec_line, env=environ)
+        return app
+
+    def finish_application(self, app):
+        app.wait()
+
+
 class BaseContainer(metaclass=abc.ABCMeta):
     """
     An abstract base container to provide common functionality for all
@@ -249,11 +267,14 @@
     def run_in_container(self, command_string):
         return 0
 
-    def launch_application(self, app_exec_line):
+    def start_application(self, app_exec_line, environ):
         import subprocess
 
-        cmd = subprocess.Popen(app_exec_line)
-        cmd.wait()
+        app = subprocess.Popen(app_exec_line, env=environ)
+        return app
+
+    def finish_application(self, app):
+        app.wait()
 
 
 class ContainerRunning(contextlib.ExitStack):
@@ -265,9 +286,8 @@
     """
     def __init__(self, container):
         super().__init__()
-        if not container.is_running():
-            container.start_container()
-            self.callback(lambda: container.stop_container())
+        container.start_container()
+        self.callback(lambda: container.stop_container())
 
 
 class LibertineContainer(object):
@@ -382,21 +402,34 @@
         except RuntimeError as e:
             return handle_runtime_error(e)
 
-    def launch_application(self, app_exec_line):
+    def connect(self):
+        """
+        Connects to the container in preparation to launch an application.  May
+        do something like start up daemons or bind-mount directories, I dunno,
+        it's up to the concrete container class.  Maybe it does nothing.
+        """
+        pass
+
+    def disconnect(self):
+        """
+        The inverse of connect() above.
+        """
+        pass
+
+    def start_application(self, app_exec_line, environ):
         """
         Launches an application in the container.
 
         :param app_exec_line: the application exec line as passed in by
             ubuntu-app-launch
         """
-        if self.containers_config.container_exists(self.container.container_id):
-            # Update $PATH as necessary
-            if '/usr/games' not in os.environ['PATH']:
-                os.environ['PATH'] = os.environ['PATH'] + ":/usr/games"
+        return self.container.start_application(app_exec_line, environ)
 
-            self.container.launch_application(app_exec_line)
-        else:
-            raise RuntimeError("Container with id %s does not exist." % self.container.container_id)
+    def finish_application(self, app):
+        """
+        Finishes the currently running application in the container.
+        """
+        self.container.finish_application(app)
 
     def list_app_launchers(self, use_json=False):
         """
@@ -450,262 +483,3 @@
                 return self.container.configure_remove_archive(archive, verbosity)
         except RuntimeError as e:
             return handle_runtime_error(e)
-
-
-class Socket(object):
-    """
-    A simple socket wrapper class. This will wrap a socket
-
-    :param socket: A python socket to be wrapped
-    """
-    def __init__(self, sock):
-        if not isinstance(sock, socket):
-             raise TypeError("expected socket to be a python socket class instead found: '{}'".format(sock.__class__))
-
-        self.socket = sock
-
-    """
-    Implement equality checking for other instances of this class or ints only.
-
-    :param other: Either a Socket class or an int
-    """
-    def __eq__(self, other):
-        if isinstance(other, Socket):
-            return self.socket == other.socket
-        elif isinstance(other, socket):
-            return self.socket == other
-        elif isinstance(other, int):
-            return self.socket.fileno() == other
-        else:
-             raise TypeError("unsupported operand type(s) for ==: '{}' and '{}'".format(self.__class__, type(other)))
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __hash__(self):
-        return self.socket.fileno()
-
-    def socket(self):
-        return self.socket
-
-class SessionSocket(Socket):
-    """
-    Creates a AF_UNIX socket from a path to be used as the session socket.
-    This is used for RAII and to take ownership of the socket
-
-    :param path: The path the socket will be binded with
-    """
-    def __init__(self, session_path):
-        try:
-            sock = socket(AF_UNIX, SOCK_STREAM)
-        except:
-            sock = None
-            raise
-        else:
-            try:
-                sock.bind(session_path)
-                sock.listen(5)
-            except:
-                sock.close()
-                sock = None
-                raise
-            else:
-                super().__init__(sock)
-                self.session_path = session_path
-
-    def __del__(self):
-        self.socket.shutdown(SHUT_RDWR)
-        self.socket.close()
-        os.remove(self.session_path)
-
-
-class HostSessionSocketPair():
-    def __init__(self, host_socket_path, session_socket_path):
-        self.host_socket_path    = host_socket_path
-        self.session_socket_path = session_socket_path
-
-
-class LibertineSessionBridge(object):
-    """
-    Creates a session bridge which will pair host and session sockets to proxy the info
-    from the session to the host and vice versa.
-
-    :param host_session_socket_paths: A list of pairs container valid sockets to proxy {host:session}
-    """
-    def __init__(self, host_session_socket_paths):
-        self.descriptors = []
-        self.host_session_socket_path_map = {}
-        self.socket_pairs = {}
-
-        for host_session_socket_pair in host_session_socket_paths:
-            host_path    = host_session_socket_pair.host_socket_path
-            session_path = host_session_socket_pair.session_socket_path
-
-            socket = SessionSocket(session_path)
-
-            self.descriptors.append(socket)
-            self.host_session_socket_path_map.update({socket:host_path})
-
-    """
-    If we end up going out of scope/error let's make sure we clean up sockets and paths.
-    """
-    def __del__(self):
-        self.socket_pairs = None
-        self.descriptors  = None
-        self.host_session_socket_path_map = None
-
-    """
-    When a new connection is made on one of the main sockets we have to create a new
-    socket pairing with the container socket.
-
-    :param host_path:      The raw path to the container socket
-    :param container_sock: The socket which received a new connection
-    """
-    def accept_new_connection(self, host_path, container_sock):
-        newconn = Socket(container_sock.accept()[0])
-        self.descriptors.append(newconn)
-
-        host_sock = Socket(socket(AF_UNIX, SOCK_STREAM))
-        host_sock.socket.connect(host_path)
-        self.descriptors.append(host_sock)
-
-        self.socket_pairs.update({newconn:host_sock})
-        self.socket_pairs.update({host_sock:newconn})
-
-    """
-    Cleans up a socket that has had its connection closed.
-
-    :param socket_to_remove: The socket that had its connection closed
-    """
-    def close_connections(self, socket_to_remove):
-        partner_socket = self.socket_pairs[socket_to_remove.fileno()]
-
-        self.socket_pairs.pop(socket_to_remove.fileno())
-        self.socket_pairs.pop(partner_socket.socket.fileno())
-
-        self.descriptors.remove(socket_to_remove)
-        self.descriptors.remove(partner_socket)
-
-        if socket_to_remove in self.host_session_socket_path_map:
-            self.host_session_socket_path_map.pop(socket_to_remove)
-
-    """
-    The main loop which uses select to block until one of the sockets we are listening to becomes readable.
-    It is advised this be started in its own process or thread, as this function blocks!
-    """
-    def main_loop(self):
-        while 1:
-            try:
-                raw_sockets = list(map(lambda x : x.socket, self.descriptors))
-                rlist, wlist, elist = select.select(raw_sockets, [], [])
-            except InterruptedError as e:
-                continue
-            except Exception as e:
-                libertine.utils.get_logger().exception(e)
-                break
-
-            for sock in rlist:
-                if sock.fileno() == -1:
-                    continue
-
-                # Its possible to have multiple socket reads that are pairs. If this happens and we remove a pair we
-                # need to ignore the other pair since it no longer has a complete pair
-                if sock.fileno() not in self.host_session_socket_path_map and sock.fileno() not in self.socket_pairs:
-                    continue
-
-                if sock.fileno() in self.host_session_socket_path_map:
-                    self.accept_new_connection(self.host_session_socket_path_map[sock.fileno()], sock)
-
-                else:
-                    try:
-                        data = sock.recv(4096)
-                    except Exception as e:
-                        libertine.utils.get_logger().exception(e)
-                        self.close_connections(sock)
-                        continue
-                    else:
-                        if len(data) == 0:
-                            self.close_connections(sock)
-                            continue
-
-                    send_sock = self.socket_pairs[sock.fileno()].socket
-
-                    if send_sock.fileno() < 0:
-                        continue
-
-                    totalsent = 0
-                    while totalsent < len(data):
-                        try:
-                            sent = send_sock.send(data)
-                        except BrokenPipeError as e:
-                            libertine.utils.get_logger().exception(e)
-                            self.close_connections(sock)
-                            break
-                        else:
-                            if sent == 0:
-                                close_connections(sock)
-                                break
-                            totalsent = totalsent + sent
-
-
-class LibertineApplication(object):
-    """
-    Launches a libertine container with a session bridge for sockets such as dbus
-
-    :param container_id: The container id.
-    :param app_exec_line: The exec line used to start the app in the container.
-    """
-    def __init__(self, container_id, app_exec_line):
-        signal.signal(signal.SIGTERM, self.cleanup_lsb)
-        signal.signal(signal.SIGINT,  self.cleanup_lsb)
-
-        self.container_id  = container_id
-        self.app_exec_line = app_exec_line
-        self.lsb           = None
-        self.pasted        = None
-
-    def cleanup_lsb(self, signum, frame):
-        self.close_lsb()
-
-    def close_lsb(self):
-        if self.lsb is not None:
-            self.lsb_process.terminate()
-
-        while active_children():
-            time.sleep(1)
-
-    """
-    Launches the libertine session bridge. This creates a proxy socket to read to and from
-    for abstract sockets such as dbus.
-
-    :param session_socket_paths: A list of socket paths the session will create.
-    """
-    def launch_session_bridge(self, session_socket_paths):
-        self.lsb         = LibertineSessionBridge(session_socket_paths)
-        self.lsb_process = Process(target=self.lsb.main_loop)
-        self.lsb_process.start()
-
-    """
-    Launches the pasted process for allowing copy and paste to work with X apps and
-    content-hub.
-    """
-    def launch_pasted(self):
-        self.pasted = psutil.Popen("pasted")
-
-    """
-    Launches the container from the id and attempts to run the application exec.
-    """
-    def launch_application(self):
-        if not ContainersConfig().container_exists(self.container_id):
-            raise RuntimeError("Container ID %s does not exist." % self.container_id)
-
-        container = LibertineContainer(self.container_id)
-        try:
-            container.launch_application(self.app_exec_line)
-        except:
-            raise
-        finally:
-            self.close_lsb()
-
-            if self.pasted is not None:
-                self.pasted.terminate()

=== modified file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	2016-09-20 13:58:52 +0000
+++ python/libertine/LxcContainer.py	2016-11-21 19:42:42 +0000
@@ -56,6 +56,14 @@
     return os.path.join(home_path, '.config', 'lxc')
 
 
+def get_lxc_manager_dbus_name():
+    return LIBERTINE_LXC_MANAGER_NAME
+
+
+def get_lxc_manager_dbus_path():
+    return LIBERTINE_LXC_MANAGER_PATH
+
+
 def lxc_container(container_id):
     config_path = utils.get_libertine_containers_dir_path()
     if not os.path.exists(config_path):
@@ -66,6 +74,28 @@
     return container
 
 
+def lxc_start(container, lxc_log_file):
+    container.append_config_item("lxc.logfile", lxc_log_file)
+    container.append_config_item("lxc.logpriority", "3")
+
+    if not container.start():
+        return (False, "Container failed to start")
+
+    if not container.wait("RUNNING", 10):
+        return (False, "Container failed to enter the RUNNING state")
+
+    if not container.get_ips(timeout=30):
+        lxc_stop(container)
+        return (False, "Not able to connect to the network.")
+
+    return (True, "")
+
+
+def lxc_stop(container):
+    if container.running:
+        container.stop()
+
+
 def get_host_timezone():
     with open(os.path.join('/', 'etc', 'timezone'), 'r') as fd:
         host_timezone = fd.read().strip('\n')
@@ -107,6 +137,18 @@
         super().__init__(container_id)
         self.container_type = "lxc"
         self.container = lxc_container(container_id)
+        self._set_lxc_log()
+        self.lxc_manager_interface = None
+        self.window_manager = None
+
+        utils.set_session_dbus_env_var()
+
+        try:
+            bus = dbus.SessionBus()
+            lxc_mgr_service = bus.get_object(get_lxc_manager_dbus_name(), get_lxc_manager_dbus_path())
+            self.lxc_manager_interface = dbus.Interface(lxc_mgr_service, get_lxc_manager_dbus_name())
+        except dbus.exceptions.DBusException:
+            pass
 
     def is_running(self):
         return self.container.running
@@ -122,40 +164,26 @@
         else:
             return True
 
-    def _dynamic_bind_mounts(self):
-        for user_dir in utils.get_common_xdg_user_directories():
-            xdg_user_dir_entry = (
-                "%s %s/%s none bind,create=dir,optional"
-                % (user_dir[0], home_path.strip('/'), user_dir[1])
-            )
-            self.container.append_config_item("lxc.mount.entry", xdg_user_dir_entry)
-
-    def start_container(self, launchable = False):
-        if not self.container.defined:
-            raise RuntimeError("Container %s is not valid" % self.container_id)
-
-        if not self.container.running:
-            self._set_lxc_log()
-            self._dynamic_bind_mounts()
-            if not self.container.start():
-                self._dump_lxc_log()
-                raise RuntimeError("Container failed to start")
-            if not self.container.wait("RUNNING", 10):
-                self._dump_lxc_log()
-                raise RuntimeError("Container failed to enter the RUNNING state")
-
-        if not self.container.get_ips(timeout=30):
-            self.stop_container()
-            raise RuntimeError("Not able to connect to the network.")
-
-        if not launchable:
-            if self.run_in_container("mountpoint -q /tmp/.X11-unix") == 0:
-                self.run_in_container("umount /tmp/.X11-unix")
-            if self.run_in_container("mountpoint -q /usr/lib/locale") == 0:
-                self.run_in_container("umount -l /usr/lib/locale")
+    def start_container(self):
+        if self.lxc_manager_interface:
+            (result, error) = self.lxc_manager_interface.operation_start(self.container_id, self.lxc_log_file)  
+        else:
+            (result, error) = lxc_start(self.container, self.lxc_log_file)
+
+        if not result:
+            self._dump_lxc_log()
+            raise RuntimeError(error)
+
+        if self.run_in_container("mountpoint -q /tmp/.X11-unix") == 0:
+            self.run_in_container("umount /tmp/.X11-unix")
+        if self.run_in_container("mountpoint -q /usr/lib/locale") == 0:
+            self.run_in_container("umount -l /usr/lib/locale")
 
     def stop_container(self):
-        self.container.stop()
+        if self.lxc_manager_interface:
+            self.lxc_manager_interface.operation_stop(self.container_id)
+        else:
+            lxc_stop(self.container)
 
     def run_in_container(self, command_string):
         cmd_args = shlex.split(command_string)
@@ -282,49 +310,49 @@
         # Dump it all to disk
         self.container.save_config()
 
-    def launch_application(self, app_exec_line):
-        bus = dbus.SessionBus()
-        lxc_mgr_service = bus.get_object(LIBERTINE_LXC_MANAGER_NAME, LIBERTINE_LXC_MANAGER_PATH)
-        lxc_manager_interface = dbus.Interface(lxc_mgr_service, LIBERTINE_LXC_MANAGER_NAME)  
-        
-        if lxc_manager_interface.app_start(self.container_id):
-            if not self.container.wait("RUNNING", 10):
-                print("Container failed to enter the RUNNING state")
-                return
-
-            if not self.container.get_ips(timeout=30):
-                print("Not able to connect to the network.")
-                return
-
-        else:
-            print("Failure detected from libertine-lxc-manager")
-            return
-
-        window_manager = self.container.attach(lxc.attach_run_command,
-                                               utils.setup_window_manager(self.container_id))
+    def start_application(self, app_exec_line, environ):
+        if self.lxc_manager_interface == None:
+            print("No interface to libertine-lxc-manager.  Failing application launch.")
+            return
+
+        os.environ.clear()
+        os.environ.update(environ)
+
+        (result, error) = self.lxc_manager_interface.app_start(self.container_id, self.lxc_log_file)
+
+        if not result:
+            self._dump_lxc_log()
+            print("%s" % error)
+            return
+
+        self.window_manager = self.container.attach(lxc.attach_run_command,
+                                                    utils.setup_window_manager(self.container_id))
 
         # Setup pulse to work inside the container
         os.environ['PULSE_SERVER'] = utils.get_libertine_lxc_pulse_socket_path()
 
         app_launch_cmd = "sudo -E -u " + os.environ['USER'] + " env PATH=" + os.environ['PATH']
         cmd = shlex.split(app_launch_cmd)
-        self.container.attach_wait(lxc.attach_run_command,
-                                   cmd + app_exec_line)
-
-        utils.terminate_window_manager(psutil.Process(window_manager))
+        app = self.container.attach(lxc.attach_run_command,
+                                    cmd + app_exec_line)
+        return psutil.Process(app)
+
+    def finish_application(self, app):
+        os.waitpid(app.pid, 0)
+
+        utils.terminate_window_manager(psutil.Process(self.window_manager))
 
         # Tell libertine-lxc-manager that the app has stopped.
-        lxc_manager_interface.app_stop(self.container_id)
+        self.lxc_manager_interface.app_stop(self.container_id)
 
     def _set_lxc_log(self):
         self.lxc_log_file = os.path.join(tempfile.mkdtemp(), 'lxc-start.log')
-        self.container.append_config_item("lxc.logfile", self.lxc_log_file)
-        self.container.append_config_item("lxc.logpriority", "3")
 
     def _dump_lxc_log(self):
-        try:
-            with open(self.lxc_log_file, 'r') as fd:
-                for line in fd:
-                    print(line.lstrip())
-        except Exception as ex:
-            print("Could not open LXC log file: %s" % ex, file=sys.stderr)
+        if os.path.exists(self.lxc_log_file):
+            try:
+                with open(self.lxc_log_file, 'r') as fd:
+                    for line in fd:
+                        print(line.lstrip())
+            except Exception as ex:
+                print("Could not open LXC log file: %s" % ex, file=sys.stderr)

=== modified file 'python/libertine/__init__.py'
--- python/libertine/__init__.py	2016-08-04 23:21:52 +0000
+++ python/libertine/__init__.py	2016-11-21 19:42:42 +0000
@@ -22,21 +22,12 @@
 
 __all__ = [
           # from Libertine
-          'LibertineApplication',
           'LibertineContainer',
-          'LibertineSessionBridge',
-          'LibertineSessionBridge',
-          'HostSessionSocketPair',
-          'SessionSocket',
-          'Socket',
+          'NoContainer',
           'utils',
           ]
 
 __docformat__ = "restructuredtext en"
 
-from libertine.Libertine import LibertineApplication
 from libertine.Libertine import LibertineContainer
-from libertine.Libertine import LibertineSessionBridge
-from libertine.Libertine import HostSessionSocketPair
-from libertine.Libertine import SessionSocket
-from libertine.Libertine import Socket
+from libertine.Libertine import NoContainer

=== added directory 'python/libertine/launcher'
=== added file 'python/libertine/launcher/__init__.py'
--- python/libertine/launcher/__init__.py	1970-01-01 00:00:00 +0000
+++ python/libertine/launcher/__init__.py	2016-11-21 19:42:42 +0000
@@ -0,0 +1,28 @@
+# Copyright 2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Provides the Libertine launcher functionality.
+
+All the things used specifically for launching and running an application under
+a Libertine aegis are in this subpackage.  It is the principal guts of the
+libertine-launch tool and associated test suites.
+
+This is the public interface of the Libertine launcher package.
+"""
+
+from .config import Config, SocketBridge
+from .session import Session, translate_to_real_address
+from .task import LaunchServiceTask, TaskConfig, TaskType
+
+__all__ = ('Config', 'Session')

=== added file 'python/libertine/launcher/config.py'
--- python/libertine/launcher/config.py	1970-01-01 00:00:00 +0000
+++ python/libertine/launcher/config.py	2016-11-21 19:42:42 +0000
@@ -0,0 +1,297 @@
+# Copyright 2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Configure the libertine launcher."""
+
+import argparse
+import dbus
+import os
+import random
+import string
+import sys
+from .task import TaskType, TaskConfig
+from .. import utils
+
+import gettext
+gettext.textdomain('libertine')
+_ = gettext.gettext
+
+log = utils.get_logger()
+
+
+def _generate_unique_id():
+    """Generate a (hopefully) unique identifier string."""
+    return ''.join(random.choice(string.ascii_lowercase + string.digits) for i in range(8))
+
+
+class SocketBridge(object):
+    """Configuration for a single socket bridge entry.
+
+    This is a 3-tuple of a label, the address of a Unix-domain socket in the
+    host environment, and the address of a Unix-domain socket in the session
+    environment.
+
+    .. data:: env_var
+
+       The label of the socket bridge.  This is used as the environment variable
+       in the session environment.  It should follow the naming rules for
+       environment variables.
+
+    .. data:: host_address
+
+        The address of a Unix-domain socket in the host environment.
+
+    .. data:: session_address
+
+        The address of a Unix-domain socket in the session environment.
+
+    """
+
+    def __init__(self, env_var, host_address, session_address):
+        """Initialize the socket bridge address pair.
+
+        :param env_var: The socket bridge label.
+        :param host_address: The host socket address.
+        :param session_address: The session socket address.
+
+        """
+        self.env_var         = env_var
+        self.host_address    = host_address
+        self.session_address = session_address
+
+    def __repr__(self):
+        """Get a human-readable string representation."""
+        return '{{{}:{}->{}}}'.format(self.env_var, self.host_address, self.session_address)
+
+
+def _get_maliit_address_from_dbus():
+    """Query the session D-Bus for the address of the Maliit server.
+
+    If there is no response from the D-Bus (let's just say there is no maliit
+    server running) None is returned.
+    """
+    try:
+        address_bus_name    = 'org.maliit.server'
+        address_object_path = '/org/maliit/server/address'
+        address_interface   = 'org.maliit.Server.Address'
+        address_property    = 'address'
+
+        session_bus   = dbus.SessionBus()
+        maliit_object = session_bus.get_object('org.maliit.server', '/org/maliit/server/address')
+        interface = dbus.Interface(maliit_object, dbus.PROPERTIES_IFACE)
+        return interface.Get('org.maliit.Server.Address', 'address')
+    except Exception as ex:
+        log.warning(ex)
+        return None
+
+
+class Config(object):
+    """Configuration for the libertine application launcher.
+
+    The main configuration items are the container ID and the application
+    command line.  Additional configuration items include and environment
+    variables to be passed in to the application session and any sockets to be
+    bridged between the session and the host.
+
+    The following members can be read from objects of this class.
+
+    ==================  ==================
+    Attribute           Description
+    ------------------  ------------------
+    **id**              A unique session identifier.  A random string of letters and numbers.
+    **container_id**    The ID of the container in which the session will run.
+    **exec_line**       The program and arguments to execute.
+    **host_environ**    A sanitized dictionary of environment variables to
+                        export in host operations.
+    **session_environ** A sanitized, remapped, and extended dictionary of environment variables to
+                        export in the session environment.  Effectively a copy of the host
+                        environment but with some changes.
+    **socket_bridges**  A collection of SocketBridge objects to implement.
+    **prelaunch_tasks** A collection of tasks to perform before launching the application.
+    ==================  ==================
+
+    """
+
+    def __init__(self, argv=sys.argv[1:]):
+        """
+        :param argv: Command-line arguments used to configure the launcher.  Default is ``sys.argv``.
+
+        """
+        log.debug('Config.__init__() begins')
+        arg_parser = argparse.ArgumentParser(description=_('Launch an application natively or in a Libertine container'))
+        arg_parser.add_argument('-i', '--id',
+                                help=_('Container identifier when launching containerized apps'))
+        arg_parser.add_argument('-E', '--env',
+                                default=[],
+                                dest='environ',
+                                action='append',
+                                help=_('Set an environment variable'))
+        arg_parser.add_argument('app_exec_line',
+                                nargs=argparse.REMAINDER,
+                                help=_('exec line'))
+        options = arg_parser.parse_args(args=argv)
+
+        if not options.app_exec_line:
+            arg_parser.error('Must specify an exec line')
+
+        if options.id:
+            self.container_id = options.id
+        else:
+            self.container_id = None
+
+        self.id              = _generate_unique_id()
+        self.exec_line       = options.app_exec_line
+        self.host_environ    = self._sanitize_host_environment(options)
+        self.socket_bridges  = self._create_socket_bridges()
+        self.prelaunch_tasks = self._add_prelaunch_tasks()
+        self.session_environ = self._generate_session_environment()
+
+        log.debug('id = "{}"'.format(self.id))
+        log.debug('container_id = "{}"'.format(self.container_id))
+        log.debug('exec_line = "{}"'.format(self.exec_line))
+        log.debug('session_environ = {}'.format(self.session_environ))
+        for bridge in self.socket_bridges:
+            log.debug('socket bridge: {}'.format(bridge))
+        log.debug('Config.__init__() ends')
+
+    def _sanitize_host_environment(self, options):
+        """Create a dictionary of sanitized environment variables.
+
+        The environment available in the Libertine aegis are effectively those
+        of the launcher, but santized to remove any unwanted or dangerous stuff
+        and with and changes requested on the command line.
+
+        :param options: A collection of option values including a dictionary
+                        named 'environ'.
+        :param type: An argparse namespace.
+
+        :returns: A sanitized host environment dictionary.
+        """
+        # inherit from the host
+        environ = os.environ.copy()
+
+        # remove problematic environment variables
+        for e in ['QT_QPA_PLATFORM', 'LD_LIBRARY_PATH', 'FAKECHROOT_BASE', 'FAKECHROOT_CMD_SUBST']:
+            if e in environ:
+                del environ[e]
+
+        # add or replace CLI-speicifed variables
+        for e in options.environ:
+            k, v = e.split(sep='=', maxsplit=2)
+            environ[k] = v
+
+        return environ
+
+    def _generate_session_environment(self):
+        """Generate the session environment."""
+
+        # Start with the host environment.
+        environ = self.host_environ.copy()
+
+        # Fudge some values.
+        path = environ.get('PATH', '/usr/bin')
+        if '/usr/games' not in path.split(sep=':'):
+            environ['PATH'] = path + os.pathsep + '/usr/games'
+
+        # Add the remapped socket bridge variables.
+        for bridge in self.socket_bridges:
+            environ[bridge.env_var] = 'unix:path=' + bridge.session_address
+
+        return environ
+
+    def _add_prelaunch_tasks(self):
+        """Create a collection of pre-launch tasks."""
+        tasks = []
+        tasks.append(TaskConfig(TaskType.LAUNCH_SERVICE, ["pasted"]))
+
+        if self.container_id is None:
+            tasks.append(TaskConfig(TaskType.LAUNCH_SERVICE, ['matchbox-window-manager', '-use_titlebar', 'no']))
+
+        return tasks
+
+    def _create_socket_bridges(self):
+        """Create the required socket bridge configs."""
+        bridges = []
+
+        if self.container_id:
+            maliit_host_bridge = self._create_maliit_host_bridge()
+            if maliit_host_bridge:
+                bridges.append(maliit_host_bridge)
+            dbus_host_bridge = self._create_dbus_host_bridge()
+            if dbus_host_bridge:
+                bridges.append(dbus_host_bridge)
+
+        return bridges
+
+    def _generate_session_socket_name(self, socket_target):
+        """Generate a socket name for the target.
+
+        :param target: A string used as a base for the socket address.
+
+        If there is a seession ID, the session ID is appended to the socket name
+        to make it (hopefully) unique.
+        """
+        socket_name = os.path.join(utils.get_libertine_runtime_dir(), socket_target)
+        if self.id:
+            socket_name += ('-' + self.id)
+        return socket_name
+
+    def _get_dbus_host_address(self):
+        """Get (or try to get) the D-Bus server socket address.
+
+        If the D-Bus server socket address environment variable is set, the
+        value of that environment variable is used, otherwise None is returned.
+        """
+        return self.host_environ.get('DBUS_SESSION_BUS_ADDRESS', None)
+
+    def _create_dbus_host_bridge(self):
+        """Create a socket bridge for the D-Bus session.
+
+        Creates a socket bridge configuration for the D-Bus session, if a socket
+        can be found for the host, otherwise returns None.
+        """
+        socket_bridge = None
+        server_address = self._get_dbus_host_address()
+        if server_address:
+            socket_bridge = SocketBridge('DBUS_SESSION_BUS_ADDRESS',
+                                         server_address,
+                                         self._generate_session_socket_name('dbus'))
+        return socket_bridge
+
+    def _get_maliit_host_address(self):
+        """Get (or try to get) the Maliit server socket address.
+
+        If the Maliit server socket address environment variable is set, the
+        value of that environment variable is used, otherwise an attempt is made
+        to query the session D-Bus.  If neither works, Maliit is probably not
+        there.
+        """
+        env_var = self.host_environ.get('MALIIT_SERVER_ADDRESS', None)
+        if env_var:
+            return env_var
+        return _get_maliit_address_from_dbus()
+
+    def _create_maliit_host_bridge(self):
+        """Create a socket bridge for the Maliit server.
+
+        Creates a socket bridge configuration for the Maliit server, if a socket
+        can be found for the host, otherwise returns None.
+        """
+        socket_bridge = None
+        server_address = self._get_maliit_host_address()
+        if server_address:
+            socket_bridge = SocketBridge('MALIIT_SERVER_ADDRESS',
+                                         server_address,
+                                         self._generate_session_socket_name('maliit'))
+        return socket_bridge

=== added file 'python/libertine/launcher/session.py'
--- python/libertine/launcher/session.py	1970-01-01 00:00:00 +0000
+++ python/libertine/launcher/session.py	2016-11-21 19:42:42 +0000
@@ -0,0 +1,358 @@
+# Copyright 2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""High-level interface for starting and running an application in Libertine."""
+
+import os
+import selectors
+import signal
+import struct
+import sys
+
+from .config import Config
+from .. import utils
+from contextlib import ExitStack, suppress
+from libertine.ContainersConfig import ContainersConfig
+from psutil import STATUS_ZOMBIE
+from socket import socket, AF_UNIX, SOCK_STREAM, SHUT_RDWR
+from .task import LaunchServiceTask, TaskType
+
+
+log = utils.get_logger()
+
+
+def translate_to_real_address(abstract_address):
+    """Translate the notional text address to a real UNIX-domain address string.
+
+    :param abstract_address: The human-readable abstract socket address string.
+
+    Trims off any suffix starting with a comma and replaces any leading string of
+    'unix:abstract=' with a zero byte.
+    """
+    addr = abstract_address.split(',')[0]
+    if addr.startswith('unix:abstract='):
+        return "\0" + ' '.join(addr.split('=')[1:])
+    elif addr.startswith('unix:path='):
+        return ' '.join(addr.split('=')[1:])
+
+    return addr
+
+
+class BridgePair(object):
+    """A pair of sockets that make up a bridge between host and session."""
+
+    def __init__(self, session_socket, host_address):
+        """Create a pair of sockets bridging host and session.
+
+        A socket bridge pair takes an (already-opened) session socket and the
+        address of the host socket and opens a connection to that.
+        """
+        self.session_socket = session_socket
+        self.session_socket.setblocking(False)
+
+        self.host_socket = socket(AF_UNIX, SOCK_STREAM)
+        self.host_socket.connect(translate_to_real_address(host_address))
+        self.host_socket.setblocking(False)
+
+    def handle_read_fd(self, fd, session):
+        """Handle read-available events on one of the sockets.
+
+        :param fd: A file descriptor on which a read is available.
+        :type fd: int -- valid file descriptor.
+        :param session: A libertine application session object.
+        :type session: libertine.launcher.Session
+
+        Callback to handle a read-available event on one of the bridge pair
+        socket fds.
+        """
+        if fd == self.session_socket.fileno():
+            if self._copy_data(self.session_socket, self.host_socket) == 0:
+                self._close_up_shop(session)
+        elif fd == self.host_socket.fileno():
+            if self._copy_data(self.host_socket, self.session_socket) == 0:
+                self._close_up_shop(session)
+
+    def _copy_data(self, from_socket, to_socket):
+        """Copy data between the sockets.
+
+        :param from_socket: A socket to be read from.
+        :type from_socket: socket-object
+        :param to_socket: A socket to be written to.
+        :type to_socket: socket-object
+
+        Note that this chunks the data 4 kilobytes at a time (which maybe should
+        be a tuneable parameter).
+        Also, it's a non-blocking write and that may affect things.  Honestly, it
+        should be a non-blocking write and logic should be added to track
+        write-available events and unsent bytes and all that stuff but not today.
+        """
+        try:
+            b = from_socket.recv(4096)
+            if len(b) > 0:
+                to_socket.sendall(b)
+                log.debug('copied {} bytes from fd to {}'.format(len(b), from_socket, to_socket))
+            else:
+                log.info('close detected on {}'.format(from_socket))
+            return len(b)
+        except Exception as e:
+            log.debug(e)
+            return 0
+
+    def _close_up_shop(self, session):
+        """Clean up.
+
+        :param session: A libertine application session object.
+        :type session: libertine.launcher.Session
+
+        Closes both sockets in the pair and calls back the session to remove
+        this object from its watch list.
+        """
+        session.remove_bridge_pair(self)
+        self.session_socket.shutdown(SHUT_RDWR)
+        self.session_socket.close()
+
+        self.host_socket.shutdown(SHUT_RDWR)
+        self.host_socket.close()
+
+
+class Session(ExitStack):
+    """Encapsulation of a running application under a Libertine aegis.
+
+    A session includes the following.
+
+    * A cleansed and remapped set of environment variables.
+    * A collection of redirected sockets.
+    * Zero or more running auxiliary programs.
+    * An executable command line.
+
+    A session must be associated with a single aegis (a container, a snap, or
+    the host itself, depending).  The associated aegis is termed the *container*
+    for historical reasons.
+
+    Each application run under a Libertine aegis must have its own session.
+
+    A session is constructed in a 'stopped' state.  It needs to be started and
+    the main loop entered, and once the main loop exits it gets torn down and
+    returned to a stopped state.
+    """
+
+    def __init__(self, config, container):
+        """Construct a libertine application session for a container.
+
+        :param config:    A session configuration object.
+        :param container: The container in which the application will be run.
+        """
+        super().__init__()
+        self._app = None
+        self._config = config
+        self._container = container
+        self._bridge_pairs = []
+        self._child_processes = []
+        self._selector = selectors.DefaultSelector()
+        self._set_signal_handlers()
+        self.callback(self._shutdown)
+
+        self._ensure_paths_exist()
+
+        with suppress(AttributeError):
+            for bridge_config in self._config.socket_bridges:
+                self._create_bridge_listener(bridge_config)
+
+        with suppress(AttributeError):
+            for task_config in self._config.prelaunch_tasks:
+                if task_config.task_type == TaskType.LAUNCH_SERVICE:
+                    log.info("launching {}".format(task_config.datum[0]))
+                    task = LaunchServiceTask(task_config)
+                    self._child_processes.append(task)
+                    task.start(self._config.host_environ)
+
+    @property
+    def id(self):
+        """A unique string identifying this session."""
+        return self._config.id
+
+    def _add_read_fd_handler(self, fd, handler, datum):
+        """Add a handler to be called when a read event is received on fd.
+
+        :param fd: A file descriptor to watch for read events.
+        :type fd: int -- valid file descriptor.
+        :param handler: A function to be called when a read on fd becomes available.
+        :param datum: Data to be passed to handler when called.
+        """
+        self._selector.register(fd, selectors.EVENT_READ, (handler, datum))
+
+    def _remove_read_fd_handler(self, fd):
+        """Remove a handler used for reading events on an fd.
+
+        :param fd: A file descriptor to be removed from watching read events.
+        """
+        self._selector.unregister(fd)
+
+    def add_bridge_pair(self, bridge_pair):
+        """Add a bridge pair to the list of those being monitored.
+
+        :param bridge_pair: an active BridgePair object to add to the watch list.
+        """
+        self._add_read_fd_handler(bridge_pair.session_socket.fileno(),
+                                  bridge_pair.handle_read_fd,
+                                  self)
+        self._add_read_fd_handler(bridge_pair.host_socket.fileno(),
+                                  bridge_pair.handle_read_fd,
+                                  self)
+        self._bridge_pairs.append(bridge_pair)
+
+    def remove_bridge_pair(self, bridge_pair):
+        """Remove a bridge pair from the list of those being monitored.
+
+        :param bridge_pair: an active BridgePair object to remove from the watch list.
+        """
+        self._remove_read_fd_handler(bridge_pair.session_socket.fileno())
+        self._remove_read_fd_handler(bridge_pair.host_socket.fileno())
+        self._bridge_pairs.remove(bridge_pair)
+
+    def run(self):
+        """Run the main event loop of the Session.
+
+        The main loop monitors the various socket bridges and the contained
+        child process(es) and dispatches events appropriately.
+
+        The event loop is generally terminated by the receipt of a StopIteration
+        exception.
+        """
+        with suppress(StopIteration):
+            while True:
+                events = self._selector.select()
+                for key, mask in events:
+                    handler, datum = key.data
+                    handler(key.fd, datum)
+        self._container.finish_application(self._app)
+        self._stop_services()
+
+    def start_application(self):
+        """Connect to the container and start the application running."""
+        self._container.connect()
+        self.callback(self._container.disconnect)
+        self._add_running_app()
+        self._app = self._container.start_application(self._config.exec_line,
+                                                      self._config.session_environ)
+
+    def _add_running_app(self):
+        """Add a running app entry to ContainersConfig.json."""
+        if self._config.container_id:
+            ContainersConfig().add_running_app(self._config.container_id, self._config.exec_line[0])
+
+    def _remove_running_app(self):
+        """Remove a running app entry from ContainersConfig.json."""
+        if self._config.container_id:
+            ContainersConfig().delete_running_app(self._config.container_id, self._config.exec_line[0])
+
+    def _create_bridge_listener(self, bridge_config):
+        """Create a socket bridge listener for a socket bridge configuration.
+
+        :param bridge_config: A socket bridge configuration object.
+        :type bridge_config: libertine.launcher.config.SocketBridge
+
+        The purpose of the listener is to listen on the session socket and
+        create a socket bridge to the host when a connection from the session is
+        made.
+        """
+        log.debug('creating bridge listener for {} on {}'.
+                  format(bridge_config.env_var, bridge_config.session_address))
+        sock = socket(AF_UNIX, SOCK_STREAM)
+        sock.bind(translate_to_real_address(bridge_config.session_address))
+        sock.listen(5)
+        self._add_read_fd_handler(sock.fileno(),
+                                  self._accept_bridge_connection,
+                                  (bridge_config, sock))
+
+    def _accept_bridge_connection(self, fd, datum):
+        """Handle a connection on a session socket.
+
+        :param fd: A file descriptor with an active connect operation in
+                   progress.
+        :type fd: int -- valid file descriptor.
+        :param datum: Data passed to handler.
+        """
+        (bridge_config, sock) = datum
+        conn = sock.accept()
+        log.debug('connection of session socket {} accepted'.format(bridge_config.session_address))
+        self.add_bridge_pair(BridgePair(conn[0], bridge_config.host_address))
+
+    def _ensure_paths_exist(self):
+        """Ensure the required paths all exist for supporting the session."""
+        directory = utils.get_libertine_runtime_dir()
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+
+    def _handle_child_died(self):
+        """Take action when a SIGCHILD has been raised."""
+        for child in self._child_processes:
+            if child.wait():
+                return True
+
+        if self._app == None or self._app.status() == STATUS_ZOMBIE:
+            return True
+
+        return False
+
+    def _handle_sig_fd(self, fd, dummy):
+        """Handle read events for captured signals.
+
+        :param fd: A file descriptor on which signal information will be sent.
+        :type fd: int -- valid file descriptor.
+        :param dummy: A dummy parameter.  Required for magic.
+        """
+        data = os.read(fd, 4)
+        sig = struct.unpack('%uB' % len(data), data)
+        if sig[0] == signal.SIGCHLD:
+            log.info('SIGCHLD received')
+            if self._handle_child_died():
+                raise StopIteration('launched program exited')
+        elif sig[0] == signal.SIGINT:
+            log.info('SIGINT received')
+            raise StopIteration('keyboard interrupt')
+        elif sig[0] == signal.SIGTERM:
+            log.info('SIGTERM received')
+            raise StopIteration('terminate')
+        else:
+            log.warning('unknown signal {} received'.format(sig[0]))
+
+    def _set_signal_handlers(self):
+        """Set the signal handlers."""
+        def noopSignalHandler(*args):
+            pass
+        self._sigchld_handler = signal.signal(signal.SIGCHLD, noopSignalHandler)
+        self._sigint_handler  = signal.signal(signal.SIGINT,  noopSignalHandler)
+        self._sigterm_handler = signal.signal(signal.SIGTERM, noopSignalHandler)
+
+        sig_r_fd, sig_w_fd = os.pipe2(os.O_NONBLOCK | os.O_CLOEXEC)
+        signal.set_wakeup_fd(sig_w_fd)
+        self._add_read_fd_handler(sig_r_fd, self._handle_sig_fd, None)
+
+    def _shutdown(self):
+        """Restore the previous state to the world when the Session is torn down."""
+        signal.signal(signal.SIGCHLD, self._sigchld_handler)
+        signal.signal(signal.SIGINT,  self._sigint_handler)
+        signal.signal(signal.SIGTERM, self._sigterm_handler)
+
+        if self._config.container_id:
+            self._remove_running_app()
+
+        for bridge_pair in self._config.socket_bridges:
+            os.remove(translate_to_real_address(bridge_pair.session_address))
+
+    def _stop_services(self):
+        """Ask any started services to stop."""
+        for service in self._child_processes:
+            service.stop()

=== added file 'python/libertine/launcher/task.py'
--- python/libertine/launcher/task.py	1970-01-01 00:00:00 +0000
+++ python/libertine/launcher/task.py	2016-11-21 19:42:42 +0000
@@ -0,0 +1,75 @@
+# Copyright 2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Pre- and post-launch tasks surrounding the Libertine launch of an application."""
+
+
+from os import waitpid, WNOHANG
+from subprocess import Popen
+
+
+class TaskType:
+    """Namespace used for task type enumeration."""
+
+    LAUNCH_SERVICE = 1
+
+
+class TaskConfig(object):
+    """Encapsulation of the configuration of a single launch task."""
+
+    def __init__(self, task_type, datum):
+        """
+        :param task_type: The type of launch task.
+        :tyoe task_type: a TaskType value
+        :param datum: The data associated with the launch task.
+        :type datum: anything -- usually a collection of data
+        """
+        self.task_type = task_type
+        self.datum = datum
+
+
+class LaunchServiceTask(object):
+    """A task that launches a service."""
+
+    def __init__(self, config):
+        """
+        :param config: The task configuraiton.
+        :type config: TaskConfig
+
+        The constructor unpacks the service commandline from the config datum.
+        """
+        self._command_line = config.datum
+        self._process = None
+
+    def start(self, environ=None):
+        """Start the service.
+        
+        :param env: An alternate environment dictionary.
+        """
+        self._process = Popen(self._command_line, env=environ)
+
+    def stop(self):
+        """Shuts the service down.  """
+        try:
+            self._process.terminate()
+        except ProcessLookupError:
+            pass
+
+    def wait(self):
+        """Wait for service shutdown to complete.
+        :return: True if the service process was successfully waited for, False
+                 otherwise (which implies the service is still running).
+        """
+        (pid, status) = waitpid(self._process.pid, WNOHANG)
+        return pid == self._process.pid

=== modified file 'python/libertine/utils.py'
--- python/libertine/utils.py	2016-09-06 12:36:47 +0000
+++ python/libertine/utils.py	2016-11-21 19:42:42 +0000
@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2015-2016 Canonical Ltd.
@@ -31,24 +30,19 @@
 
     # If someone else sets a handler before this, we wont run this!
     if not logger.hasHandlers():
-        logger.setLevel(logging.DEBUG)
-        logger.disabled = True
-
         stream_handler = logging.StreamHandler()
-        stream_handler.setLevel(logging.DEBUG)
-
         formatter = logging.Formatter('%(filename)s:'
                                       '%(lineno)d: '
                                       '%(levelname)s: '
                                       '%(funcName)s():\t'
                                       '%(message)s')
-
         stream_handler.setFormatter(formatter)
         logger.addHandler(stream_handler)
 
-    # Only enable the logger if we set this
-    if os.getenv('LIBERTINE_DEBUG') is '1':
-        logger.disabled = False
+    if 'LIBERTINE_DEBUG' in os.environ:
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.WARNING)
 
     return logger
 
@@ -173,3 +167,20 @@
                  (scopes_object_path, invalidate_signal, libertine_scope_id))
 
     subprocess.Popen(shlex.split(gdbus_cmd), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def set_session_dbus_env_var():
+    if not 'DBUS_SESSION_BUS_ADDRESS' in os.environ:
+        dbus_session_path = os.path.join('/', 'run', 'user', str(os.getuid()), 'dbus-session')
+
+        if os.path.exists(dbus_session_path):
+            with open(dbus_session_path, 'r') as fd:
+                dbus_session_str = fd.read()
+
+                os.environ['DBUS_SESSION_BUS_ADDRESS'] = dbus_session_str.partition('DBUS_SESSION_BUS_ADDRESS=')[2].rstrip('\n')
+
+                return True
+        else:
+            return False
+
+    return True

=== added directory 'qml'
=== added file 'qml/CMakeLists.txt'
--- qml/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ qml/CMakeLists.txt	2016-11-21 19:42:42 +0000
@@ -0,0 +1,3 @@
+install(DIRECTORY common DESTINATION ${LIBERTINE_QML_PATH})
+install(DIRECTORY gui DESTINATION ${LIBERTINE_QML_PATH})
+install(DIRECTORY plugin DESTINATION ${LIBERTINE_QML_PATH})

=== added directory 'qml/common'
=== renamed file 'libertine/qml/AddExtraArchiveView.qml' => 'qml/common/AddExtraArchiveView.qml'
--- libertine/qml/AddExtraArchiveView.qml	2016-07-13 19:48:48 +0000
+++ qml/common/AddExtraArchiveView.qml	2016-11-21 19:42:42 +0000
@@ -28,6 +28,8 @@
     }
     property string currentContainer: ""
 
+    signal error(string short_description, string details)
+
     Column {
         spacing: units.gu(2)
 
@@ -96,9 +98,9 @@
     }
 
     function addArchive() {
-        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
         worker.finishedConfigure.connect(finishedConfigure)
-        worker.error.connect(mainView.error)
+        worker.error.connect(addExtraArchiveView.error)
         worker.addArchive(currentContainer, containerConfigList.getContainerName(currentContainer),
                           extraArchiveString.text, publicSigningKey.text.trim())
 

=== renamed file 'libertine/qml/HomeView.qml' => 'qml/common/ContainerEditView.qml'
--- libertine/qml/HomeView.qml	2016-07-06 14:17:46 +0000
+++ qml/common/ContainerEditView.qml	2016-11-21 19:42:42 +0000
@@ -26,7 +26,7 @@
     id: homeView
     header: PageHeader {
         id: pageHeader
-        title: i18n.tr("Classic Apps - %1").arg(containerConfigList.getContainerName(currentContainer))
+        title: i18n.tr("%1 - All Apps").arg(containerConfigList.getContainerName(currentContainer))
         trailingActionBar.actions: [
             Action {
                 id: settingsButton
@@ -153,7 +153,7 @@
                 width: parent.width
                 onClicked: {
                     PopupUtils.close(addAppsDialog)
-                    PopupUtils.open(Qt.resolvedUrl("SearchPackagesDialog.qml"))
+                    PopupUtils.open(Qt.resolvedUrl("SearchPackagesDialog.qml"), {currentContainer: currentContainer})
                 }
             }
         }
@@ -249,12 +249,11 @@
     }
 
     function operationSetup() {
-        var comp = Qt.createComponent("ContainerManager.qml")
-        var worker = comp.createObject(mainView)
-        worker.error.connect(mainView.error)
-        worker.updateOperationDetails.connect(mainView.updateOperationDetails)
-        mainView.packageOperationInteraction.connect(worker.packageOperationInteraction)
-        worker.operationFinished.connect(mainView.resetOperationDetails)
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
+        worker.error.connect(packageOperationDetails.error)
+        worker.updateOperationDetails.connect(packageOperationDetails.update)
+        packageOperationDetails.send.connect(worker.packageOperationInteraction)
+        worker.operationFinished.connect(packageOperationDetails.clear)
         return worker
     }
 

=== renamed file 'libertine/qml/ContainerInfoView.qml' => 'qml/common/ContainerInfoView.qml'
--- libertine/qml/ContainerInfoView.qml	2016-06-09 18:20:19 +0000
+++ qml/common/ContainerInfoView.qml	2016-11-21 19:42:42 +0000
@@ -27,7 +27,7 @@
     id: containerInfoView
     header: PageHeader {
         id: pageHeader
-        title: i18n.tr("Container information for %1").arg(containerConfigList.getContainerName(currentContainer))
+        title: i18n.tr("Container Info: %1").arg(containerConfigList.getContainerName(currentContainer))
     }
 
     property string currentContainer: null
@@ -114,19 +114,17 @@
     Component.onCompleted: {
         containerConfigList.configChanged.connect(reloadStatus)
 
-        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
+        operationDetails = packageOperationDetails.details(currentContainer, "")
+        packageOperationDetails.updated.connect(updateDetails)
 
-        operationDetails = mainView.getOperationDetails(currentContainer)
         operationDetailsView.cursorPosition = operationDetailsView.length
-        if (operationDetails != "") {
+        if (operationDetails !== "") {
             showDetails = !showDetails
         }
-
-        mainView.operationDetailsUpdated.connect(updateDetails)
     }
 
     Component.onDestruction: {
-        mainView.operationDetailsUpdated.disconnect(updateDetails)
         containerConfigList.configChanged.disconnect(reloadStatus)
     }
 

=== renamed file 'libertine/qml/ContainerManager.qml' => 'qml/common/ContainerManager.qml'
=== renamed file 'libertine/qml/ContainerOptionsDialog.qml' => 'qml/common/ContainerOptionsDialog.qml'
--- libertine/qml/ContainerOptionsDialog.qml	2016-09-02 18:26:25 +0000
+++ qml/common/ContainerOptionsDialog.qml	2016-11-21 19:42:42 +0000
@@ -30,7 +30,7 @@
     signal onCreateInitialized()
 
     Row {
-        visible: containerConfigList.getHostArchitecture() == 'x86_64' ? true : false
+        visible: containerConfigList.getHostArchitecture() === 'x86_64' ? true : false
         spacing: units.gu(1)
         CheckBox {
             id: enableMultiarchCheckbox
@@ -97,11 +97,11 @@
 
     function createContainer() {
         var container_id = containerConfigList.addNewContainer("lxc", containerNameInput.text)
-        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
 
-        worker.updateOperationDetails.connect(mainView.updateOperationDetails)
-        worker.operationFinished.connect(mainView.resetOperationDetails)
-        worker.error.connect(mainView.error)
+        worker.updateOperationDetails.connect(packageOperationDetails.update)
+        worker.operationFinished.connect(packageOperationDetails.clear)
+        worker.error.connect(packageOperationDetails.error)
 
         worker.createContainer(container_id,
                                containerConfigList.getContainerName(container_id),

=== added file 'qml/common/ContainersList.qml'
--- qml/common/ContainersList.qml	1970-01-01 00:00:00 +0000
+++ qml/common/ContainersList.qml	2016-11-21 19:42:42 +0000
@@ -0,0 +1,131 @@
+/**
+ * @file ContainersListView.qml
+ * @brief Libertine containers view
+ */
+/*
+ * Copyright 2016 Canonical Ltd
+ *
+ * Libertine 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.
+ *
+ * Libertine is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import Libertine 1.0
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+import Ubuntu.Components.Popups 1.3
+
+
+/**
+ * Component providing a list of available containers and their (possibly animated)
+ * states.
+ */
+Item {
+    property string currentContainer
+
+    UbuntuListView {
+        id: containersList
+        anchors {
+            fill: parent
+        }
+        model: containerConfigList
+
+        function edit(id, status) {
+            if (status === "removing") {
+                packageOperationDetails.error(i18n.tr("Container Unavailable"), i18n.tr("Container is being destroyed and is no longer editable."))
+                return
+            }
+            currentContainer = id
+            containerAppsList.setContainerApps(currentContainer)
+            pageStack.push(Qt.resolvedUrl("../common/ContainerEditView.qml"), {currentContainer: currentContainer})
+        }
+
+        delegate: ListItem {
+            Label {
+                text: name
+                anchors {
+                    verticalCenter: parent.verticalCenter
+                    left: parent.left
+                    leftMargin: units.gu(2)
+                }
+            }
+            ActivityIndicator {
+                id: containerActivity
+                anchors {
+                    verticalCenter: parent.verticalCenter
+                    right: parent.right
+                    rightMargin: units.gu(2)
+                }
+                visible: installStatus === i18n.tr("installing") ||
+                          installStatus === i18n.tr("removing")
+                running: containerActivity.visible
+            }
+
+            onClicked: { containersList.edit(containerId, installStatus) }
+
+            leadingActions: ListItemActions {
+                actions: [
+                    Action {
+                        iconName: "delete"
+                        text: i18n.tr("delete")
+                        description: i18n.tr("Delete Container")
+                        onTriggered: {
+                            var worker = Qt.createComponent("../common/ContainerManager.qml").createObject(parent)
+                            worker.error.connect(packageOperationDetails.error)
+                            worker.destroyContainer(containerId)
+                        }
+                    }
+                ]
+            }
+
+            trailingActions: ListItemActions {
+                actions: [
+                    Action {
+                        iconName: "info"
+                        text: i18n.tr("info")
+                        description: i18n.tr("Container Info")
+                        onTriggered: {
+                            currentContainer = containerId
+                            pageStack.push(Qt.resolvedUrl("../common/ContainerInfoView.qml"), {currentContainer: containerId})
+                        }
+                    },
+                    Action {
+                        iconName: "edit"
+                        text: i18n.tr("edit")
+                        description: i18n.tr("Container Apps")
+                        visible: installStatus === i18n.tr("ready") ||
+                                  installStatus === i18n.tr("updating")
+                        onTriggered: {
+                            containersList.edit(containerId, installStatus)
+                        }
+                    }
+                ]
+            }
+        }
+    }
+
+    Component.onCompleted: {
+        containerConfigList.configChanged.connect(updateContainerList)
+    }
+
+    Component.onDestruction: {
+        containerConfigList.configChanged.disconnect(updateContainerList)
+    }
+
+    function updateContainerList() {
+        containerConfigList.reloadContainerList()
+
+        if (currentContainer && !containerConfigList.getContainerStatus(currentContainer) && pageStack.currentPage !== containersView) {
+            pageStack.pop()
+            currentContainer = ""
+            packageOperationDetails.error(i18n.tr("Container Unavailable"),
+                                          i18n.tr("This container has been destroyed and is no longer valid. You have been returned to the containers overview."))
+        }
+    }
+}

=== renamed file 'libertine/qml/DebianPackagePicker.qml' => 'qml/common/DebianPackagePicker.qml'
=== renamed file 'libertine/qml/ExtraArchivesView.qml' => 'qml/common/ExtraArchivesView.qml'
--- libertine/qml/ExtraArchivesView.qml	2016-09-29 15:40:02 +0000
+++ qml/common/ExtraArchivesView.qml	2016-11-21 19:42:42 +0000
@@ -96,7 +96,7 @@
     function deleteArchive(archive) {
         var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
         worker.finishedConfigure.connect(finishedConfigure)
-        worker.error.connect(mainView.error)
+        worker.error.connect(packageOperationDetails.error)
         worker.configureContainer(currentContainer, containerConfigList.getContainerName(currentContainer), ["--archive", "remove", "--archive-name", "\"" + archive + "\""])
     }
 

=== renamed file 'libertine/qml/GenericErrorDialog.qml' => 'qml/common/GenericErrorDialog.qml'
=== renamed file 'libertine/qml/ManageContainer.qml' => 'qml/common/ManageContainer.qml'
--- libertine/qml/ManageContainer.qml	2016-07-11 14:35:11 +0000
+++ qml/common/ManageContainer.qml	2016-11-21 19:42:42 +0000
@@ -46,14 +46,14 @@
             anchors.right: parent.right
 
             ListItem.Standard {
-                visible: containerConfigList.getHostArchitecture() == 'x86_64' ? true : false
+                visible: containerConfigList.getHostArchitecture() === 'x86_64' ? true : false
                 control: CheckBox {
                     checked: isMultiarchEnabled
                     onClicked: {
-                        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
+                        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
 
-                        worker.updateOperationDetails.connect(mainView.updateOperationDetails)
-                        worker.operationFinished.connect(mainView.resetOperationDetails)
+                        worker.updateOperationDetails.connect(packageOperationDetails.update)
+                        worker.operationFinished.connect(packageOperationDetails.clear)
 
                         if (checked) {
                             worker.configureContainer(currentContainer,
@@ -105,12 +105,14 @@
                 control: CheckBox {
                     checked: isDefaultContainer
                     onClicked: {
-                        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
-                        worker.error.connect(mainView.error)
+                        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
+                        worker.error.connect(packageOperationDetails.error)
+
                         var fallback = checked
                         worker.error.connect(function() {
                             checked = fallback
                         })
+
                         worker.setDefaultContainer(currentContainer, !checked)
                     }
                 }
@@ -129,11 +131,11 @@
     }
 
     function updateContainer() {
-        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
-        worker.error.connect(mainView.error);
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
+        worker.error.connect(packageOperationDetails.error);
 
-        worker.updateOperationDetails.connect(mainView.updateOperationDetails)
-        worker.operationFinished.connect(mainView.resetOperationDetails)
+        worker.updateOperationDetails.connect(packageOperationDetails.update)
+        worker.operationFinished.connect(packageOperationDetails.clear)
 
         worker.updateContainer(currentContainer, containerConfigList.getContainerName(currentContainer))
     }

=== renamed file 'libertine/qml/PackageExistsDialog.qml' => 'qml/common/PackageExistsDialog.qml'
=== renamed file 'libertine/qml/PackageInfoView.qml' => 'qml/common/PackageInfoView.qml'
--- libertine/qml/PackageInfoView.qml	2016-06-10 13:22:16 +0000
+++ qml/common/PackageInfoView.qml	2016-11-21 19:42:42 +0000
@@ -27,19 +27,18 @@
     id: packageInfoView
     header: PageHeader {
         id: pageHeader
-        title: i18n.tr("Information for the %1 package").arg(currentPackage)
+        title: i18n.tr("%1 - %2").arg(currentContainer).arg(currentPackage)
     }
     property string currentContainer: null
     property var currentPackage: null
     property var statusText: containerConfigList.getAppStatus(currentContainer, currentPackage)
     property var packageVersionText: i18n.tr("Obtaining package version…")
-    property string packageOperationDetails: ""
+    property string currentDetails: ""
     property var worker: null
     property bool showDetails: false
 
     signal sendOperationInteraction(string text)
 
-
     Flickable {
         anchors {
             topMargin: pageHeader.height
@@ -77,7 +76,7 @@
                     text: enabled ?
                               showDetails ? i18n.tr('Hide') : i18n.tr('Show')
                             : i18n.tr('None')
-                    enabled: packageOperationDetails != ""
+                    enabled: currentDetails != ""
                     onClicked: {
                         showDetails = !showDetails
                     }
@@ -92,7 +91,7 @@
                 anchors.right: parent.right
                 height: Math.max(packageInfoView.height - pageHeader.height - packageListItem.height - showDetailsView.height - statusListItem.height - 35, units.gu(35))
                 readOnly: true
-                text: packageOperationDetails
+                text: currentDetails
             }
 
             TextField {
@@ -112,31 +111,32 @@
     Component.onCompleted: {
         containerConfigList.configChanged.connect(reloadStatus)
         var command = "apt-cache policy " + currentPackage
-        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
         worker.finishedCommand.connect(getPackageVersion)
 
-        packageOperationDetails = mainView.getOperationDetails(currentContainer, currentPackage)
+        currentDetails = packageOperationDetails.details(currentContainer, currentPackage)
         packageDetailsView.cursorPosition = packageDetailsView.length
-        if (packageOperationDetails != "") {
+        if (currentDetails != "") {
             showDetails = !showDetails
         }
 
-        mainView.operationDetailsUpdated.connect(updatePackageDetails)
-        sendOperationInteraction.connect(mainView.packageOperationInteraction)
+        packageOperationDetails.updated.connect(updatePackageDetails)
+        sendOperationInteraction.connect(packageOperationDetails.send)
 
         worker.error.connect(onError)
+        worker.error.connect(packageOperationDetails.error)
         worker.runCommand(currentContainer, containerConfigList.getContainerName(currentContainer), command)
     }
 
     Component.onDestruction: {
         containerConfigList.configChanged.disconnect(reloadStatus)
-        mainView.operationDetailsUpdated.disconnect(updatePackageDetails)
-        sendOperationInteraction.disconnect(mainView.packageOperationInteraction)
+        packageOperationDetails.updated.disconnect(updatePackageDetails)
+        sendOperationInteraction.disconnect(packageOperationDetails.send)
     }
 
     function updatePackageDetails(container_id, package_name, details) {
         if (container_id === currentContainer && package_name === currentPackage) {
-            packageOperationDetails += details
+            currentDetails += details
             packageDetailsView.cursorPosition = packageDetailsView.length
         }
     }

=== renamed file 'libertine/qml/SearchPackagesDialog.qml' => 'qml/common/SearchPackagesDialog.qml'
--- libertine/qml/SearchPackagesDialog.qml	2016-05-06 21:13:01 +0000
+++ qml/common/SearchPackagesDialog.qml	2016-11-21 19:42:42 +0000
@@ -25,6 +25,7 @@
     id: searchPackageDialog
     title: i18n.tr("Search for packages")
     text: i18n.tr("Search archives for packages")
+    property string currentContainer: null
 
     TextField {
         id: searchPackageInput
@@ -42,11 +43,11 @@
             onClicked: {
                 if (searchPackageInput.text != "") {
                     PopupUtils.close(searchPackageDialog)
-                    if (pageStack.currentPage.objectName == "searchResultsView") {
+                    if (pageStack.currentPage.objectName === "searchResultsView") {
                         pageStack.currentPage.searchForPackages(searchPackageInput.text)
                     }
                     else {
-                        pageStack.push(Qt.resolvedUrl("SearchResultsView.qml"), {search_string : searchPackageInput.text})
+                        pageStack.push(Qt.resolvedUrl("SearchResultsView.qml"), {search_string : searchPackageInput.text, currentContainer: currentContainer})
                     }
                 }
             }

=== renamed file 'libertine/qml/SearchResults.qml' => 'qml/common/SearchResults.qml'
--- libertine/qml/SearchResults.qml	2016-05-10 19:26:22 +0000
+++ qml/common/SearchResults.qml	2016-11-21 19:42:42 +0000
@@ -28,8 +28,10 @@
         fill: parent
     }
 
+    property var currentContainer: null
+
     function install(packageName) {
-        if (!containerConfigList.isAppInstalled(mainView.currentContainer, packageName)) {
+        if (!containerConfigList.isAppInstalled(currentContainer, packageName)) {
             pageStack.pop()
             pageStack.currentPage.installPackage(packageName)
         }

=== renamed file 'libertine/qml/SearchResultsView.qml' => 'qml/common/SearchResultsView.qml'
--- libertine/qml/SearchResultsView.qml	2016-05-19 17:56:43 +0000
+++ qml/common/SearchResultsView.qml	2016-11-21 19:42:42 +0000
@@ -43,6 +43,8 @@
     property var search_string: null
     property var search_comp: null
     property var search_obj: null
+    property var currentContainer: null
+
     signal doSearch
 
     Component {
@@ -50,7 +52,7 @@
         Dialog {
             id: noResultsDialog
             title: i18n.tr("No Search Results Found")
-            property var returnHome: false
+            property bool returnHome: false
 
             Button {
                 id: searchAgain
@@ -58,7 +60,7 @@
                 color: UbuntuColors.green
                 onClicked: {
                     PopupUtils.close(noResultsDialog)
-                    PopupUtils.open(Qt.resolvedUrl("SearchPackagesDialog.qml"))
+                    PopupUtils.open(Qt.resolvedUrl("SearchPackagesDialog.qml"), {currentContainer: currentContainer})
                 }
             }
 
@@ -118,11 +120,11 @@
         }
         packageListModel.clear()
 
-        var comp = Qt.createComponent("ContainerManager.qml")
-        var worker = comp.createObject()
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(parent)
         worker.finishedSearch.connect(finishedSearch)
-        worker.error.connect(mainView.error)
-        worker.searchPackageCache(mainView.currentContainer, search_string)
+        worker.error.connect(packageOperationDetails.error)
+
+        worker.searchPackageCache(currentContainer, search_string)
     }
 
     function finishedSearch(packageList) {
@@ -133,14 +135,14 @@
                 packageListModel.append({"package_desc": packageList[i], "package_name": packageList[i].split(' ')[0]})
             }
             if (!search_comp) {
-                search_comp = Qt.createComponent("SearchResults.qml")
+                search_comp = Qt.createComponent("SearchResults.qml", {currentContainer: currentContainer})
             }
-            search_obj = search_comp.createObject(searchResultsView, {"model": packageListModel})
+            search_obj = search_comp.createObject(parent, {"model": packageListModel})
         }
         else {
             PopupUtils.open(noResultsPopup)
         }
     }
 
-    onDoSearch: PopupUtils.open(Qt.resolvedUrl("SearchPackagesDialog.qml"))
+    onDoSearch: PopupUtils.open(Qt.resolvedUrl("SearchPackagesDialog.qml"), {currentContainer: currentContainer})
 }

=== added directory 'qml/gui'
=== renamed file 'libertine/qml/ContainersView.qml' => 'qml/gui/ContainersView.qml'
--- libertine/qml/ContainersView.qml	2016-08-22 18:20:43 +0000
+++ qml/gui/ContainersView.qml	2016-11-21 19:42:42 +0000
@@ -20,6 +20,7 @@
 import QtQuick 2.4
 import Ubuntu.Components 1.3
 import Ubuntu.Components.Popups 1.3
+import "../common"
 
 
 /**
@@ -35,115 +36,19 @@
             Action {
                 iconName: "add"
                 onTriggered: {
-                    PopupUtils.open(Qt.resolvedUrl("ContainerOptionsDialog.qml"))
+                    PopupUtils.open(Qt.resolvedUrl("../common/ContainerOptionsDialog.qml"))
                 }
             }
         ]
-        leadingActionBar.actions: [
-            Action {
-                iconName: "back"
-                visible: false
-            }
-        ]
     }
+    property string currentContainer
 
-    UbuntuListView {
-        id: containersList
+    ContainersList {
         anchors {
             topMargin: pageHeader.height
-            fill: parent
-        }
-        model: containerConfigList
-
-        function edit(id, status) {
-            if (status === "removing") {
-                mainView.error(i18n.tr("Container Unavailable"), i18n.tr("Container is being destroyed and is no longer editable."))
-                return
-            }
-            mainView.currentContainer = id
-            containerAppsList.setContainerApps(mainView.currentContainer)
-            pageStack.push(Qt.resolvedUrl("HomeView.qml"), {"currentContainer": mainView.currentContainer})
-        }
-
-        delegate: ListItem {
-            Label {
-                text: name
-                anchors {
-                    verticalCenter: parent.verticalCenter
-                    left: parent.left
-                    leftMargin: units.gu(2)
-                }
-            }
-            ActivityIndicator {
-                id: containerActivity
-                anchors {
-                    verticalCenter: parent.verticalCenter
-                    right: parent.right
-                    rightMargin: units.gu(2)
-                }
-                visible: (installStatus === i18n.tr("installing") ||
-                          installStatus === i18n.tr("removing")) ? true : false
-                running: containerActivity.visible
-            }
-
-            onClicked: { containersList.edit(containerId, installStatus) }
-
-            leadingActions: ListItemActions {
-                actions: [
-                    Action {
-                        iconName: "delete"
-                        text: i18n.tr("delete")
-                        description: i18n.tr("Delete Container")
-                        onTriggered: {
-                            var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
-                            worker.error.connect(mainView.error)
-                            worker.destroyContainer(containerId)
-                        }
-                    }
-                ]
-            }
-
-            trailingActions: ListItemActions {
-                actions: [
-                    Action {
-                        iconName: "info"
-                        text: i18n.tr("info")
-                        description: i18n.tr("Container Info")
-                        onTriggered: {
-                            mainView.currentContainer = containerId
-                            pageStack.push(Qt.resolvedUrl("ContainerInfoView.qml"), {currentContainer: containerId})
-                        }
-                    },
-                    Action {
-                        iconName: "edit"
-                        text: i18n.tr("edit")
-                        description: i18n.tr("Container Apps")
-                        visible: (installStatus === i18n.tr("ready") ||
-                                  installStatus === i18n.tr("updating")) ? true : false
-                        onTriggered: {
-                            containersList.edit(containerId, installStatus)
-                        }
-                    }
-                ]
-            }
-        }
-    }
-
-    Component.onCompleted: {
-        containerConfigList.configChanged.connect(updateContainerList)
-    }
-
-    Component.onDestruction: {
-        containerConfigList.configChanged.disconnect(updateContainerList)
-    }
-
-    function updateContainerList() {
-        containerConfigList.reloadContainerList()
-
-        if (mainView.currentContainer && !containerConfigList.getContainerStatus(mainView.currentContainer) && pageStack.currentPage !== containersView) {
-            pageStack.pop()
-            mainView.currentContainer = ""
-            mainView.error(i18n.tr("Container Unavailable"), i18n.tr("This container has been destroyed and is no longer valid. You have been returned to the containers overview."))
-        }
+            fill: containersView
+        }
+
+        currentContainer: containersView.currentContainer
     }
 }

=== renamed file 'libertine/qml/WelcomeView.qml' => 'qml/gui/WelcomeView.qml'
--- libertine/qml/WelcomeView.qml	2016-09-07 20:43:08 +0000
+++ qml/gui/WelcomeView.qml	2016-11-21 19:42:42 +0000
@@ -49,6 +49,7 @@
 
             text: i18n.tr("Welcome to the Ubuntu Legacy Application Support Manager.")
         }
+
         Label {
             id: warningMessage
             Layout.fillWidth: true
@@ -67,13 +68,13 @@
             color: UbuntuColors.green
 
             onClicked: {
-                var dialog = PopupUtils.open(Qt.resolvedUrl("ContainerOptionsDialog.qml"))
+                var dialog = PopupUtils.open(Qt.resolvedUrl("../common/ContainerOptionsDialog.qml"))
                 dialog.onCreateInitialized.connect(createInitialized)
             }
         }
     }
 
     function createInitialized() {
-        pageStack.push(Qt.resolvedUrl("ContainersView.qml"))
+        pageStack.push(Qt.resolvedUrl("ContainersView.qml"), {currentContainer: ""})
     }
 }

=== renamed file 'libertine/qml/libertine.qml' => 'qml/gui/libertine.qml'
--- libertine/qml/libertine.qml	2016-06-09 18:20:19 +0000
+++ qml/gui/libertine.qml	2016-11-21 19:42:42 +0000
@@ -28,27 +28,25 @@
     applicationName: "libertine"
     width:  units.gu(90)
     height: units.gu(75)
-    property var currentContainer: undefined
-    property var operationDetails: undefined
 
     signal error(string short_description, string details)
-    signal operationDetailsUpdated(string container_id, string package_name, string details)
-    signal packageOperationInteraction(string data)
 
     PageStack {
         id: pageStack
     }
 
     Component.onCompleted: {
-        Qt.createComponent("ContainerManager.qml").createObject(mainView).fixIntegrity()
-
-        mainView.currentContainer = containerConfigList.defaultContainerId
+        packageOperationDetails.error.connect(error)
+
+        Qt.createComponent("../common/ContainerManager.qml").createObject(mainView).fixIntegrity()
+
+        var currentContainer = containerConfigList.defaultContainerId
 
         if (!containerConfigList.empty()) {
-            pageStack.push(Qt.resolvedUrl("ContainersView.qml"))
-            if (mainView.currentContainer) {
-                containerAppsList.setContainerApps(mainView.currentContainer)
-                pageStack.push(Qt.resolvedUrl("HomeView.qml"), {currentContainer: mainView.currentContainer})
+            pageStack.push(Qt.resolvedUrl("ContainersView.qml"), {currentContainer: currentContainer})
+            if (currentContainer) {
+                containerAppsList.setContainerApps(currentContainer)
+                pageStack.push(Qt.resolvedUrl("../common/ContainerEditView.qml"), {currentContainer: currentContainer})
             }
         }
         else {
@@ -57,63 +55,7 @@
     }
 
     onError: {
-        PopupUtils.open(Qt.resolvedUrl("GenericErrorDialog.qml"), null,
+        PopupUtils.open(Qt.resolvedUrl("../common/GenericErrorDialog.qml"), null,
                                        {"short_description": short_description, "details": details})
     }
-
-    function initializeDetails(container_id, package_name) {
-        if (!operationDetails) {
-            operationDetails = {}
-        }
-        if (!operationDetails[container_id]) {
-            operationDetails[container_id] = {packages: {}, details: ""}
-        }
-        if (!operationDetails[container_id].details) {
-            operationDetails[container_id].details = ""
-        }
-        if (package_name && !operationDetails[container_id].packages[package_name]) {
-            operationDetails[container_id].packages[package_name] = ""
-        }
-    }
-
-    function updateOperationDetails(container_id, package_name, details) {
-        if (!mainView) {
-            return
-        }
-
-        initializeDetails(container_id, package_name)
-
-        if (package_name) {
-            operationDetails[container_id].packages[package_name] += details
-        } else {
-            operationDetails[container_id].details += details
-        }
-
-        operationDetailsUpdated(container_id, package_name, details)
-    }
-
-    function resetOperationDetails(container_id, package_name) {
-        if (mainView && operationDetails && operationDetails[container_id]) {
-            if (package_name) {
-                if (operationDetails[container_id].packages[package_name]) {
-                    delete operationDetails[container_id].packages[package_name]
-                }
-            } else {
-                delete operationDetails[container_id].details
-            }
-        }
-    }
-
-    function getOperationDetails(container_id, package_name) {
-        if (operationDetails && operationDetails[container_id]) {
-            if (package_name) {
-                if (operationDetails[container_id].packages[package_name]) {
-                    return operationDetails[container_id].packages[package_name]
-                }
-            } else if (operationDetails[container_id].details) {
-                return operationDetails[container_id].details
-            }
-        }
-        return ""
-    }
 }

=== added directory 'qml/plugin'
=== added file 'qml/plugin/MainSettingsPage.qml'
--- qml/plugin/MainSettingsPage.qml	1970-01-01 00:00:00 +0000
+++ qml/plugin/MainSettingsPage.qml	2016-11-21 19:42:42 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+import Ubuntu.Components.Popups 1.3
+import SystemSettings 1.0
+import Libertine 1.0
+import "../common"
+
+ItemPage {
+    id: mainView
+
+    header: PageHeader {
+        id: pageHeader
+        title: i18n.tr("Manage Libertine Containers")
+        trailingActionBar.actions: [
+            Action {
+                iconName: "add"
+                onTriggered: {
+                    PopupUtils.open(Qt.resolvedUrl("../common/ContainerOptionsDialog.qml"))
+                }
+            }
+        ]
+    }
+
+    property string currentContainer
+    property var operationDetails
+
+    signal error(string short_description, string details)
+
+    ContainersList {
+        anchors {
+            topMargin: pageHeader.height
+            fill: mainView
+        }
+
+        currentContainer: mainView.currentContainer
+    }
+
+    onError: {
+        PopupUtils.open(Qt.resolvedUrl("../common/GenericErrorDialog.qml"), null,
+                                       {"short_description": short_description, "details": details})
+    }
+}

=== added directory 'system-settings-plugin'
=== added file 'system-settings-plugin/CMakeLists.txt'
--- system-settings-plugin/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ system-settings-plugin/CMakeLists.txt	2016-11-21 19:42:42 +0000
@@ -0,0 +1,38 @@
+set(PLUGIN_MANIFEST_DIR_BASE share/ubuntu/settings/system)
+set(PLUGIN_MODULE_DIR_BASE ubuntu-system-settings)
+
+set(PLUGIN_MANIFEST_DIR "${CMAKE_INSTALL_PREFIX}/${PLUGIN_MANIFEST_DIR_BASE}")
+set(PLUGIN_MODULE_DIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/${PLUGIN_MODULE_DIR_BASE}")
+set(PLUGIN_QML_DIR "${CMAKE_INSTALL_PREFIX}/share/ubuntu/settings/system/qml-plugins/libertine")
+
+SET(CMAKE_INSTALL_RPATH "${PLUGIN_MODULE_DIR}")
+
+configure_file(config.h.in config.h)
+
+set(LIBERTINE_PLUGIN_ICON_PATH "${PLUGIN_MANIFEST_DIR}/icons")
+set(PLUGIN_SETTINGS_TARGET libertine.settings)
+configure_file(${PLUGIN_SETTINGS_TARGET}.in ${PLUGIN_SETTINGS_TARGET})
+
+set (CMAKE_INCLUDE_CURRENT_DIR ON)
+set (CMAKE_AUTOMOC ON)
+
+# For some reason, building on vivid seems to require that we manually
+# add /usr/include to the include directories when using automoc here.
+set (CMAKE_AUTOMOC_MOC_OPTIONS -I/usr/include)
+
+pkg_check_modules(SYSTEM_SETTINGS REQUIRED SystemSettings)
+
+file(GLOB_RECURSE PLUGIN_QML_SRC
+     ${CMAKE_SOURCE_DIR}/qml/common/*.qml
+     ${CMAKE_SOURCE_DIR}/qml/plugin/*.qml
+)
+
+add_library(libertine-plugin MODULE plugin.cpp plugin.h ${PLUGIN_QML_SRC})
+qt5_use_modules(libertine-plugin Qml Quick)
+
+include_directories(${SYSTEM_SETTINGS_INCLUDE_DIRS} ${CMAKE_SOURCE_DIR}/libertine)
+target_link_libraries(libertine-plugin ${LIBERTINE_COMMON} ${SYSTEM_SETTINGS_LIBRARIES})
+
+install(TARGETS libertine-plugin LIBRARY DESTINATION ${PLUGIN_MODULE_DIR} NAMELINK_SKIP)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PLUGIN_SETTINGS_TARGET} DESTINATION ${PLUGIN_MANIFEST_DIR})
+install(FILES libertine-plugin.png DESTINATION ${LIBERTINE_PLUGIN_ICON_PATH})

=== added file 'system-settings-plugin/config.h.in'
--- system-settings-plugin/config.h.in	1970-01-01 00:00:00 +0000
+++ system-settings-plugin/config.h.in	2016-11-21 19:42:42 +0000
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2016 Canonical Ltd
+ *
+ * Libertine 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.
+ *
+ * Libertine 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/>.
+ */
+
+#define LIBERTINE_PLUGIN_QML_DIR "@LIBERTINE_QML_PATH@/plugin"

=== added file 'system-settings-plugin/libertine-plugin.png'
Binary files system-settings-plugin/libertine-plugin.png	1970-01-01 00:00:00 +0000 and system-settings-plugin/libertine-plugin.png	2016-11-21 19:42:42 +0000 differ
=== added file 'system-settings-plugin/libertine.settings.in'
--- system-settings-plugin/libertine.settings.in	1970-01-01 00:00:00 +0000
+++ system-settings-plugin/libertine.settings.in	2016-11-21 19:42:42 +0000
@@ -0,0 +1,14 @@
+{
+    "name": "Libertine",
+    "icon": "${LIBERTINE_PLUGIN_ICON_PATH}/libertine-plugin.png",
+    "translations": "libertine",
+    "category": "system",
+    "keywords": [
+        "libertine",
+        "legacy",
+        "x11"
+    ],
+    "has-dynamic-keywords": false,
+    "has-dynamic-visibility": false,
+    "plugin": "libertine-plugin"
+}

=== added file 'system-settings-plugin/plugin.cpp'
--- system-settings-plugin/plugin.cpp	1970-01-01 00:00:00 +0000
+++ system-settings-plugin/plugin.cpp	2016-11-21 19:42:42 +0000
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "plugin.h"
+
+#include "config.h"
+#include "common/ContainerManager.h"
+#include "common/ContainerAppsList.h"
+#include "common/ContainerArchivesList.h"
+#include "common/ContainerConfigList.h"
+#include "common/LibertineConfig.h"
+#include "common/ContainerConfig.h"
+#include "common/PackageOperationDetails.h"
+#include <memory>
+#include <QQmlEngine>
+#include <QQmlContext>
+#include <QFileSystemWatcher>
+#include <SystemSettings/ItemBase>
+
+using namespace SystemSettings;
+
+class LibertineItem: public ItemBase
+{
+    Q_OBJECT
+
+public:
+    explicit LibertineItem(const QVariantMap &staticData, QObject *parent = 0);
+    virtual ~LibertineItem() = default;
+
+    virtual QQmlComponent* pageComponent(QQmlEngine *engine,
+                                         QObject *parent = 0) override;
+
+private:
+    std::unique_ptr<LibertineConfig> config_;
+    ContainerConfigList*            containers_;
+    ContainerAppsList*              container_apps_;
+    ContainerArchivesList*          container_archives_;
+    PackageOperationDetails*        package_operation_details_;
+    QFileSystemWatcher              watcher_;
+
+private slots:
+    void reload_config(QString const&);
+};
+
+LibertineItem::
+LibertineItem(const QVariantMap &staticData, QObject *parent)
+  : ItemBase(staticData, parent)
+  , config_(new LibertineConfig())
+  , containers_(new ContainerConfigList(config_.get(), this))
+  , container_apps_(new ContainerAppsList(containers_, this))
+  , container_archives_(new ContainerArchivesList(containers_, this))
+  , package_operation_details_(new PackageOperationDetails(this))
+  , watcher_({config_->containers_config_file_name()})
+{
+  qmlRegisterType<ContainerConfig>("Libertine", 1, 0, "ContainerConfig");
+  qmlRegisterType<ContainerManagerWorker>("Libertine", 1, 0, "ContainerManagerWorker");
+  qmlRegisterType<PackageOperationDetails>("Libertine", 1, 0, "PackageOperationDetails");
+
+  connect(&watcher_, &QFileSystemWatcher::fileChanged, this, &LibertineItem::reload_config);
+}
+
+QQmlComponent *LibertineItem::
+pageComponent(QQmlEngine *engine, QObject *parent)
+{
+  auto ctxt = engine->rootContext();
+  ctxt->setContextProperty("containerConfigList", containers_);
+  ctxt->setContextProperty("containerAppsList", container_apps_);
+  ctxt->setContextProperty("containerArchivesList", container_archives_);
+  ctxt->setContextProperty("packageOperationDetails", package_operation_details_);
+
+  auto component = new QQmlComponent(engine,
+                           QUrl(LIBERTINE_PLUGIN_QML_DIR "/MainSettingsPage.qml"),
+                           parent);
+  return component;
+}
+
+
+void LibertineItem::
+reload_config(QString const&)
+{
+  containers_->reloadConfigs();
+}
+
+
+ItemBase *LibertinePlugin::
+createItem(const QVariantMap &staticData,
+                                 QObject *parent)
+{
+  return new LibertineItem(staticData, parent);
+}
+
+#include "plugin.moc"

=== added file 'system-settings-plugin/plugin.h'
--- system-settings-plugin/plugin.h	1970-01-01 00:00:00 +0000
+++ system-settings-plugin/plugin.h	2016-11-21 19:42:42 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <QObject>
+#include <SystemSettings/PluginInterface>
+
+class LibertinePlugin:
+    public QObject,
+    public SystemSettings::PluginInterface2
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "com.ubuntu.SystemSettings.PluginInterface/2.0")
+    Q_INTERFACES(SystemSettings::PluginInterface2)
+
+public:
+    explicit LibertinePlugin() = default;
+
+    SystemSettings::ItemBase *createItem(const QVariantMap &staticData,
+                                         QObject *parent = 0);
+};

=== modified file 'tests/unit/CMakeLists.txt'
--- tests/unit/CMakeLists.txt	2016-08-09 22:37:08 +0000
+++ tests/unit/CMakeLists.txt	2016-11-21 19:42:42 +0000
@@ -19,59 +19,14 @@
   test_container_config
 )
 
-add_test(test_libertine_public_gir
-  "/usr/bin/python3" "-m" "testtools.run" "libertine_public_gir_tests"
-)
-set_tests_properties(test_libertine_public_gir
-                     PROPERTIES
-                     ENVIRONMENT
-                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}")
-set_tests_properties(test_libertine_public_gir
-                     PROPERTIES
-                     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
-
-add_test(test_libertine "/usr/bin/python3" "-m" "testtools.run" "discover" "-s" "${CMAKE_CURRENT_SOURCE_DIR}")
+add_test(test_libertine "py.test-3" "${CMAKE_CURRENT_SOURCE_DIR}" "-v" "--junit-xml=test_libertine.xml" "--ignore=${CMAKE_CURRENT_SOURCE_DIR}/test_launcher_with_dbus.py")
 set_tests_properties(test_libertine
-                     PROPERTIES
-                     ENVIRONMENT
-                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};PYTHONPATH=${CMAKE_SOURCE_DIR}/python")
-
-add_test(test_libertine_container_manager
-  "/usr/bin/python3" "-m" "testtools.run" "libertine_container_manager_tests"
-)
-set_tests_properties(test_libertine_container_manager
-                     PROPERTIES
-                     ENVIRONMENT
-                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
-
-add_test(test_libertine_launch
-  "/usr/bin/python3" "-m" "testtools.run" "libertine_launch_tests"
-)
-set_tests_properties(test_libertine_launch
-                     PROPERTIES
-                     ENVIRONMENT
-                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
-
-add_test(test_libertine_session_bridge
-  "/usr/bin/python3" "-m" "testtools.run" "libertine_session_bridge_tests"
-)
-set_tests_properties(test_libertine_session_bridge
-                     PROPERTIES
-                     ENVIRONMENT
-                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
-
-add_test(test_libertine_socket
-  "/usr/bin/python3" "-m" "testtools.run" "libertine_socket_tests"
-)
-set_tests_properties(test_libertine_socket
-                     PROPERTIES
-                     ENVIRONMENT
-                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
-
-add_test(test_logger
-  "/usr/bin/python3" "-m" "testtools.run" "libertine_logger_tests"
-)
-set_tests_properties(test_logger
-                     PROPERTIES
-                     ENVIRONMENT
-                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
+                     PROPERTIES ENVIRONMENT
+                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR};LIBERTINE_DATA_DIR=${CMAKE_CURRENT_SOURCE_DIR}")
+
+add_test(test_libertine_with_dbus "py.test-3" "${CMAKE_CURRENT_SOURCE_DIR}/test_launcher_with_dbus.py" "-v" "--junit-xml=test_libertine_with_dbus.xml" )
+set_tests_properties(test_libertine_with_dbus
+                     PROPERTIES
+                     ENVIRONMENT
+                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
+

=== modified file 'tests/unit/ContainerConfigListTests.cpp'
--- tests/unit/ContainerConfigListTests.cpp	2015-09-15 15:03:38 +0000
+++ tests/unit/ContainerConfigListTests.cpp	2016-11-21 19:42:42 +0000
@@ -19,7 +19,7 @@
  */
 #include <gtest/gtest.h>
 
-#include "libertine/ContainerConfigList.h"
+#include "common/ContainerConfigList.h"
 #include <QtCore/QByteArray>
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonParseError>

=== modified file 'tests/unit/ContainerConfigTests.cpp'
--- tests/unit/ContainerConfigTests.cpp	2016-01-21 21:42:28 +0000
+++ tests/unit/ContainerConfigTests.cpp	2016-11-21 19:42:42 +0000
@@ -19,7 +19,7 @@
  */
 #include <gtest/gtest.h>
 
-#include "libertine/ContainerConfig.h"
+#include "common/ContainerConfig.h"
 #include <QtCore/QByteArray>
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonParseError>

=== removed file 'tests/unit/libertine_public_gir_tests.py'
--- tests/unit/libertine_public_gir_tests.py	2015-10-08 14:49:00 +0000
+++ tests/unit/libertine_public_gir_tests.py	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-# Copyright 2015 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import os
-from testtools import TestCase
-from testtools.matchers import Equals
-from gi.repository import Libertine
-
-class TestLibertineGir(TestCase):
-
-    def setUp(self):
-        super(TestLibertineGir, self).setUp()
-        self.cmake_source_dir = os.environ['CMAKE_SOURCE_DIR']
-
-    def test_list_containers(self):
-        os.environ['XDG_DATA_HOME'] = self.cmake_source_dir + '/libertine-config'
-  
-        containers = Libertine.list_containers()
-
-        self.assertThat(containers[0], Equals('wily'))
-        self.assertThat(containers[1], Equals('wily-2'))
-
-    def test_container_path(self):
-        container_id = 'wily'
-        os.environ['XDG_CACHE_HOME'] = self.cmake_source_dir + '/libertine-data'
-
-        container_path = Libertine.container_path(container_id)
-        self.assertThat(container_path, Equals(self.cmake_source_dir + '/libertine-data/libertine-container/wily/rootfs'))
-
-    def test_container_home_path(self):
-        container_id = 'wily'
-        os.environ['XDG_DATA_HOME'] = self.cmake_source_dir + '/libertine-home'
-
-        container_home_path = Libertine.container_home_path(container_id)
-        self.assertThat(container_home_path, Equals(self.cmake_source_dir + '/libertine-home/libertine-container/user-data/wily'))
-
-    def test_container_name(self):
-        container_id = 'wily'
-        os.environ['XDG_DATA_HOME'] = self.cmake_source_dir + '/libertine-config'
-
-        container_name = Libertine.container_name(container_id)
-        self.assertThat(container_name, Equals("Ubuntu 'Wily Werewolf'"))
-
-        container_id = 'wily-2'
-        container_name = Libertine.container_name(container_id)
-        self.assertThat(container_name, Equals("Ubuntu 'Wily Werewolf' (2)"))
-
-    def test_list_apps_for_container(self):
-        os.environ['XDG_DATA_HOME'] = self.cmake_source_dir + '/libertine-config'
-  
-        apps = Libertine.list_apps_for_container('wily')
-        self.assertThat(len(apps), Equals(0))

=== removed file 'tests/unit/libertine_session_bridge_tests.py'
--- tests/unit/libertine_session_bridge_tests.py	2016-08-09 18:18:14 +0000
+++ tests/unit/libertine_session_bridge_tests.py	1970-01-01 00:00:00 +0000
@@ -1,106 +0,0 @@
-# Copyright 2016 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import os
-import tempfile
-from socket import *
-import shutil
-
-from libertine import LibertineSessionBridge, HostSessionSocketPair, SessionSocket, LibertineApplication
-from libertine import Socket
-from multiprocessing import Process
-
-from testtools import TestCase
-from testtools.matchers import Equals, NotEquals
-
-import time
-import threading
-
-class TestLibertineSessionBridge(TestCase):
-    def setUp(self):
-        super(TestLibertineSessionBridge, self).setUp()
-
-        xdg_runtime_path = tempfile.mkdtemp()
-
-        self.addCleanup(self.cleanup)
-
-        # Set necessary enviroment variables
-        os.environ['XDG_RUNTIME_DIR'] = xdg_runtime_path
-
-        # Create r/w fake temp sockets, the session will be created by the lsb
-        self.host_path    = os.path.join(xdg_runtime_path, 'HOST')
-        self.session_path = os.path.join(xdg_runtime_path, 'SESSION')
-
-        self.host_socket = SessionSocket(self.host_path)
-        self.assertTrue(os.path.exists(self.host_path))
-
-    """
-    Make sure we assert out socket is cleaned up. If we are failing here RAII
-    is broken.
-    """
-    def cleanup(self):
-        self.host_socket = None
-
-        self.assertFalse(os.path.exists(self.session_path))
-        self.assertFalse(os.path.exists(self.host_path))
-        shutil.rmtree(os.environ['XDG_RUNTIME_DIR'])
-
-    """
-    A function used to just read from the host socket. In a different thread
-    """
-    def host_read(self, expected_bytes):
-        conn, addr = self.host_socket.socket.accept()
-        data = conn.recv(1024)
-        conn.close()
-        self.assertThat(data, Equals(expected_bytes))
-
-    def test_creates_socket_file(self):
-        """
-        We assert when we create a lsb we create the session socket
-        """
-        lsb = LibertineSessionBridge([HostSessionSocketPair(self.host_path, self.session_path)])
-        self.assertTrue(os.path.exists(self.session_path))
-
-
-    def test_data_read_from_host_to_session(self):
-        """
-        This test shows we are able to proxy data from a host socket to a session client.
-        We do this by:
-        1) Create a valid host socket
-        2) Start a thread which waits to asserts out host socket recv the expected data
-        3) Start the lsb thread to create a proxy session socket
-        4) We create a fake session client (socket) and connect to the session path
-        5) We send the expected bytes to the fake session client socket
-        6) We join on the host sock loop, if we never get the expected bytes in the host socket loop we fail
-        7) Clean up, and assert all our threads are not alive and have been cleaned up
-        """
-        expected_bytes = b'Five exclamation marks, the sure sign of an insane mind.'
-        host_sock_loop = threading.Thread(target=self.host_read, args=(expected_bytes,))
-        host_sock_loop.start()
-
-        lsb = LibertineSessionBridge([HostSessionSocketPair(self.host_path, self.session_path)])
-        lsb_process = Process(target=lsb.main_loop)
-        lsb_process.start()
-
-        fake_session_client = socket(AF_UNIX, SOCK_STREAM)
-        fake_session_client.connect(self.session_path)
-        fake_session_client.sendall(expected_bytes)
-
-        host_sock_loop.join(timeout=1)
-        fake_session_client.close()
-        lsb_process.terminate()
-        lsb_process.join(timeout=1)
-
-        self.assertFalse(host_sock_loop.is_alive())
-        self.assertFalse(lsb_process.is_alive())

=== removed file 'tests/unit/libertine_socket_tests.py'
--- tests/unit/libertine_socket_tests.py	2016-07-19 20:25:02 +0000
+++ tests/unit/libertine_socket_tests.py	1970-01-01 00:00:00 +0000
@@ -1,72 +0,0 @@
-# Copyright 2016 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-from libertine import Socket
-
-from socket import socket
-
-from testtools import TestCase
-from testtools.matchers import Equals, NotEquals
-
-class FakeSocket(Socket):
-    """
-    We are making things up here... soo lets not attempt to remove anything!
-    """
-    def __del__(self):
-        pass
-
-
-class TestSocket(TestCase):
-    def setUp(self):
-        super(TestSocket, self).setUp()
-        self.socket1 = socket()
-        self.socket2 = socket()
-
-    """
-    Test we can wrap a python socket.socket in our Socket class
-    """
-    def test_socket_warp(self):
-        s = FakeSocket(self.socket1)
-        self.assertThat(s, Equals(self.socket1))
-
-    """
-    Test our equivalence operator works on three types:
-        1: Other Socket classes
-        2: Python socket classes
-        3: The fd/socket raw Int value
-    """
-    def test_socket_eq_op(self):
-        s1 = FakeSocket(self.socket1)
-        s2 = FakeSocket(self.socket1)
-        self.assertThat(s1, Equals(s2))
-        self.assertThat(s2, Equals(self.socket1))
-        self.assertThat(s2, Equals(self.socket1.fileno()))
-
-    """
-    Test our not equivalence works on the same three types
-    """
-    def test_socket_not_eq_op(self):
-        s1 = FakeSocket(self.socket1)
-        s2 = FakeSocket(self.socket2)
-        self.assertThat(s1, NotEquals(s2))
-        self.assertThat(s2, NotEquals(self.socket1))
-        self.assertThat(s2, NotEquals(self.socket1.fileno()))
-
-    """
-    Test our Socket wrapper class is also hashable
-    """
-    def test_socket_is_hashable(self):
-        s   = FakeSocket(self.socket1)
-        dic = {s: 17}
-        self.assertThat(dic[s], Equals(17))

=== renamed file 'tests/unit/libertine_launch_tests.py' => 'tests/unit/test_launcher.py'
--- tests/unit/libertine_launch_tests.py	2016-06-30 20:45:38 +0000
+++ tests/unit/test_launcher.py	2016-11-21 19:42:42 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015 Canonical Ltd.
+# Copyright 2015-2016 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -13,64 +13,575 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
-import shlex
+import random
 import shutil
-import subprocess
+import signal
+import string
 import tempfile
 
-from libertine import LibertineApplication
-
-from testtools import TestCase
-from testtools.matchers import Equals, NotEquals
-
-class TestLibertineLaunch(TestCase):
+from libertine import LibertineContainer
+from libertine import launcher
+
+from contextlib import suppress
+from io import StringIO
+from selectors import DefaultSelector, EVENT_READ
+from socket import socket, AF_UNIX, SOCK_STREAM
+from testtools import TestCase, ExpectedException
+from testtools.matchers import Equals, Not, Contains, MatchesPredicate
+from threading import Thread, Barrier, BrokenBarrierError
+from time import sleep
+from unittest.mock import call, patch, MagicMock
+
+
+def _generate_unique_string(prefix=''):
+    """Generates a (hopefully) unique string."""
+    return prefix + ''.join(random.choice(string.ascii_lowercase + string.digits) for i in range(8))
+
+class TestLauncher(TestCase):
     def setUp(self):
-        super(TestLibertineLaunch, self).setUp()
-        self.cmake_source_dir = os.environ['CMAKE_SOURCE_DIR']
-        self.cmake_binary_dir = os.environ['CMAKE_BINARY_DIR']
-
-        container_config_path = os.path.join(self.cmake_binary_dir, 'tests', 'unit', 'libertine-config')
-
-        # Set necessary enviroment variables
-        os.environ['XDG_DATA_HOME'] = container_config_path
+        super(TestLauncher, self).setUp()
         os.environ['XDG_RUNTIME_DIR'] = tempfile.mkdtemp()
-        os.environ['PATH'] = (self.cmake_source_dir + '/tests/mocks:' +
-                              self.cmake_source_dir + '/tools:' + os.environ['PATH'])
-
         self.addCleanup(self.cleanup)
 
-        # Lets figure out how to really mock this....
-        cli_cmd = self.cmake_source_dir + '/tools/libertine-container-manager create -i test -n Test -t mock'
-        args = shlex.split(cli_cmd)
-        subprocess.Popen(args).wait()
-
     def cleanup(self):
         shutil.rmtree(os.environ['XDG_RUNTIME_DIR'])
 
-    def test_launch_app_existing_container(self):
-        '''
-        Base line test to ensure launching an app in an existing container works.
-        '''
-        la = LibertineApplication('test', 'true')
-        la.launch_application()
-
-    def test_launch_app_nonexistent_container(self):
-        '''
-        Test to make sure that things gracefully handle a non-existing container.
-        '''
-        la = LibertineApplication('test1', 'true')
-        self.assertRaises(RuntimeError, la.launch_application)
-
-    def test_launch_good_app(self):
-        '''
-        Test to make sure that launching an app actually works.
-        '''
-        la = LibertineApplication('test', 'mock_app')
-        la.launch_application()
-
-    def test_launch_bad_app(self):
-        '''
-        Test to make sure launching an app that doesn't exist doesn't break things
-        '''
-        la = LibertineApplication('test', 'foo')
-        self.assertRaises(FileNotFoundError, la.launch_application)
+class TestLauncherTaskConfig(TestLauncher):
+    """Unit tests for libertine.launcher.task module."""
+
+    def test_task_config_ctor(self):
+        """Verify Task constructor sets the required attributes."""
+        fake_datum = [self.getUniqueString()]
+
+        task = launcher.TaskConfig(launcher.TaskType.LAUNCH_SERVICE, fake_datum)
+
+        self.assertThat(task.task_type, Equals(launcher.TaskType.LAUNCH_SERVICE))
+        self.assertThat(task.datum, Equals(fake_datum))
+
+
+class TestLauncherConfig(TestLauncher):
+    """
+    Verifies the defined behaviour of the Libertine Launcher Config class.
+    """
+
+    # a standard set of command-line arguments for when we don't care
+    id_arg = ['-i', 'container-id']
+    exec_args = ['exec-line', 'one', 'two', 'three']
+    basic_args = id_arg + exec_args
+
+    def test_unqiue_id_generation(self):
+        """Ensure each unique configuration has a unique identifier."""
+        config1 = launcher.Config(TestLauncherConfig.basic_args[:])
+        config2 = launcher.Config(TestLauncherConfig.basic_args[:])
+        self.assertThat(config1.id, Not(Equals(config2.id)))
+
+    def test_mandatory_args(self):
+        """Verify that the mandatory CLI args get put where they're supposed to get put."""
+        config = launcher.Config(TestLauncherConfig.basic_args[:])
+        self.assertEquals(config.exec_line, TestLauncherConfig.exec_args)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_missing_mandatory_args(self, stderr):
+        """Make sure missing mandatory CLI args are handled gracefully.
+
+        Gracefully means a usage message is printed and the application exists.
+        """
+        with ExpectedException(SystemExit):
+            config = launcher.Config(TestLauncherConfig.id_arg)
+        message = stderr.getvalue().strip()
+        self.assertThat(message, Contains("usage:"))
+
+    def test_optional_id_arg(self):
+        """Make sure optional container id is handled."""
+        config = launcher.Config(TestLauncherConfig.basic_args[:])
+        self.assertEquals(config.container_id, 'container-id')
+
+    def test_missing_optional_id_arg(self):
+        """Ensure command parsing works fine when container id is left off"""
+        config = launcher.Config(TestLauncherConfig.exec_args)
+        self.assertEquals(config.container_id, None)
+
+    def test_one_explicit_environment_arg(self):
+        """Verify that one -E arg gets put into the environment."""
+        argv = ['-EMY_ENV=something'] + TestLauncherConfig.basic_args[:]
+        config = launcher.Config(argv)
+        self.assertIn('MY_ENV', config.session_environ)
+
+    def test_two_explicit_environment_args(self):
+        """Verify that multiple -E args gets put into the environment."""
+        argv = ['-EMY_ENV=something', '-E', 'SOME_OTHER_ENV=somethingelse'] + TestLauncherConfig.basic_args[:]
+        config = launcher.Config(argv)
+        self.assertEquals(config.session_environ.get('MY_ENV', 'nothing'), 'something')
+        self.assertEquals(config.session_environ.get('SOME_OTHER_ENV', 'nothing'), 'somethingelse')
+
+    def test_usr_games_is_in_path(self):
+        """Makes sure that /usr/games is in $PATH.
+
+        This was a problem encountered early on.
+        """
+        with patch.dict('os.environ', {'PATH': '/usr/local/bin:/bin:/usr/bin'}):
+            self.assertNotIn('/usr/games', os.environ['PATH'].split(sep=':'))
+            config = launcher.Config(TestLauncherConfig.basic_args[:])
+            self.assertIn('/usr/games', config.session_environ['PATH'].split(sep=':'))
+
+    def test_maliit_socket_bridge_from_env(self):
+        """Make sure the Maliit socket bridge gets configured.
+
+        The Maliit socket address is normally found in an environment variable.
+        """
+        env_key = 'MALIIT_SERVER_ADDRESS'
+        bogus_host_address = 'unix:abstract=/tmp/maliit-host-socket'
+        maliit_bridge = None
+
+        with patch.dict('os.environ', {env_key: bogus_host_address}):
+            config = launcher.Config(TestLauncherConfig.basic_args[:])
+            for bridge in config.socket_bridges:
+                if bridge.env_var == env_key:
+                    maliit_bridge = bridge
+
+        self.assertIsNotNone(maliit_bridge)
+        self.assertThat(maliit_bridge.host_address, Equals(bogus_host_address))
+        self.assertThat(maliit_bridge.session_address, Contains('maliit'))
+        self.assertThat(config.session_environ.get(env_key, None), Not(Equals(None)))
+        self.assertThat(config.session_environ.get(env_key, bogus_host_address),
+                        Not(Equals(bogus_host_address)))
+
+    def test_dbus_socket_bridge_from_env(self):
+        """Make sure the D-Bus socket bridge gets configured.
+
+        The D-Bus socket address is normally found in an environment variable.
+        """
+        env_key = 'DBUS_SESSION_BUS_ADDRESS'
+        bogus_host_address = 'unix:abstract=/tmp/dbus-host-socket'
+        dbus_bridge = None
+
+        with patch.dict('os.environ', {env_key: bogus_host_address}):
+            config = launcher.Config(TestLauncherConfig.basic_args[:])
+            for bridge in config.socket_bridges:
+                if bridge.env_var == env_key:
+                    dbus_bridge = bridge
+
+        self.assertIsNotNone(dbus_bridge)
+        self.assertThat(dbus_bridge.host_address, Equals(bogus_host_address))
+        self.assertThat(dbus_bridge.session_address, Contains('dbus'))
+        self.assertThat(config.session_environ.get(env_key, None), Not(Equals(None)))
+        self.assertThat(config.session_environ.get(env_key, bogus_host_address),
+                        Not(Equals(bogus_host_address)))
+
+    def test_default_prelaunch_tasks(self):
+        """Ensure 'pasted' is in the default pre-launch task list."""
+        def pasted_is_in_list(task_list):
+            for t in task_list:
+                if t.task_type == launcher.TaskType.LAUNCH_SERVICE and t.datum[0] == "pasted":
+                    return True
+            return False
+
+        config = launcher.Config(TestLauncherConfig.basic_args[:])
+        self.assertThat(config.prelaunch_tasks,
+                        MatchesPredicate(pasted_is_in_list, "pasted is not in task list"))
+
+
+class TestLauncherSession(TestLauncher):
+    """
+    Verifies the defined bahaviour of a Libertine Lunacher session.
+
+    This set of tests does the alien probe dance on things that can be verified
+    without actually requiring the launcher event loop be runing -- except for
+    the basic check that an event loop runs and can be terminated.
+    """
+
+    def setUp(self):
+        """Set up a mock config and a mock container."""
+        super().setUp()
+
+        fake_session_socket = 'unix:path=/tmp/garbage'
+        fake_bridge_config = launcher.SocketBridge('FAKE_SOCKET', 'dummy', fake_session_socket)
+        self._mock_config = MagicMock(spec=launcher.Config,
+                                      socket_bridges=[fake_bridge_config],
+                                      container_id=None)
+
+        self._fake_session_address = launcher.translate_to_real_address(fake_session_socket)
+
+        self._mock_container = MagicMock(spec=LibertineContainer)
+
+    def test_basic_ctor(self):
+        """Just test the basic no-frill construction of a session."""
+        self._mock_config.id = 'blah'
+        session = launcher.Session(self._mock_config, self._mock_container)
+        self.assertThat(session.id, Equals('blah'))
+
+    def test_signals_are_restored(self):
+        """Verify that a Session object, when used correctly, cleans up any signal
+        handlers it has replaced.
+
+        This test just makes sure the test environment is left in a clean state
+        after testing so that it does not corrupt the results of other unit
+        tests.
+        """
+        old_sigchld_handler = signal.getsignal(signal.SIGCHLD)
+        old_sigint_handler  = signal.getsignal(signal.SIGINT)
+        old_sigterm_handler = signal.getsignal(signal.SIGTERM)
+
+        with launcher.Session(self._mock_config, self._mock_container) as session:
+            pass
+
+        self.assertThat(signal.getsignal(signal.SIGCHLD), Equals(old_sigchld_handler))
+        self.assertThat(signal.getsignal(signal.SIGINT),  Equals(old_sigint_handler))
+        self.assertThat(signal.getsignal(signal.SIGTERM), Equals(old_sigterm_handler))
+
+    @patch('libertine.launcher.session.socket.listen')
+    @patch('libertine.launcher.session.socket.bind')
+    def test_bridge_listener_is_created(self, mock_bind, mock_listen):
+        """Verify that a socket connection listener is set up for a socket bridge config passed in."""
+        with launcher.Session(self._mock_config, self._mock_container) as session:
+            self.assertThat(mock_bind.call_args, Equals(call(self._fake_session_address)))
+            self.assertThat(mock_listen.called, Equals(True))
+
+    def test_sigchld_exits_run(self):
+        """Verify that the run() method returns on receipt of SIGCHLD. """
+        with launcher.Session(self._mock_config, self._mock_container) as session:
+            def run_session_event_loop():
+                session.run()
+
+            session_event_loop = Thread(target=run_session_event_loop)
+            session_event_loop.start()
+
+            os.kill(os.getpid(), signal.SIGCHLD)
+
+            session_event_loop.join(timeout=0.5)
+            self.assertThat(session_event_loop.is_alive(), Equals(False))
+
+    def test_sigint_exits_run(self):
+        """Verify that the run() method returns on receipt of SIGINT. """
+        with launcher.Session(self._mock_config, self._mock_container) as session:
+            def run_session_event_loop():
+                session.run()
+
+            session_event_loop = Thread(target=run_session_event_loop)
+            session_event_loop.start()
+
+            os.kill(os.getpid(), signal.SIGINT)
+
+            session_event_loop.join(timeout=0.5)
+            self.assertThat(session_event_loop.is_alive(), Equals(False))
+
+    def test_sigterm_exits_run(self):
+        """Verify that the run() method returns on receipt of SIGTERM."""
+        with launcher.Session(self._mock_config, self._mock_container) as session:
+            def run_session_event_loop():
+                session.run()
+
+            session_event_loop = Thread(target=run_session_event_loop)
+            session_event_loop.start()
+
+            os.kill(os.getpid(), signal.SIGTERM)
+
+            session_event_loop.join(timeout=0.5)
+            self.assertThat(session_event_loop.is_alive(), Equals(False))
+
+
+class TestLauncherServiceTask(TestLauncher):
+    """Verify the expected bahaviour of launch tasks."""
+
+    def setUp(self):
+        """Set up an even loop fixture to watch for signals from spawned tasks. """
+        super().setUp()
+        self._sigchld_caught = False
+
+        def noopSignalHandler(*args):
+            pass
+        original_sigchld_handler = signal.signal(signal.SIGCHLD, noopSignalHandler)
+        self.addCleanup(lambda: signal.signal(signal.SIGCHLD, original_sigchld_handler))
+
+        sig_r_fd, sig_w_fd = os.pipe2(os.O_NONBLOCK | os.O_CLOEXEC)
+        signal.set_wakeup_fd(sig_w_fd)
+
+        pre_loop_barrier = Barrier(2)
+        self._post_loop_barrier = Barrier(2)
+
+        def loop():
+            pre_loop_barrier.wait(1)
+            selector = DefaultSelector()
+            selector.register(sig_r_fd, EVENT_READ)
+            with suppress(StopIteration):
+                while True:
+                    events = selector.select(timeout=5)
+                    if len(events) == 0:
+                        raise StopIteration
+                    for key, mask in events:
+                        if key.fd == sig_r_fd:
+                            data = os.read(sig_r_fd, 4)
+                            self._sigchld_caught = True
+                            raise StopIteration
+            self._post_loop_barrier.wait(1)
+
+        test_loop = Thread(target=loop)
+        self.addCleanup(lambda: test_loop.join(1))
+        test_loop.start()
+        pre_loop_barrier.wait(1)
+
+    def test_service_sends_SIGCHLD_on_exit(self):
+        """Verify a SIGCHLD signal gets raised when the service exits.
+
+        Runs a fast-exiting 'service' (which should finish on its own in a
+        reasonable time) and verifies that a SIGCHLD is raised.
+        """
+        config = launcher.TaskConfig(launcher.TaskType.LAUNCH_SERVICE, ("/bin/true"))
+        task = launcher.LaunchServiceTask(config)
+        task.start()
+        self._post_loop_barrier.wait(1)
+        self.assertThat(self._sigchld_caught, Equals(True))
+        
+    def test_service_stop_exits_program(self):
+        """Verify the service exists when stopped.
+        
+        Runs a long-running service (which should not normally finish on its
+        own) and verifies that a SIGCHLD is received after calling stop() on the
+        task.
+        """
+        config = launcher.TaskConfig(launcher.TaskType.LAUNCH_SERVICE, ("/usr/bin/yes"))
+        task = launcher.LaunchServiceTask(config)
+        task.start()
+        sleep(0.05)
+        task.stop()
+        self._post_loop_barrier.wait(1)
+        self.assertThat(self._sigchld_caught, Equals(True))
+
+
+class SessionEventLoopRunning(Thread):
+    """Provide a running, stoppable session event loop as a context manager thread."""
+
+    def __init__(self, session):
+        super().__init__()
+        self._session = session
+
+    def __enter__(self):
+        """Start the session event loop thread running on context entry."""
+        self.start()
+        return self
+
+    def __exit__(self, *exc):
+        """Shut down the session event loop thread."""
+        join_attempt_count = 0
+        max_join_attempts = 5
+        while self.is_alive() and join_attempt_count < max_join_attempts:
+            self.stop()
+            self.join(timeout=0.5)
+            join_attempt_count += 1
+        assert join_attempt_count < max_join_attempts
+        return False
+
+    def run(self):
+        with suppress(BrokenBarrierError):
+            self._session.run()
+
+    def stop(self):
+        """Stop the session event loop.
+
+        May be called multiple times without harm.
+
+        Has a little nap after raising the TERM signal so the GIL gets
+        relinquished and the loop thread has a chance to process its signals.
+        """
+        os.kill(os.getpid(), signal.SIGTERM)
+        sleep(0.0001)
+
+
+class EchoServer(Thread):
+    """A test fixture providing some kind of service running on the host at a known address."""
+
+    socket_address = 'unix:path=/tmp/echo-host-' + _generate_unique_string()
+
+    def __init__(self):
+        super().__init__()
+        self.daemon = True
+
+        real_socket_address = launcher.translate_to_real_address(EchoServer.socket_address)
+
+        self._socket = socket(AF_UNIX, SOCK_STREAM)
+        self._socket.bind(real_socket_address)
+        self._socket.listen(5)
+        self.start()
+
+    def run(self):
+        while True:
+            (s, a) = self._socket.accept()
+            b = s.recv(512)
+            r = bytes("echo<<{}>>".format(b), 'ascii')
+            with suppress(BrokenPipeError):
+                s.sendall(r)
+            s.close()
+
+
+class TestLauncherSessionSocketBridge(TestLauncher):
+    """Verify the Launcher Session socket bridge functionality."""
+
+    _fake_session_socket = 'unix:path=/tmp/session-' + _generate_unique_string()
+
+    @patch('test_launcher.LibertineContainer')
+    def setUp(self, mock_container):
+        """Construct a test fixture with a single socket bridge configuration."""
+        super().setUp()
+
+        real_socket_address = launcher.translate_to_real_address(self._fake_session_socket)
+        with suppress(OSError):
+            os.remove(real_socket_address)
+
+        config = MagicMock(spec=launcher.Config,
+                           socket_bridges=[launcher.SocketBridge('FAKE_SOCKET',
+                                           host_address=EchoServer.socket_address,
+                                           session_address=self._fake_session_socket)],
+                           container_id=None)
+        self._session = launcher.Session(config, mock_container)
+
+    def test_abstract_socket_is_used(self):
+        bogus_abstract_path = '/tmp/dbus-host-socket'
+        bogus_host_address = 'unix:abstract=' + bogus_abstract_path
+
+        bogus_host_socket = launcher.translate_to_real_address(bogus_host_address)
+
+        self.assertThat(bogus_host_socket, Equals('\0' + bogus_abstract_path))
+
+    def test_connection_acceptance(self):
+        """Verify that when at attempt is made to connect to a session bridge it is accepted.
+
+        This test has to perform some ear-wiggling and hop-dart behaviour to
+        make sure it waits until the event loop has called the accept() method
+        before it tries to check to see if the accept() method has been called
+        (hence the thread barrier).  Also, because the real socket accept
+        operation does not get performed, the mock accept() call can be
+        executed several times by the server before we get around to actually
+        checking up on it and we only care that it's called at least once, hence
+        the 'called_once' flag.
+        """
+        barrier = Barrier(2, timeout=0.5)
+        called_once = False
+        real_session_address = launcher.translate_to_real_address(self._fake_session_socket)
+
+        def fake_accept(*args, called_once=called_once):
+            if not called_once:
+                called_once = True
+                barrier.wait()
+            sock = socket(AF_UNIX, SOCK_STREAM)
+            return (sock, 'xyzzy')
+
+        with patch('libertine.launcher.session.socket.accept', side_effect=fake_accept) as mock_accept:
+            with SessionEventLoopRunning(self._session):
+                sock = socket(AF_UNIX, SOCK_STREAM)
+                sock.connect(real_session_address)
+                with suppress(BrokenBarrierError):
+                    barrier.wait()
+            self.assertThat(mock_accept.called, Equals(True), "accept() not called")
+
+    def test_bridge_socket_relay(self):
+        """Test that the whole socket bridge relay functionality works.
+
+        Sure, this is not really a unit test but a black-box functional test.
+        """
+        echo_server = EchoServer()
+        real_session_address = launcher.translate_to_real_address(self._fake_session_socket)
+
+        with SessionEventLoopRunning(self._session):
+            sock = socket(AF_UNIX, SOCK_STREAM)
+            sock.connect(real_session_address)
+            sock.sendall(bytes('ping', 'ascii'))
+            response = str(sock.recv(1024), 'ascii')
+            self.assertThat(response, Contains('ping'))
+
+
+class TestLauncherSessionTask(TestLauncher):
+    """Verify how a Session handles Tasks."""
+
+    @patch('test_launcher.LibertineContainer')
+    def setUp(self, mock_container):
+        super().setUp()
+
+        # Monkey-patch the task object created by the LaunchServiceTask class.
+        # This is a little awkward by it's the way Python works.
+        p = patch('libertine.launcher.session.LaunchServiceTask')
+        mock_service_task_class = p.start()
+        self._mock_service_task = mock_service_task_class.return_value
+        self._mock_service_task.wait = MagicMock(return_value=True)
+        self.addCleanup(p.stop)
+
+        fake_datum = [self.getUniqueString()]
+        task = launcher.TaskConfig(launcher.TaskType.LAUNCH_SERVICE, fake_datum)
+
+        config = MagicMock(spec=launcher.Config,
+                           socket_bridges=[],
+                           prelaunch_tasks=[task],
+                           host_environ={},
+                           container_id=None)
+        self._session = launcher.Session(config, mock_container)
+
+    def test_session_starts_prelaunch_task(self):
+        """Test that a session starts a pre-launch task."""
+        self.assertThat(self._mock_service_task.start.called,
+                        Equals(True),
+                        message="task.start() not called")
+
+    def test_session_stops_prelaunch_task(self):
+        """Test that a session starts a pre-launch task."""
+        with SessionEventLoopRunning(self._session) as event_loop:
+            event_loop.stop()
+        self.assertThat(self._mock_service_task.stop.called, Equals(True))
+
+    def test_session_handles_dying_prelaunch_task(self):
+        """Test that a session starts a pre-launch task."""
+        with SessionEventLoopRunning(self._session) as event_loop:
+            os.kill(os.getpid(), signal.SIGCHLD)
+            event_loop.stop()
+        self.assertThat(self._mock_service_task.wait.called, Equals(True))
+
+
+class TestLauncherContainerBehavior(TestLauncher):
+    """Verify some expected behaviour when it comes to running the contained application."""
+
+    def setUp(self):
+        super().setUp()
+
+        self._mock_config = MagicMock(spec=launcher.Config,
+                                      socket_bridges=[],
+                                      session_environ={},
+                                      container_id=None)
+
+        # Need to fake the ContainersConfig used internally by
+        # LibertineContainer...  that whole outfit needs to be refactored for
+        # better testing next.
+        mock_containers_config = MagicMock()
+        mock_containers_config.get_container_type = MagicMock(return_value='mock')
+
+        self._container_proxy = LibertineContainer(container_id='xyzzy',
+                                                   containers_config=mock_containers_config)
+
+        libertine_mock_patcher = patch.object(self._container_proxy, "container", autospec=True)
+        self._mock_container = libertine_mock_patcher.start()
+        self.addCleanup(libertine_mock_patcher.stop)
+
+    def test_start_application(self):
+        """Test the start_application() function of the session API."""
+        self._mock_config.exec_line = ["/bin/echo", "sis", "boom", "bah"]
+
+        with launcher.Session(self._mock_config, self._container_proxy) as session:
+            with SessionEventLoopRunning(session):
+                session.start_application()
+
+        #self.assertThat(self._mock_container.connect.called, Equals(True))
+        #self.assertThat(self._mock_container.disconnect.called, Equals(True))
+        self.assertThat(self._mock_container.start_application.called, Equals(True))
+        self.assertThat(self._mock_container.start_application.call_args[0][0],
+                        Equals(self._mock_config.exec_line))
+        self.assertThat(self._mock_container.finish_application.called, Equals(True))
+
+    def test_environment_gets_set(self):
+        """Verify that the configured variables are set in the contained execution environments."""
+        fake_value = _generate_unique_string()
+        fake_var = _generate_unique_string(prefix='V')
+        self._mock_config.session_environ[fake_var] = fake_value
+        self._mock_config.exec_line = ["/dev/null"]
+
+        with launcher.Session(self._mock_config, self._container_proxy) as session:
+            with SessionEventLoopRunning(session):
+                session.start_application()
+
+        self.assertThat(self._mock_container.start_application.call_args[0][1], Contains(fake_var))

=== added file 'tests/unit/test_launcher_with_dbus.py'
--- tests/unit/test_launcher_with_dbus.py	1970-01-01 00:00:00 +0000
+++ tests/unit/test_launcher_with_dbus.py	2016-11-21 19:42:42 +0000
@@ -0,0 +1,103 @@
+# Copyright 2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import dbus
+import dbusmock
+import os
+import subprocess
+
+from libertine import launcher
+
+from testtools import TestCase
+from testtools.matchers import Equals, Contains
+from unittest.mock import patch
+
+
+
+class MockDBusServer(object):
+    """
+    A mock object that proxies a mock D-Bus server, for testing things that do
+    D-Bus operations in the background.
+    """
+
+    def __init__(self, maliit_server_address):
+        dbusmock.DBusTestCase.start_session_bus()
+        self.maliit_server_address = maliit_server_address
+        self._dbus_connection = dbusmock.DBusTestCase.get_dbus(system_bus=False)
+
+    def setUp(self):
+        self._dbus_mock_server = dbusmock.DBusTestCase.spawn_server(
+                'org.maliit.server',
+                '/org/maliit/server/address',
+                'org.maliit.Server.Address',
+                system_bus=False,
+                stdout=subprocess.PIPE)
+        self._mock_interface = self._get_mock_interface()
+        self._mock_interface.AddProperty('', 'address', self.maliit_server_address)
+
+    def cleanUp(self):
+        self._dbus_mock_server.terminate()
+        self._dbus_mock_server.wait()
+
+    def getDetails(self):
+        return { }
+
+    def _get_mock_interface(self):
+        return dbus.Interface(
+                self._dbus_connection.get_object(
+                    'org.maliit.server',
+                    '/org/maliit/server/address',
+                    'org.maliit.Server.Address'),
+                dbusmock.MOCK_IFACE)
+
+
+class TestLauncherConfigUsingDBus(TestCase):
+    """
+    Verifies the defined behaviour of the Libertine Launcher Config class with
+    reference to a D-Bus server.
+    """
+    def setUp(self):
+        """
+        Need to save and restore the os.environ for each test in case they
+        change things.  That's a global that propagates between tests.
+        """
+        super().setUp()
+        fake_maliit_host_address = 'unix:abstract=/tmp/maliit-host-socket'
+        self._dbus_server = self.useFixture(MockDBusServer(maliit_server_address=fake_maliit_host_address))
+        self._cli = [ '-i', self.getUniqueString(), self.getUniqueString() ]
+
+    def test_maliit_socket_bridge_from_dbus(self):
+        """
+        Make sure the Maliit socket bridge gets configured.
+
+        The Maliit service advertizes it's socket on the D-Bus, although the
+        environment variable, if present, overrides that so to test the D-Bus
+        advert the environment variable must be clear.
+        """
+        maliit_bridge = None
+        with patch.dict('os.environ'):
+            if 'MALIIT_SERVER_ADDRESS' in os.environ:
+                del os.environ['MALIIT_SERVER_ADDRESS']
+
+            config = launcher.Config(self._cli[:])
+
+            for bridge in config.socket_bridges:
+                if bridge.env_var == 'MALIIT_SERVER_ADDRESS':
+                    maliit_bridge = bridge
+
+            self.assertIsNotNone(maliit_bridge)
+            self.assertThat(maliit_bridge.host_address, Equals(self._dbus_server.maliit_server_address))
+            self.assertThat(maliit_bridge.session_address, Contains('maliit'))
+            self.assertThat(maliit_bridge.session_address, Contains(config.id))
+

=== renamed file 'tests/unit/libertine_container_manager_tests.py' => 'tests/unit/test_libertine_container_manager.py'
=== added file 'tests/unit/test_libertine_gir.py'
--- tests/unit/test_libertine_gir.py	1970-01-01 00:00:00 +0000
+++ tests/unit/test_libertine_gir.py	2016-11-21 19:42:42 +0000
@@ -0,0 +1,67 @@
+# Copyright 2015 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+from testtools import TestCase
+from testtools.matchers import Equals
+from gi.repository import Libertine
+from unittest import skip
+from unittest.mock import patch
+
+
+class TestLibertineGir(TestCase):
+
+    def setUp(self):
+        super(TestLibertineGir, self).setUp()
+        self.cmake_source_dir = os.environ['LIBERTINE_DATA_DIR']
+
+    def test_list_containers(self):
+        with patch.dict('os.environ', {'XDG_DATA_HOME': self.cmake_source_dir + '/libertine-config'}):
+            containers = Libertine.list_containers()
+
+            self.assertThat(containers[0], Equals('wily'))
+            self.assertThat(containers[1], Equals('wily-2'))
+
+    @skip("need to work around cached globals in glib")
+    def test_container_path(self):
+        container_id = 'wily'
+        with patch.dict('os.environ', {'XDG_CACHE_HOME': self.cmake_source_dir + '/libertine-data'}):
+            container_path = Libertine.container_path(container_id)
+
+            self.assertThat(container_path, Equals(self.cmake_source_dir + '/libertine-data/libertine-container/wily/rootfs'))
+
+    def test_container_home_path(self):
+        container_id = 'wily'
+        with patch.dict('os.environ', {'XDG_DATA_HOME': self.cmake_source_dir + '/libertine-home'}):
+            container_home_path = Libertine.container_home_path(container_id)
+
+            self.assertThat(container_home_path, Equals(self.cmake_source_dir + '/libertine-home/libertine-container/user-data/wily'))
+
+    def test_container_name(self):
+        container_id = 'wily'
+        with patch.dict('os.environ', {'XDG_DATA_HOME': self.cmake_source_dir + '/libertine-config'}):
+            container_name = Libertine.container_name(container_id)
+
+            self.assertThat(container_name, Equals("Ubuntu 'Wily Werewolf'"))
+
+            container_id = 'wily-2'
+            container_name = Libertine.container_name(container_id)
+
+            self.assertThat(container_name, Equals("Ubuntu 'Wily Werewolf' (2)"))
+
+    def test_list_apps_for_container(self):
+        with patch.dict('os.environ', {'XDG_DATA_HOME': self.cmake_source_dir + '/libertine-config'}):
+            apps = Libertine.list_apps_for_container('wily')
+
+            self.assertThat(len(apps), Equals(0))

=== renamed file 'tests/unit/libertine_logger_tests.py' => 'tests/unit/test_logger.py'
--- tests/unit/libertine_logger_tests.py	2016-08-09 23:34:22 +0000
+++ tests/unit/test_logger.py	2016-11-21 19:42:42 +0000
@@ -12,38 +12,34 @@
 # 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 logging
 import os
-import shutil
 
 import libertine.utils
 
 from testtools import TestCase
 from testtools.matchers import Equals, NotEquals
+from unittest.mock import patch
+
 
 class TestLogger(TestCase):
-    def setUp(self):
-        super(TestLogger, self).setUp()
-        os.environ['LIBERTINE_DEBUG'] = '1'
-        self.addCleanup(self.cleanup)
-
-    def cleanup(self):
-        if os.getenv('LIBERTINE_DEBUG', None) is not None:
-            del os.environ['LIBERTINE_DEBUG']
 
     def test_logger_off_by_default(self):
-        # Need to turn off for this test only!
-        self.cleanup()
-        os.unsetenv('LIBERTINE_DEBUG')
-        l = libertine.utils.get_logger()
-        self.assertTrue(l.disabled)
+        with patch.dict('os.environ'):
+            if 'LIBERTINE_DEBUG' in os.environ:
+                del os.environ['LIBERTINE_DEBUG']
+            l = libertine.utils.get_logger()
+            self.assertThat(l.getEffectiveLevel(), Equals(logging.WARNING))
 
     def test_logger_on_with_env_var(self):
-        l = libertine.utils.get_logger()
-        self.assertFalse(l.disabled)
+        with patch.dict('os.environ', {'LIBERTINE_DEBUG': '1'}):
+            l = libertine.utils.get_logger()
+            self.assertThat(l.getEffectiveLevel(), Equals(logging.DEBUG))
 
     def test_logger_only_inits_once(self):
-        l1 = libertine.utils.get_logger()
-        l2 = libertine.utils.get_logger()
-        l3 = libertine.utils.get_logger()
-        self.assertThat(len(l3.handlers), Equals(1))
+        with patch.dict('os.environ', {'LIBERTINE_DEBUG': '1'}):
+            l1 = libertine.utils.get_logger()
+            l2 = libertine.utils.get_logger()
+            l3 = libertine.utils.get_logger()
+            self.assertThat(len(l3.handlers), Equals(1))
 

=== modified file 'tools/libertine-container-manager'
--- tools/libertine-container-manager	2016-10-03 15:38:18 +0000
+++ tools/libertine-container-manager	2016-11-21 19:42:42 +0000
@@ -239,6 +239,10 @@
             self.containers_config.update_container_multiarch_support(container_id, multiarch)
 
         elif args.archive is not None:
+            if args.archive_name is None:
+                print("Configure archive called with no archive name. See configure --help for usage.")
+                sys.exit(1)
+
             archive_name = args.archive_name.strip("\'\"")
             archive_name_esc = "\"" + archive_name + "\""
 

=== modified file 'tools/libertine-launch'
--- tools/libertine-launch	2016-10-03 19:51:28 +0000
+++ tools/libertine-launch	2016-11-21 19:42:42 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/python3
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2015 Canonical Ltd.
+# Copyright (C) 2015-2016 Canonical Ltd.
 # Author: Christopher Townsend <[e-mail]>
 
 # This program is free software: you can redistribute it and/or modify
@@ -16,144 +16,25 @@
 # 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 random
-import string
-import libertine.utils
-import shlex
-import time
-from libertine import LibertineApplication, HostSessionSocketPair
-
-
-def get_host_maliit_socket():
-    address_bus_name    = 'org.maliit.server'
-    address_object_path = '/org/maliit/server/address'
-    address_interface   = 'org.maliit.Server.Address'
-    address_property    = 'address'
-    address             = ''
-
-    try:
-        session_bus   = dbus.SessionBus()
-        maliit_object = session_bus.get_object('org.maliit.server', '/org/maliit/server/address')