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

[Christopher Townsend]

* Drop support for the Puritine click package as that is Vivid only and a Vivid Libertine branch exists for any future fixes.
* Only set the lxc log when a container is defined during class init. (LP: #1653973)
* Bump version to 1.5 for new upstream release.
* Logic for bundling libertine as a snap built from source.
* Catch exceptions raised during container creation.
* Initial implementation of lxd backend. (LP: #1580612)
* Use the libertine logger and LIBERTINE_DEBUG variable everywhere.
* Update configure bind-mount logic given new lxd backend.
* Use dpkg to find package name when installing local deb.
* Create d-bus service for lxd container management.

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

181. By Christopher Townsend on 2017-01-05

Update the version for the snap package as well.

182. By Larry Price on 2017-01-05

Merge from lp:libertine for fixes during testing and review.

[Larry Price (larryprice)]

okok let's do this

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2016-10-25 17:27:50 +0000
+++ .bzrignore	2017-01-05 20:19:05 +0000
@@ -2,3 +2,11 @@
 po/Makefile.in.in
 __pycache__
 tests/unit/.cache
+*.click-hook
+
+prime/
+stage/
+*.snap
+parts/*
+!parts/plugins
+parts/plugins/__pycache__
 
=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-11-03 18:28:54 +0000
+++ CMakeLists.txt	2017-01-05 20:19:05 +0000
@@ -2,7 +2,7 @@
 cmake_policy(SET CMP0048 NEW)
 
 project(libertine
-        VERSION 1.4.3)
+        VERSION 1.5)
 
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}")
 
 
=== modified file 'common/ContainerConfigList.h'
--- common/ContainerConfigList.h	2016-09-26 18:17:07 +0000
+++ common/ContainerConfigList.h	2017-01-05 20:19:05 +0000
@@ -55,11 +55,10 @@
    * Display roles for a container config.
    */
   enum class DataRole
-  : int
   {
     ContainerId = Qt::UserRole + 1,   /**< The container ID */
     ContainerName,                    /**< The container name */
-    ContainerType,                    /**< The type of container - lxc or chroot */
+    ContainerType,                    /**< The type of container */
     DistroSeries,                     /**< The distro from which the container was built */
     InstallStatus,                    /**< Current container install status */
     Error                             /**< last role (error) */
 
=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2016-11-01 20:10:58 +0000
+++ data/CMakeLists.txt	2017-01-05 20:19:05 +0000
@@ -6,11 +6,9 @@
   DESTINATION ${CMAKE_INSTALL_DATADIR}/${CMAKE_PROJECT_NAME})
 install(FILES libertine-xmir.conf
         DESTINATION ${CMAKE_INSTALL_DATADIR}/upstart/sessions)
-install(FILES libertine-lxc-sudo
+install(FILES libertine-lxc-sudo libertine-lxd-sudo
         DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/sudoers.d)
-install(FILES com.canonical.libertine.LxcManager.service com.canonical.libertine.ContainerManager.service
+install(FILES com.canonical.libertine.ContainerManager.service
+              com.canonical.libertine.LxcManager.service
+              com.canonical.libertine.LxdManager.service
         DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services)
-
-configure_file("python3-libertine-chroot.click-hook.in"
-  "${CMAKE_SOURCE_DIR}/debian/python3-libertine-chroot.click-hook"
-  @ONLY)
 
=== added file 'data/com.canonical.libertine.LxdManager.service'
--- data/com.canonical.libertine.LxdManager.service	1970-01-01 00:00:00 +0000
+++ data/com.canonical.libertine.LxdManager.service	2017-01-05 20:19:05 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=com.canonical.libertine.LxdManager
+Exec=/usr/bin/libertine-lxd-manager
 
=== added file 'data/libertine-lxd-sudo'
--- data/libertine-lxd-sudo	1970-01-01 00:00:00 +0000
+++ data/libertine-lxd-sudo	2017-01-05 20:19:05 +0000
@@ -0,0 +1,1 @@
+ALL ALL=(ALL) NOPASSWD:/usr/bin/libertine-lxd-setup
 
=== removed file 'data/python3-libertine-chroot.click-hook.in'
--- data/python3-libertine-chroot.click-hook.in	2016-09-06 12:36:47 +0000
+++ data/python3-libertine-chroot.click-hook.in	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-Pattern: ${home}/.cache/libertine/puritine/${id}
-Exec: @CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@/libertine/update-puritine-containers
-User-Level: yes
-Hook-Name: puritine
 
=== added file 'data/snap-runner.wrapper'
--- data/snap-runner.wrapper	1970-01-01 00:00:00 +0000
+++ data/snap-runner.wrapper	2017-01-05 20:19:05 +0000
@@ -0,0 +1,11 @@
+#!/bin/bash
+# additional env modifications on top of desktop-launch
+
+export LD_LIBRARY_PATH=$SNAP/usr/lib/$ARCH/fakechroot:$LD_LIBRARY_PATH
+export DEBOOTSTRAP_DIR=$SNAP/usr/share/debootstrap
+
+# Useful debug variables
+# export FAKECHROOT_DEBUG=1
+# export LIBERTINE_DEBUG=1
+
+exec $SNAP/bin/desktop-launch $@
 
=== modified file 'debian/changelog'
--- debian/changelog	2016-12-05 21:10:03 +0000
+++ debian/changelog	2017-01-05 20:19:05 +0000
@@ -1,3 +1,23 @@
+libertine (1.5-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Chris Townsend ]
+  * Drop support for the Puritine click package as that is Vivid only
+    and a Vivid Libertine branch exists for any future fixes.
+  * Only set the lxc log when a container is defined during class init.
+    (LP: #1653973)
+  * Bump version to 1.5 for new upstream release.
+
+  [ Larry Price ]
+  * Logic for bundling libertine as a snap built from source.
+  * Catch exceptions raised during container creation.
+  * Initial implementation of lxd backend. (LP: #1580612)
+  * Use the libertine logger and LIBERTINE_DEBUG variable everywhere.
+  * Update configure bind-mount logic given new lxd backend.
+  * Use dpkg to find package name when installing local deb.
+  * Create d-bus service for lxd container management.
+
+ -- Chris Townsend <[e-mail]>  Thu, 05 Jan 2017 11:46:42 -0500
+
 libertine (1.4.4+17.04.20161205-0ubuntu1) zesty; urgency=medium
 
   [ Chris Townsend ]
 
=== modified file 'debian/control'
--- debian/control	2016-11-22 17:47:05 +0000
+++ debian/control	2017-01-05 20:19:05 +0000
@@ -2,8 +2,7 @@
 Section: utils
 Priority: extra
 Maintainer: Ubuntu Developers <[e-mail]>
-Build-Depends: click-dev,
-               cmake,
+Build-Depends: cmake,
                cmake-extras,
                debhelper (>= 9),
                dh-translations,
@@ -61,8 +60,7 @@
 Depends: libertine-qt-common,
          libertine-tools,
          python3-libertine-lxc,
-         qml-module-qtquick2,
-         qtdeclarative5-ubuntu-ui-toolkit-plugin,
+         libsystemsettings1,
          ${misc:Depends},
          ${shlibs:Depends}
 Enhances: ubuntu-system-settings
@@ -184,6 +182,21 @@
  Libertine sandbox.  It requires support for unprivileged LXC containers in the
  Linux kernel.
 
+Package: python3-libertine-lxd
+Architecture: any
+Section: python
+Multi-Arch: allowed
+Depends: lxd,
+         python3-libertine,
+         python3-pexpect,
+         python3-pylxd,
+         ${misc:Depends},
+         ${python3:Depends}
+Description: Python3 scripts for the Libertine application sandbox
+ This package provides the LXD-based container back end module for the
+ Libertine sandbox.  It requires support for unprivileged LXD containers in the
+ Linux kernel.
+
 Package: python3-libertine-chroot
 Architecture: any
 Section: python
 
=== modified file 'debian/python3-libertine-chroot.install'
--- debian/python3-libertine-chroot.install	2016-10-07 21:09:41 +0000
+++ debian/python3-libertine-chroot.install	2017-01-05 20:19:05 +0000
@@ -1,2 +1,1 @@
-usr/lib/*/libertine/update-puritine-containers
 usr/lib/python*/*/libertine/ChrootContainer.py
 
=== added file 'debian/python3-libertine-lxd.install'
--- debian/python3-libertine-lxd.install	1970-01-01 00:00:00 +0000
+++ debian/python3-libertine-lxd.install	2017-01-05 20:19:05 +0000
@@ -0,0 +1,5 @@
+etc/sudoers.d/libertine-lxd-sudo
+usr/bin/libertine-lxd-setup
+usr/bin/libertine-lxd-manager
+usr/lib/python*/*/libertine/LxdContainer.py
+usr/share/dbus-1/services/com.canonical.libertine.LxdManager.service
 
=== modified file 'debian/python3-libertine.install'
--- debian/python3-libertine.install	2016-10-28 19:37:32 +0000
+++ debian/python3-libertine.install	2017-01-05 20:19:05 +0000
@@ -4,5 +4,6 @@
 usr/lib/python*/*/libertine/Libertine.py
 usr/lib/python*/*/libertine/__init__.py
 usr/lib/python*/*/libertine/launcher
+usr/lib/python*/*/libertine/lifecycle
 usr/lib/python*/*/libertine/service
 usr/lib/python*/*/libertine/utils.py
 
=== modified file 'debian/rules'
--- debian/rules	2016-12-05 15:32:46 +0000
+++ debian/rules	2017-01-05 20:19:05 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/make -f
 
 %:
-	dh $@ --with python3,gir,click
+	dh $@ --with python3,gir
 
 override_dh_auto_test:
 	dbus-run-session -- dh_auto_test
 
=== modified file 'liblibertine/libertine.cpp'
--- liblibertine/libertine.cpp	2016-10-26 13:58:19 +0000
+++ liblibertine/libertine.cpp	2017-01-05 20:19:05 +0000
@@ -67,8 +67,16 @@
   g_dir_close(dir);
   return nullptr;
 }
-}
-
+
+
+gchar*
+id_from_list_index(const ContainerConfigList& container_list, guint index)
+{
+  return (gchar*)container_list.data(container_list.index(index, 0),
+                                     (int)ContainerConfigList::DataRole::ContainerId)
+                               .toString().toStdString().c_str();
+}
+}
 
 gchar**
 libertine_list_apps_for_container(const gchar* container_id)
@@ -137,61 +145,68 @@
 gchar *
 libertine_container_path(const gchar * container_id)
 {
+  g_return_val_if_fail(container_id != nullptr, nullptr);
+  LibertineConfig config;
+  ContainerConfigList container_list(&config);
   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", nullptr);
+  if (g_strcmp0((gchar*)container_list.getContainerType(container_id).toStdString().c_str(), "lxd") == 0)
+  {
+    path = g_build_filename("/", "var", "lib", "lxd", "containers", container_id, "rootfs", nullptr);
+  }
+  else
+  {
+    path = g_build_filename(g_get_user_cache_dir(), "libertine-container", container_id, "rootfs", nullptr);
+  }
 
   if (g_file_test(path, G_FILE_TEST_EXISTS))
   {
     return path;
   }
-  else
-  {
-    g_free(path);
-    return nullptr;
-  }
+
+  g_free(path);
+  return nullptr;
 }
 
 
 gchar *
 libertine_container_home_path(const gchar * container_id)
 {
+  g_return_val_if_fail(container_id != nullptr, nullptr);
+  LibertineConfig config;
+  ContainerConfigList container_list(&config);
   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, nullptr);
+  if (g_strcmp0((gchar*)container_list.getContainerType(container_id).toStdString().c_str(), "lxd") == 0)
+  {
+    path = g_build_filename("/", "var", "lib", "lxd", "containers", container_id, "rootfs", "home", g_get_user_name(), nullptr);
+  }
+  else
+  {
+    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))
   {
     return path;
   }
-  else
-  {
-    g_free(path);
-    return nullptr;
-  }
 
+  g_free(path);
+  return nullptr;
 }
 
 
 gchar *
 libertine_container_name(const gchar * container_id)
 {
-  guint container_count;
-  guint i;
   gchar * container_name = nullptr;
   LibertineConfig config;
   ContainerConfigList container_list(&config);
-  QVariant id;
-
-  container_count = (guint)container_list.size();
-
-  for (i = 0; i < container_count; ++i)
+  guint container_count = (guint)container_list.size();
+
+  for (guint i = 0; i < container_count; ++i)
   {
-    id = container_list.data(container_list.index(i, 0), (int)ContainerConfigList::DataRole::ContainerId);
-
-    if (g_strcmp0((gchar *)id.toString().toStdString().c_str(), container_id) == 0)
+    if (g_strcmp0(id_from_list_index(container_list, i), container_id) == 0)
     {
       QVariant name = container_list.data(container_list.index(i, 0), (int)ContainerConfigList::DataRole::ContainerName);
       container_name = g_strdup(name.toString().toStdString().c_str());
 
=== added directory 'parts'
=== added directory 'parts/plugins'
=== added file 'parts/plugins/utils.py'
--- parts/plugins/utils.py	1970-01-01 00:00:00 +0000
+++ parts/plugins/utils.py	2017-01-05 20:19:05 +0000
@@ -0,0 +1,63 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*-
+#
+# 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 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 re
+from snapcraft import file_utils
+
+
+def fix_shebangs(path):
+    file_utils.replace_in_file(path, re.compile(r''),
+                               re.compile(r'^#!.*python'),
+                               r'#!/usr/bin/env python')
+
+
+def _sanitize(dep):
+    return re.sub(r"\(.*\)", "", re.sub(r"\[.*\]", "", dep)).replace(',', '').strip()
+
+
+class DependsParser(object):
+    def __init__(self):
+        self.keyword = 'Depends:'
+        self._parsing = False
+        self._deps = []
+        self._packages = []
+
+    @property
+    def deps(self):
+        return [dep for dep in self._deps if dep not in self._packages]
+
+    def parse(self, line):
+        if self._parsing:
+            if ':' in line:
+                if not line.strip().startswith('${'):
+                    self._parsing = False
+            else:
+                self._deps.append(_sanitize(line))
+
+        if line.startswith(self.keyword):
+            self._parsing = True
+            possible_dep = line.lstrip(self.keyword)
+            if not possible_dep.isspace() and not possible_dep.strip().startswith('${'):
+                self._deps.append(_sanitize(possible_dep))
+
+        if line.startswith('Package:'):
+            self._packages.append(line.lstrip('Package:').strip())
+
+
+class BuildDependsParser(DependsParser):
+    def __init__(self):
+        super().__init__()
+        self.keyword = 'Build-Depends:'
 
=== added file 'parts/plugins/x-libertine-deps.py'
--- parts/plugins/x-libertine-deps.py	1970-01-01 00:00:00 +0000
+++ parts/plugins/x-libertine-deps.py	2017-01-05 20:19:05 +0000
@@ -0,0 +1,155 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*-
+#
+# 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 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 fileinput
+import os
+import re
+import shlex
+import snapcraft.plugins.nil
+import sys
+import subprocess
+import utils # local
+
+
+def _arch():
+    cmd = subprocess.Popen(shlex.split('dpkg-architecture -qDEB_HOST_ARCH_CPU'), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    out, err = cmd.communicate()
+    arch = str(out, 'utf-8').strip()
+    if arch == 'amd64':
+        return 'x86_64-linux-gnu'
+    elif arch == 'armhf':
+        return 'arm-linux-gnueabihf'
+    elif arch == 'arm64':
+        return 'aarch64-linux-gnu'
+
+    return '{}-linux-gnu'.format(arch)
+
+
+class LibertineDependenciesPlugin(snapcraft.plugins.nil.NilPlugin):
+    def __init__(self, name, options, project):
+        super().__init__(name, options, project)
+        self._arch = _arch()
+
+        deps_parser = utils.DependsParser()
+        with open('debian/control') as control:
+            for line in control.readlines():
+                deps_parser.parse(line)
+        self.stage_packages.extend(deps_parser.deps)
+
+        self._ignore_duplicate_files()
+
+    @classmethod
+    def schema(cls):
+        return super().schema()
+
+    def enable_cross_compilation(self):
+        return super().enable_cross_compilation()
+
+    def env(self, root):
+        return super().env(root) + ['ARCH={}'.format(self._arch)]
+
+    # By design, snapcraft ignores all pre- and post-inst scripts which
+    # result in a bunch of packages that just don't work.
+    def _run_preinst_postinst(self):
+        # We need to create the lxc-usernet
+        if not os.path.exists(self.installdir + '/etc/lxc/lxc-usernet'):
+            with open(self.installdir + '/etc/lxc/lxc-usernet', 'w') as f:
+                f.write('# USERNAME TYPE BRIDGE COUNT')
+
+        # We need to run update-alternatives to create /usr/bin/fakeroot
+        admindir = self.installdir + '/var/lib/dpkg/alternatives'
+        altdir = self.installdir + '/etc/alternatives'
+        os.makedirs(admindir, exist_ok=True)
+        os.makedirs(altdir, exist_ok=True)
+        subprocess.Popen(shlex.split('\
+                update-alternatives --admindir {0} --altdir {1} --install \
+                    {2}/usr/bin/fakeroot fakeroot {2}/usr/bin/fakeroot-sysv 50 \
+        		--slave {2}/usr/share/man/man1/fakeroot.1.gz \
+        		fakeroot.1.gz {2}/usr/share/man/man1/fakeroot-sysv.1.gz \
+        		--slave {2}/usr/share/man/man1/faked.1.gz \
+        		faked.1.gz {2}/usr/share/man/man1/faked-sysv.1.gz \
+        		--slave {2}/usr/share/man/es/man1/fakeroot.1.gz \
+        		fakeroot.es.1.gz {2}/usr/share/man/es/man1/fakeroot-sysv.1.gz \
+        		--slave {2}/usr/share/man/es/man1/faked.1.gz \
+        		faked.es.1.gz {2}/usr/share/man/es/man1/faked-sysv.1.gz \
+        		--slave {2}/usr/share/man/fr/man1/fakeroot.1.gz \
+        		fakeroot.fr.1.gz {2}/usr/share/man/fr/man1/fakeroot-sysv.1.gz \
+        		--slave {2}/usr/share/man/fr/man1/faked.1.gz \
+        		faked.fr.1.gz {2}/usr/share/man/fr/man1/faked-sysv.1.gz \
+        		--slave {2}/usr/share/man/sv/man1/fakeroot.1.gz \
+        		fakeroot.sv.1.gz {2}/usr/share/man/sv/man1/fakeroot-sysv.1.gz \
+        		--slave {2}/usr/share/man/sv/man1/faked.1.gz \
+        		faked.sv.1.gz {2}/usr/share/man/sv/man1/faked-sysv.1.gz\
+                '.format(admindir, altdir, self.installdir))).wait()
+        subprocess.Popen(shlex.split('\
+                update-alternatives --admindir {0} --altdir {1} --install \
+                    {2}/usr/bin/fakeroot fakeroot {2}/usr/bin/fakeroot-tcp 30 \
+        		--slave {2}/usr/share/man/man1/fakeroot.1.gz \
+        		fakeroot.1.gz {2}/usr/share/man/man1/fakeroot-tcp.1.gz \
+        		--slave {2}/usr/share/man/man1/faked.1.gz \
+        		faked.1.gz {2}/usr/share/man/man1/faked-tcp.1.gz \
+        		--slave {2}/usr/share/man/es/man1/fakeroot.1.gz \
+        		fakeroot.es.1.gz {2}/usr/share/man/es/man1/fakeroot-tcp.1.gz \
+        		--slave {2}/usr/share/man/es/man1/faked.1.gz \
+        		faked.es.1.gz {2}/usr/share/man/es/man1/faked-tcp.1.gz \
+        		--slave {2}/usr/share/man/fr/man1/fakeroot.1.gz \
+        		fakeroot.fr.1.gz {2}/usr/share/man/fr/man1/fakeroot-tcp.1.gz \
+        		--slave {2}/usr/share/man/fr/man1/faked.1.gz \
+        		faked.fr.1.gz {2}/usr/share/man/fr/man1/faked-tcp.1.gz \
+        		--slave {2}/usr/share/man/sv/man1/fakeroot.1.gz \
+        		fakeroot.sv.1.gz {2}/usr/share/man/sv/man1/fakeroot-tcp.1.gz \
+        		--slave {2}/usr/share/man/sv/man1/faked.1.gz \
+        		faked.sv.1.gz {2}/usr/share/man/sv/man1/faked-tcp.1.gz\
+                '.format(admindir, altdir, self.installdir))).wait()
+
+    def _fix_symlinks(self):
+        for root, dirs, files in os.walk(self.installdir):
+            for f in files:
+                path = '{}/{}'.format(root, f)
+                if os.path.islink(path):
+                    link = os.readlink(path)
+                    if link.startswith('/'): # needs fixing
+                        os.remove(path)
+                        os.symlink(os.path.relpath(link, root), path)
+
+    def _fix_fakeroot(self):
+        for line in fileinput.FileInput('{}/usr/bin/fakeroot'.format(self.installdir), inplace=True):
+            if line.startswith('FAKEROOT_PREFIX='):
+                sys.stdout.write('FAKEROOT_PREFIX=${SNAP}/usr  # Updated by x-libertine.py\n')
+            elif line.startswith('FAKEROOT_BINDIR='):
+                sys.stdout.write('FAKEROOT_BINDIR=${SNAP}/usr/bin  # Updated by x-libertine.py\n')
+            elif line.startswith('PATHS='):
+                sys.stdout.write('PATHS=${FAKEROOT_PREFIX}/lib/%s/libfakeroot:' \
+                                 '${FAKEROOT_PREFIX}/lib64/libfakeroot:' \
+                                 '${FAKEROOT_PREFIX}/lib32/libfakeroot' \
+                                 '  # Updated by x-libertine.py\n' % self._arch)
+            else:
+                sys.stdout.write(line)
+
+    def _ignore_duplicate_files(self):
+        self.options.stage.extend([
+            '-usr/lib/{}/liblibertine.so*'.format(self._arch)
+        ])
+
+    def build(self):
+        super().build()
+
+        utils.fix_shebangs(self.installdir + '/usr/bin')
+
+        self._run_preinst_postinst()
+        self._fix_symlinks()
+        self._fix_fakeroot()
 
=== added file 'parts/plugins/x-libertine.py'
--- parts/plugins/x-libertine.py	1970-01-01 00:00:00 +0000
+++ parts/plugins/x-libertine.py	2017-01-05 20:19:05 +0000
@@ -0,0 +1,45 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*-
+#
+# 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 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 snapcraft.plugins.cmake
+import utils # local
+
+class LibertinePlugin(snapcraft.plugins.cmake.CMakePlugin):
+    def __init__(self, name, options, project):
+        super().__init__(name, options, project)
+
+        deps = utils.BuildDependsParser()
+
+        with open('debian/control') as control:
+            for line in control.readlines():
+                deps.parse(line)
+
+        self.build_packages.extend(deps.deps)
+        self.options.configflags.extend(['-DCMAKE_INSTALL_PREFIX=/usr'])
+
+    @classmethod
+    def schema(cls):
+        return super().schema()
+
+    def enable_cross_compilation(self):
+        return super().enable_cross_compilation()
+
+    def build(self):
+        super().build()
+
+        # Fix all shebangs to use the in-snap python.
+        utils.fix_shebangs(self.installdir + '/usr/bin')
 
=== modified file 'python/CMakeLists.txt'
--- python/CMakeLists.txt	2015-07-20 15:00:27 +0000
+++ python/CMakeLists.txt	2017-01-05 20:19:05 +0000
@@ -1,4 +1,4 @@
-execute_process(COMMAND python3 -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())"
+execute_process(COMMAND /usr/bin/python3 -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())"
                 OUTPUT_VARIABLE python_site_packages
                 OUTPUT_STRIP_TRAILING_WHITESPACE)
 
 
=== modified file 'python/libertine/AppDiscovery.py'
--- python/libertine/AppDiscovery.py	2016-01-04 17:41:08 +0000
+++ python/libertine/AppDiscovery.py	2017-01-05 20:19:05 +0000
@@ -188,7 +188,7 @@
             if desktop_file_is_showable(desktop_entry):
                     yield AppInfo(desktop_file_name, desktop_entry, icon_cache)
         except Exception as ex:
-            print("error processing {}: {}".format(desktop_file_name, ex), file=sys.stderr)
+            utils.get_logger().error("error processing {}: {}".format(desktop_file_name, ex))
 
 
 class AppLauncherCache(object):
@@ -218,5 +218,3 @@
                           default=lambda o: o.__dict__,
                           sort_keys=True,
                           indent=4)
-
-
 
=== modified file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	2016-12-02 17:46:47 +0000
+++ python/libertine/ChrootContainer.py	2017-01-05 20:19:05 +0000
@@ -71,10 +71,10 @@
             shutil.rmtree(container_root)
             return True
         except Exception as e:
-            print("%s" % e)
+            utils.get_logger().error("%s" % e)
             return False
 
-    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
+    def create_libertine_container(self, password=None, multiarch=False):
         # Create the actual chroot
         command_line = "{} fakeroot debootstrap --verbose --variant=fakechroot {} {}".format(
                     self._build_fakechroot_command(), self.installed_release, self.root_path)
@@ -83,12 +83,12 @@
         cmd.wait()
 
         if cmd.returncode != 0:
-            print("Failed to create container")
+            utils.get_logger().error("Failed to create container")
             self.destroy_libertine_container()
             return False
 
         # Remove symlinks as they can cause ill-behaved recursive behavior in the chroot
-        print("Fixing chroot symlinks...")
+        utils.get_logger().info("Fixing chroot symlinks...")
         os.remove(os.path.join(self.root_path, 'dev'))
         os.remove(os.path.join(self.root_path, 'proc'))
 
@@ -109,8 +109,8 @@
         else:
             archive = "deb http://archive.ubuntu.com/ubuntu "
 
-        if verbosity == 1:
-            print("Updating chroot's sources.list entries...")
+        utils.get_logger().info("Updating chroot's sources.list entries...")
+
         with open(os.path.join(self.root_path, 'etc', 'apt', 'sources.list'), 'a') as fd:
             fd.write(archive + self.installed_release + "-updates main\n")
             fd.write(archive + self.installed_release + " universe\n")
@@ -121,46 +121,43 @@
         utils.create_libertine_user_data_dir(self.container_id)
 
         if multiarch and self.architecture == 'amd64':
-            if verbosity == 1:
-                print("Adding i386 multiarch support...")
+            utils.get_logger().info("Adding i386 multiarch support...")
             self.run_in_container("dpkg --add-architecture i386")
 
-        if verbosity == 1:
-            print("Updating the contents of the container after creation...")
-        self.update_packages(verbosity)
+        utils.get_logger().info("Updating the contents of the container after creation...")
+        self.update_packages()
 
         for package in self.default_packages:
-            if not self.install_package(package, verbosity, update_cache=False):
-                print("Failure installing %s during container creation" % package)
+            if not self.install_package(package, update_cache=False):
+                utils.get_logger().error("Failure installing %s during container creation" % package)
                 self.destroy_libertine_container()
                 return False
 
         if self.installed_release == "vivid" or self.installed_release == "xenial":
-            if verbosity == 1:
-                print("Installing the Stable Overlay PPA...")
-            if not self.install_package("software-properties-common", verbosity, update_cache=False):
-                print("Failure installing software-properties-common during container creation")
+            utils.get_logger().info("Installing the Stable Overlay PPA...")
+            if not self.install_package("software-properties-common", update_cache=False):
+                utils.get_logger().error("Failure installing software-properties-common during container creation")
                 self.destroy_libertine_container()
                 return False
 
             self.run_in_container("add-apt-repository ppa:ci-train-ppa-service/stable-phone-overlay -y")
-            self.update_packages(verbosity)
+            self.update_packages()
 
         # Check if the container was created as root and chown the user directories as necessary
         chown_recursive_dirs(utils.get_libertine_container_userdata_dir_path(self.container_id))
 
         return True
 
-    def update_packages(self, verbosity=1):
-        retcode = super().update_packages(verbosity)
-        self._run_ldconfig(verbosity)
+    def update_packages(self):
+        retcode = super().update_packages()
+        self._run_ldconfig()
         return retcode == 0
 
-    def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
-        returncode = super().install_package(package_name, verbosity, no_dialog, update_cache)
+    def install_package(self, package_name, no_dialog=False, update_cache=True):
+        returncode = super().install_package(package_name, no_dialog, update_cache)
 
         if returncode:
-            self._run_ldconfig(verbosity)
+            self._run_ldconfig()
 
         return returncode
 
@@ -197,8 +194,12 @@
         mounts = self._sanitize_bind_mounts(utils.get_common_xdg_user_directories() + \
                                             ContainersConfig().get_container_bind_mounts(self.container_id))
         for user_dir in utils.generate_binding_directories(mounts, home_path):
-            user_dir_path = os.path.join(home_path, user_dir[1])
-            bind_mounts += " -b \"%s:%s\"" % (user_dir[0], user_dir_path)
+            if os.path.isabs(user_dir[1]):
+                path = user_dir[1]
+            else:
+                path = os.path.join(home_path, user_dir[1])
+
+            bind_mounts += " -b \"%s:%s\"" % (user_dir[0], path)
 
         proot_cmd += bind_mounts
 
@@ -233,16 +234,14 @@
 
         args = shlex.split(proot_cmd)
         args.extend(app_exec_line)
-        app = psutil.Popen(args, env=environ)
-        return app
+        return psutil.Popen(args, env=environ)
 
     def finish_application(self, app):
         utils.terminate_window_manager(self._window_manager)
         app.wait()
 
-    def _run_ldconfig(self, verbosity=1):
-        if verbosity == 1:
-            print("Refreshing the container's dynamic linker run-time bindings...")
+    def _run_ldconfig(self):
+        utils.get_logger().info("Refreshing the container's dynamic linker run-time bindings...")
 
         command_line = self._build_privileged_proot_cmd() + " ldconfig.REAL"
 
 
=== modified file 'python/libertine/ContainersConfig.py'
--- python/libertine/ContainersConfig.py	2016-11-16 17:58:38 +0000
+++ python/libertine/ContainersConfig.py	2017-01-05 20:19:05 +0000
@@ -214,12 +214,12 @@
 
     def check_container_id(self, container_id):
         if container_id and not self.container_exists(container_id):
-            print("Container id \'%s\' does not exist." % container_id, file=sys.stderr)
+            libertine.utils.get_logger().error("Container id \'%s\' does not exist." % container_id)
             sys.exit(1)
         elif not container_id:
             container_id = self.get_default_container_id()
             if container_id is None:
-                print("No default container available.")
+                libertine.utils.get_logger().error("No default container available.")
                 sys.exit(1)
 
         return container_id
@@ -260,7 +260,7 @@
 
     def delete_container(self, container_id):
         if not self.container_list:
-            print("Unable to delete container.  No containers defined.")
+            libertine.utils.get_logger().error("Unable to delete container.  No containers defined.")
             sys.exit(1)
 
         container = self._get_container_entry(container_id)
 
=== modified file 'python/libertine/HostInfo.py'
--- python/libertine/HostInfo.py	2016-10-28 18:11:12 +0000
+++ python/libertine/HostInfo.py	2017-01-05 20:19:05 +0000
@@ -13,6 +13,7 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import lsb_release
+import os
 import platform
 import subprocess
 
@@ -69,3 +70,7 @@
             parser.error("Failed to determine the local architecture.")
 
         return dpkg.stdout.read().strip()
+
+    def get_host_timezone(self):
+        with open(os.path.join('/', 'etc', 'timezone'), 'r') as fd:
+            return fd.read().strip('\n')
 
=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2016-11-16 17:58:38 +0000
+++ python/libertine/Libertine.py	2017-01-05 20:19:05 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015-2106 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
@@ -20,31 +20,32 @@
 import os
 import shutil
 
+from . import utils
 from libertine.ContainersConfig import ContainersConfig
 from libertine.HostInfo import HostInfo
 
 
-def apt_args_for_verbosity_level(verbosity):
-    """
-    Maps numeric verbosity levels onto APT command-line arguments.
-
-    :param verbosity: 0 is quiet, 1 is normal, 2 is incontinent
-    """
-    return {
-            0: '--quiet=2',
-            1: '--assume-yes',
-            2: '--quiet=1 --assume-yes --option APT::Status-Fd=1'
-    }.get(verbosity, '')
-
-
-def apt_command_prefix(verbosity):
-    return '/usr/bin/apt-get ' + apt_args_for_verbosity_level(verbosity) + \
+def _apt_args_for_verbosity_level():
+    """
+    Maps debug levels to APT command-line arguments.
+    """
+    if 'LIBERTINE_DEBUG' not in os.environ or os.environ['LIBERTINE_DEBUG'] == '0':
+        return '--quiet=2'
+
+    if os.environ['LIBERTINE_DEBUG'] == '1':
+        return '--quiet=1 --assume-yes'
+
+    return '--assume-yes --option APT::Status-Fd=1'
+
+
+def _apt_command_prefix():
+    return '/usr/bin/apt-get ' + _apt_args_for_verbosity_level() + \
            ' --option Apt::Cmd::Disable-Script-Warning=true --option Dpkg::Progress-Fancy=1' + \
            ' --option Apt::Color=1 '
 
 
 def handle_runtime_error(error):
-    print("%s" % error)
+    utils.get_logger().error("%s" % error)
     return False
 
 
@@ -92,41 +93,33 @@
                                  'maliit-inputcontext-gtk3',
                                  'maliit-framework']
 
-    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
-        pass
-
-    def destroy_libertine_container(self, verbosity=1):
-        pass
-
-    def copy_package_to_container(self, package_path):
-        """
-        Copies a Debian package from the host to a pre-determined place
-        in a container.
-
-        :param package_path: The full path to the Debian package located
-                             on the host.
-        """
-        if os.path.exists(os.path.join(self.root_path, 'tmp', package_path.split('/')[-1])):
+    def create_libertine_container(self, password=None, multiarch=False):
+        pass
+
+    def destroy_libertine_container(self):
+        pass
+
+    def copy_file_to_container(self, source, dest):
+        """
+        Copies a file from the host to the given path in the container.
+
+        :param source: The full path to the file on the host.
+        :param   dest: The relative path to the file in the container without
+                       the root path.
+        """
+        if os.path.exists(os.path.join(self.root_path, dest)):
             return False
 
-        shutil.copy2(package_path, os.path.join(self.root_path, 'tmp'))
+        shutil.copy2(source, os.path.join(self.root_path, dest.lstrip('/')))
         return True
 
-    def delete_package_in_container(self, package_path):
-        """
-        Deletes a previously copied in Debian package in a container.
-
-        :param package_path: The full path to the Debian package located
-                             on the host.
-        """
-        os.remove(os.path.join(self.root_path, 'tmp', package_path.split('/')[-1]))
-
-    def is_running(self):
-        """
-        Indicates if the container is 'running'. The definition of 'running'
-        depends on the type of the container.
-        """
-        return False
+    def delete_file_in_container(self, path):
+        """
+        Deletes a file within the container.
+
+        :param path: The path to the file without the container root path.
+        """
+        os.remove(os.path.join(self.root_path, path.lstrip('/')))
 
     def start_container(self):
         """
@@ -151,91 +144,85 @@
         """
         pass
 
-    def update_apt_cache(self, verbosity=1):
+    def update_apt_cache(self):
         """
         Updates the apt cache in the container.
-
-        :param verbosity: the chattiness of the output on a range from 0 to 2
         """
-        return self.run_in_container(apt_command_prefix(verbosity) + 'update')
+        return self.run_in_container(_apt_command_prefix() + 'update')
 
-    def update_packages(self, verbosity=1):
+    def update_packages(self):
         """
         Updates all packages installed in the container.
-
-        :param verbosity: the chattiness of the output on a range from 0 to 2
         """
-        self.update_apt_cache(verbosity)
-        return self.run_in_container(apt_command_prefix(verbosity) + '--force-yes dist-upgrade') == 0
+        self.update_apt_cache()
+        return self.run_in_container(_apt_command_prefix() + '--force-yes dist-upgrade') == 0
 
-    def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
+    def install_package(self, package_name, no_dialog=False, update_cache=True):
         """
         Installs a named package in the container.
 
         :param package_name: The name of the package as APT understands it or
                              a full path to a Debian package on the host.
-        :param verbosity: the chattiness of the output on a range from 0 to 2
         """
         if update_cache:
-            self.update_apt_cache(verbosity)
+            self.update_apt_cache()
 
         if package_name.endswith('.deb'):
-            delete_package = self.copy_package_to_container(package_name)
-
-            self.run_in_container('ls -la ' + os.environ['HOME'])
-            self.run_in_container('dpkg -i ' +
-                os.path.join('/', 'tmp', package_name.split('/')[-1]))
-
-            ret = self.run_in_container(apt_command_prefix(verbosity) + " install -f") == 0
-
-            if delete_package:
-                self.delete_package_in_container(package_name)
+            if not os.path.exists(package_name):
+                utils.get_logger().error("File {} does not exist.".format(package_name))
+                return False
+
+            dest = os.path.join('/', 'tmp', package_name.split('/')[-1])
+            file_created = self.copy_file_to_container(package_name, dest)
+
+            self.run_in_container('dpkg -i {}'.format(dest))
+            ret = self.run_in_container(_apt_command_prefix() + " install -f") == 0
+
+            if file_created:
+                self.delete_file_in_container(dest)
 
             return ret
         else:
             if no_dialog:
                 os.environ['DEBIAN_FRONTEND'] = 'teletype'
-            return self.run_in_container(apt_command_prefix(verbosity) + " install '" + package_name + "'") == 0
+            return self.run_in_container(_apt_command_prefix() + " install '" + package_name + "'") == 0
 
-    def remove_package(self, package_name, verbosity=1):
+    def remove_package(self, package_name):
         """
         Removes a package from the container.
 
         :param package_name: The name of the package to be removed.
-        :param verbosity: The verbosity level of the progress reporting.
         """
-        if self.run_in_container(apt_command_prefix(verbosity) + " purge '" + package_name + "'") != 0:
+        if self.run_in_container(_apt_command_prefix() + " purge '" + package_name + "'") != 0:
             return False
-        return self.run_in_container(apt_command_prefix(verbosity) + "autoremove --purge") == 0
+        return self.run_in_container(_apt_command_prefix() + "autoremove --purge") == 0
 
-    def configure_multiarch(self, should_enable, verbosity=1):
+    def configure_multiarch(self, should_enable):
         """
         Enables or disables multiarch repositories.
 
         :param should_enable: Whether or not to enable multiarch support.
-        :param verbosity: the chattiness of the output on a range from 0 to 2
         """
         if should_enable:
             ret = self.run_in_container("dpkg --add-architecture i386")
             if ret or ret == 0:
-                self.update_apt_cache(verbosity)
+                self.update_apt_cache()
             return ret
         else:
-            self.run_in_container(apt_command_prefix(verbosity) + "purge \".*:i386\"")
+            self.run_in_container(_apt_command_prefix() + "purge \".*:i386\"")
             return self.run_in_container("dpkg --remove-architecture i386")
 
-    def configure_add_archive(self, archive, public_key_file, verbosity=1):
+    def configure_add_archive(self, archive, public_key_file):
         """
         Adds the given archive. If this archive requires a key, prompt user.
 
         :param archive: The configuration command to run.
         :param public_key_file: file containing the public key used to sign this archive
-        :param verbosity: the chattiness of the output on a range from 0 to 2
         """
         if not os.path.exists(os.path.join(self.root_path, 'usr', 'bin', 'add-apt-repository')):
-            self.install_package("software-properties-common", verbosity)
+            self.install_package("software-properties-common")
         if 'https://' in archive and not os.path.exists(os.path.join(self.root_path, 'usr', 'lib', 'apt', 'methods', 'https')):
-            self.install_package("apt-transport-https", verbosity)
+            self.install_package("apt-transport-https")
 
         retcode = self.run_in_container("add-apt-repository -y " + archive)
         if retcode is 0 and public_key_file is not None:
@@ -244,12 +231,11 @@
 
         return retcode
 
-    def configure_remove_archive(self, archive, verbosity=1):
+    def configure_remove_archive(self, archive):
         """
         Removes the given archive.
 
         :param archive: The configuration command to run.
-        :param verbosity: the chattiness of the output on a range from 0 to 2
         """
         return self.run_in_container("add-apt-repository -y -r " + archive)
 
@@ -272,19 +258,19 @@
         super().__init__(container_id)
         self.container_type = "mock"
 
-    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
-        return True
-
-    def destroy_libertine_container(self, verbosity=1):
-        return True
-
-    def update_packages(self, verbosity=1):
-        return True
-
-    def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
-        return True
-
-    def remove_package(self, package_name, verbosity=1, no_dialog=False):
+    def create_libertine_container(self, password=None, multiarch=False):
+        return True
+
+    def destroy_libertine_container(self):
+        return True
+
+    def update_packages(self):
+        return True
+
+    def install_package(self, package_name, no_dialog=False, update_cache=True):
+        return True
+
+    def remove_package(self, package_name, no_dialog=False):
         return True
 
     def run_in_container(self, command_string):
@@ -335,6 +321,9 @@
         if container_type == "lxc":
             from  libertine.LxcContainer import LibertineLXC
             self.container = LibertineLXC(container_id)
+        elif container_type == "lxd":
+            from libertine.LxdContainer import LibertineLXD
+            self.container = LibertineLXD(container_id, self.containers_config)
         elif container_type == "chroot":
             from  libertine.ChrootContainer import LibertineChroot
             self.container = LibertineChroot(container_id)
@@ -365,48 +354,47 @@
         """
         return self.container.destroy_libertine_container()
 
-    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
+    def create_libertine_container(self, password=None, multiarch=False):
         """
         Creates the container.
         """
         self.container.architecture = HostInfo().get_host_architecture()
         self.container.installed_release = self.containers_config.get_container_distro(self.container_id)
 
-        return self.container.create_libertine_container(password, multiarch, verbosity)
+        return self.container.create_libertine_container(password, multiarch)
 
-    def update_libertine_container(self, verbosity=1):
+    def update_libertine_container(self):
         """
         Updates the contents of the container.
         """
         try:
             with ContainerRunning(self.container):
-                return self.container.update_packages(verbosity)
+                return self.container.update_packages()
         except RuntimeError as e:
             return handle_runtime_error(e)
 
-    def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
+    def install_package(self, package_name, no_dialog=False, update_cache=True):
         """
         Installs a package in the container.
         """
         try:
             with ContainerRunning(self.container):
-                return self.container.install_package(package_name, verbosity, no_dialog, update_cache)
+                return self.container.install_package(package_name, no_dialog, update_cache)
         except RuntimeError as e:
             return handle_runtime_error(e)
 
-    def remove_package(self, package_name, verbosity=1, no_dialog=False):
+    def remove_package(self, package_name, no_dialog=False):
         """
         Removes a package from the container.
 
         :param package_name: The name of the package to be removed.
-        :param verbosity: The verbosity level of the progress reporting.
         """
         try:
             with ContainerRunning(self.container):
                 if no_dialog:
                     os.environ['DEBIAN_FRONTEND'] = 'teletype'
 
-                return self.container.remove_package(package_name, verbosity)
+                return self.container.remove_package(package_name)
         except RuntimeError as e:
             return handle_runtime_error(e)
 
@@ -484,23 +472,23 @@
         except RuntimeError as e:
             return handle_runtime_error(e)
 
-    def configure_multiarch(self, should_enable, verbosity=1):
-        try:
-            with ContainerRunning(self.container):
-                return self.container.configure_multiarch(should_enable, verbosity)
-        except RuntimeError as e:
-            return handle_runtime_error(e)
-
-    def configure_add_archive(self, archive, key, verbosity):
-        try:
-            with ContainerRunning(self.container):
-                return self.container.configure_add_archive(archive, key, verbosity)
-        except RuntimeError as e:
-            return handle_runtime_error(e)
-
-    def configure_remove_archive(self, archive, verbosity):
-        try:
-            with ContainerRunning(self.container):
-                return self.container.configure_remove_archive(archive, verbosity)
+    def configure_multiarch(self, should_enable):
+        try:
+            with ContainerRunning(self.container):
+                return self.container.configure_multiarch(should_enable)
+        except RuntimeError as e:
+            return handle_runtime_error(e)
+
+    def configure_add_archive(self, archive, key):
+        try:
+            with ContainerRunning(self.container):
+                return self.container.configure_add_archive(archive, key)
+        except RuntimeError as e:
+            return handle_runtime_error(e)
+
+    def configure_remove_archive(self, archive):
+        try:
+            with ContainerRunning(self.container):
+                return self.container.configure_remove_archive(archive)
         except RuntimeError as e:
             return handle_runtime_error(e)
 
=== modified file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	2016-11-16 17:33:42 +0000
+++ python/libertine/LxcContainer.py	2017-01-05 20:19:05 +0000
@@ -23,8 +23,9 @@
 import sys
 import tempfile
 
+from .lifecycle import LifecycleResult
 from .Libertine import BaseContainer
-from . import utils
+from . import utils, HostInfo
 
 
 home_path = os.environ['HOME']
@@ -33,7 +34,7 @@
 LIBERTINE_LXC_MANAGER_PATH = "/LxcManager"
 
 
-def check_lxc_net_entry(entry):
+def _check_lxc_net_entry(entry):
     lxc_net_file = open('/etc/lxc/lxc-usernet')
     found = False
 
@@ -45,14 +46,14 @@
     return found
 
 
-def setup_host_environment(username):
+def _setup_host_environment(username):
     lxc_net_entry = "%s veth lxcbr0 10" % str(username)
 
-    if not check_lxc_net_entry(lxc_net_entry):
+    if not _check_lxc_net_entry(lxc_net_entry):
         subprocess.Popen(["sudo", "libertine-lxc-setup", str(username)]).wait()
 
 
-def get_lxc_default_config_path():
+def _get_lxc_default_config_path():
     return os.path.join(home_path, '.config', 'lxc')
 
 
@@ -74,21 +75,43 @@
     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")
+def _dump_lxc_log(logfile):
+    if os.path.exists(logfile):
+        try:
+            with open(logfile, 'r') as fd:
+                for line in fd:
+                    print(line.lstrip())
+        except Exception as ex:
+            utils.get_logger().error("Could not open LXC log file: %s" % ex)
+
+
+def get_logfile(container):
+    try:
+        logfile = container.get_config_item('lxc.logfile')
+    except:
+        logfile = None
+
+    if not container.running or logfile is None or not os.path.exists(logfile):
+        logfile = os.path.join(tempfile.mkdtemp(), 'lxc-start.log')
+        container.append_config_item("lxc.logfile", logfile)
+        container.append_config_item("lxc.logpriority", "3")
+
+    return logfile
+
+def lxc_start(container):
+    lxc_log_file = get_logfile(container)
 
     if not container.start():
-        return (False, "Container failed to start")
+        return LifecycleResult("Container failed to start.")
 
     if not container.wait("RUNNING", 10):
-        return (False, "Container failed to enter the RUNNING state")
+        return LifecycleResult("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 LifecycleResult("Not able to connect to the network.")
 
-    return (True, "")
+    return LifecycleResult()
 
 
 def lxc_stop(container):
@@ -96,13 +119,6 @@
         container.stop()
 
 
-def get_host_timezone():
-    with open(os.path.join('/', 'etc', 'timezone'), 'r') as fd:
-        host_timezone = fd.read().strip('\n')
-
-    return host_timezone
-
-
 class EnvLxcSettings(contextlib.ExitStack):
     """
     Helper object providing a way to set the proxies for testing
@@ -137,42 +153,31 @@
         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
+        self.host_info = HostInfo.HostInfo()
 
         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())
+            self.lxc_manager_interface = bus.get_object(get_lxc_manager_dbus_name(), get_lxc_manager_dbus_path())
         except dbus.exceptions.DBusException:
             pass
 
-    def is_running(self):
-        return self.container.running
-
     def timezone_needs_update(self):
-        host_timezone = get_host_timezone()
-
         with open(os.path.join(self.root_path, 'etc', 'timezone'), 'r') as fd:
-            container_timezone = fd.read().strip('\n')
-
-        if host_timezone == container_timezone:
-            return False
-        else:
-            return True
+            return fd.read().strip('\n') != self.host_info.get_host_timezone()
 
     def start_container(self):
         if self.lxc_manager_interface:
-            (result, error) = self.lxc_manager_interface.operation_start(self.container_id, self.lxc_log_file)
+            result = LifecycleResult.from_dict(self.lxc_manager_interface.operation_start(self.container_id))
         else:
-            (result, error) = lxc_start(self.container, self.lxc_log_file)
+            result = lxc_start(self.container)
 
-        if not result:
-            self._dump_lxc_log()
-            raise RuntimeError(error)
+        if not result.success:
+            _dump_lxc_log(result.logfile)
+            raise RuntimeError(result.error)
 
         if self.run_in_container("mountpoint -q /tmp/.X11-unix") == 0:
             self.run_in_container("umount /tmp/.X11-unix")
@@ -189,14 +194,14 @@
         cmd_args = shlex.split(command_string)
         return self.container.attach_wait(lxc.attach_run_command, cmd_args)
 
-    def update_packages(self, verbosity=1):
+    def update_packages(self):
         if self.timezone_needs_update():
             self.run_in_container("bash -c \'echo \"{}\" >/etc/timezone\'".format(
-                                  get_host_timezone()))
+                                  self.host_info.get_host_timezone()))
             self.run_in_container("rm -f /etc/localtime")
             self.run_in_container("dpkg-reconfigure -f noninteractive tzdata")
 
-        return super().update_packages(verbosity)
+        return super().update_packages()
 
     def destroy_libertine_container(self):
         if not self.container.defined:
@@ -206,7 +211,7 @@
         self.container.destroy()
         return True
 
-    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
+    def create_libertine_container(self, password=None, multiarch=False):
         if password is None:
             return False
 
@@ -214,10 +219,10 @@
         user_id = os.getuid()
         group_id = os.getgid()
 
-        setup_host_environment(username)
+        _setup_host_environment(username)
 
         # Generate the default lxc default config, if it doesn't exist
-        config_path = get_lxc_default_config_path()
+        config_path = _get_lxc_default_config_path()
         config_file = "%s/default.conf" % config_path
 
         if not os.path.exists(config_path):
@@ -236,25 +241,27 @@
                 fd.write("lxc.id_map = u %s %s %s\n" % (user_id + 1, (user_id + 1) + 100000, 65536 - (user_id + 1)))
                 fd.write("lxc.id_map = g %s %s %s\n" % (group_id + 1, (group_id + 1) + 100000, 65536 - (user_id + 1)))
 
+        self.container.load_config(config_file)
+
         utils.create_libertine_user_data_dir(self.container_id)
 
         with EnvLxcSettings():
+            lxc_logfile = get_logfile(self.container)
             if not self.container.create("download", 0,
                                          {"dist": "ubuntu",
                                           "release": self.installed_release,
                                           "arch": self.architecture}):
-                print("Failed to create container")
-                self._dump_lxc_log()
+                utils.get_logger().error("Failed to create container")
+                _dump_lxc_log(lxc_logfile)
                 return False
 
         self.create_libertine_config()
 
-        if verbosity == 1:
-            print("starting container ...")
+        utils.get_logger().info("starting container ...")
         try:
             self.start_container()
         except RuntimeError as e:
-            print("Container failed to start: %s" % e)
+            utils.get_logger().error("Container failed to start: %s" % e)
             self.destroy_libertine_container()
             return False
 
@@ -263,22 +270,19 @@
                 str(user_id), crypt.crypt(password), str(username)))
 
         if multiarch and self.architecture == 'amd64':
-            if verbosity == 1:
-                print("Adding i386 multiarch support...")
+            utils.get_logger().info("Adding i386 multiarch support...")
             self.run_in_container("dpkg --add-architecture i386")
 
-        if verbosity == 1:
-            print("Updating the contents of the container after creation...")
-        self.update_packages(verbosity)
+        utils.get_logger().info("Updating the contents of the container after creation...")
+        self.update_packages()
 
         for package in self.default_packages:
-            if not self.install_package(package, verbosity, update_cache=False):
-                print("Failure installing %s during container creation" % package)
+            if not self.install_package(package, update_cache=False):
+                utils.get_logger().error("Failure installing %s during container creation" % package)
                 self.destroy_libertine_container()
                 return False
 
-        if verbosity == 1:
-            print("stopping container ...")
+        utils.get_logger().info("stopping container ...")
         self.stop_container()
 
         return True
@@ -316,17 +320,17 @@
 
     def start_application(self, app_exec_line, environ):
         if self.lxc_manager_interface == None:
-            print("No interface to libertine-lxc-manager.  Failing application launch.")
+            utils.get_logger().error("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)
+        result = LifecycleResult.from_dict(self.lxc_manager_interface.app_start(self.container_id))
 
-        if not result:
-            self._dump_lxc_log()
-            print("%s" % error)
+        if not result.success:
+            _dump_lxc_log(get_logfile(self.container))
+            utils.get_logger().error("%s" % result.error)
             return
 
         self.window_manager = self.container.attach(lxc.attach_run_command,
@@ -348,17 +352,3 @@
 
         # Tell libertine-lxc-manager that the app has stopped.
         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):
-        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)
 
=== added file 'python/libertine/LxdContainer.py'
--- python/libertine/LxdContainer.py	1970-01-01 00:00:00 +0000
+++ python/libertine/LxdContainer.py	2017-01-05 20:19:05 +0000
@@ -0,0 +1,455 @@
+# 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 crypt
+import dbus
+import os
+import psutil
+import pylxd
+import shlex
+import subprocess
+import time
+
+from .lifecycle import LifecycleResult
+from libertine import Libertine, utils, HostInfo
+
+
+LIBERTINE_LXC_MANAGER_NAME = "com.canonical.libertine.LxdManager"
+LIBERTINE_LXC_MANAGER_PATH = "/LxdManager"
+
+
+def get_lxd_manager_dbus_name():
+    return LIBERTINE_LXC_MANAGER_NAME
+
+
+def get_lxd_manager_dbus_path():
+    return LIBERTINE_LXC_MANAGER_PATH
+
+
+def _get_devices_map():
+    devices = {
+        '/dev/tty0':   {'path': '/dev/tty0', 'type': 'unix-char'},
+        '/dev/tty7':   {'path': '/dev/tty7', 'type': 'unix-char'},
+        '/dev/tty8':   {'path': '/dev/tty8', 'type': 'unix-char'},
+        '/dev/fb0':    {'path': '/dev/fb0', 'type': 'unix-char'},
+        'x11-socket':  {'source': '/tmp/.X11-unix', 'path': '/tmp/.X11-unix', 'type': 'disk', 'optional': 'true'},
+    }
+
+    if os.path.exists('/dev/video0'):
+        devices['/dev/video0'] = {'path': '/dev/video0', 'type': 'unix-char'}
+
+    # every regular file in /dev/snd
+    for f in ['/dev/snd/{}'.format(f) for f in os.listdir('/dev/snd') if not os.path.isdir('/dev/snd/{}'.format(f))]:
+        devices[f] = {'path': f, 'type': 'unix-char'}
+
+    # every regular file in /dev/dri
+    for f in ['/dev/dri/{}'.format(f) for f in os.listdir('/dev/dri') if not os.path.isdir('/dev/dri/{}'.format(f))]:
+        devices[f] = {'path': f, 'type': 'unix-char'}
+
+    # Some devices require special mappings for snap
+    if utils.is_snap_environment():
+        devices['x11-socket']['source'] = '/var/lib/snapd/hostfs/tmp/.X11-unix'
+
+    return devices
+
+def _readlink(source):
+    while os.path.islink(source):
+        new_source = os.readlink(source)
+        if not os.path.isabs(new_source):
+            new_source = os.path.join(os.path.dirname(source), new_source)
+        source = new_source
+
+    return source
+
+def _setup_lxd():
+    utils.get_logger().info("Running LXD setup.")
+    import pexpect
+    child = pexpect.spawnu('sudo libertine-lxd-setup {}'.format(os.environ['USER']), env={'TERM': 'dumb'})
+
+    while True:
+        index = child.expect(['.+\[default=.+\].*', pexpect.EOF, pexpect.TIMEOUT,
+                              # The following are required for lxd=2.0.x
+                              '.+\[yes/no\].*',
+                              '.+\(e.g. (?P<example>[a-z0-9\.:]+)\).+'])
+        if index == 0:
+            child.sendline()
+        elif index == 1:
+            return True
+        elif index == 2:
+            return False
+        elif index == 3:
+            child.sendline('yes')
+        elif index == 4:
+            child.sendline(child.match.group('example'))
+
+        if child.exitstatus is not None:
+            return child.exitstatus == 0
+
+
+def _setup_bind_mount_service(container, uid, username):
+    utils.get_logger().info("Creating systemd mount override service")
+    service = '''
+[Unit]
+Description=Fix system mounts for libertine
+
+[Service]
+ExecStart=/usr/bin/libertine-lxd-mount-update
+
+[Install]
+WantedBy=multi-user.target
+'''[1:-1]
+    container.files.put('/etc/systemd/system/libertine-lxd-mount-update.service', service.encode('utf-8'))
+    container.execute(shlex.split('chmod 644 /etc/systemd/system/libertine-lxd-mount-update.service'))
+
+    utils.get_logger().info("Creating mount update shell script")
+    script = '''
+#!/bin/sh
+
+mkdir -p /run/user/{uid}
+chown {username}:{username} /run/user/{uid}
+chmod 755 /run/user/{uid}
+mount -o bind /var/tmp/run/user/{uid} /run/user/{uid}
+
+chgrp audio /dev/snd/*
+chgrp video /dev/dri/*
+[ -n /dev/video0 ] && chgrp video /dev/video0
+'''[1:-1]
+    container.files.put('/usr/bin/libertine-lxd-mount-update', script.format(uid=uid, username=username).encode('utf-8'))
+    container.execute(shlex.split('chmod 755 /usr/bin/libertine-lxd-mount-update'))
+
+    utils.get_logger().info("Enabling systemd mount update service")
+    container.execute(shlex.split('systemctl enable libertine-lxd-mount-update.service'))
+
+
+def lxd_container(client, container_id):
+    try:
+        return client.containers.get(container_id)
+    except pylxd.exceptions.LXDAPIException:
+        return None
+
+
+def _wait_for_network(container):
+    for retries in range(0, 10):
+        out, err = container.execute(shlex.split('ping -c 1 ubuntu.com'))
+        if out:
+            utils.get_logger().info("Network connection active")
+            return True
+        time.sleep(1)
+    return False
+
+
+def lxd_start(container):
+    if container.status != 'Running':
+        container.start(wait=True)
+
+    container.sync(rollback=True) # required for pylxd=2.0.x
+
+    if container.status != 'Running':
+        return LifecycleResult("Container {} failed to start".format(container.name))
+
+    return LifecycleResult()
+
+
+def lxd_stop(container, wait):
+    if container.status == 'Stopped':
+        return LifecycleResult()
+
+    container.stop(wait=wait)
+    container.sync(rollback=True) # required for pylxd=2.0.x
+
+    if wait and container.status != 'Stopped':
+        return LifecycleResult("Container {} failed to stop".format(container.name))
+
+    return LifecycleResult()
+
+
+def update_bind_mounts(container, config):
+    home_path = os.environ['HOME']
+
+    container.devices.clear()
+    container.devices['root'] = {'type': 'disk', 'path': '/'}
+
+    if os.path.exists(os.path.join(home_path, '.config', 'dconf')):
+        container.devices['dconf'] = {
+            'type': 'disk',
+            'source': os.path.join(home_path, '.config', 'dconf'),
+            'path': os.path.join(home_path, '.config', 'dconf')
+        }
+
+    run_user = '/run/user/{}'.format(os.getuid())
+    container.devices[run_user] = {'source': run_user, 'path': '/var/tmp{}'.format(run_user), 'type': 'disk'}
+
+    mounts = utils.get_common_xdg_user_directories() + \
+             config.get_container_bind_mounts(container.name)
+    for user_dir in utils.generate_binding_directories(mounts, home_path):
+        if not os.path.exists(user_dir[0]):
+            utils.get_logger().warning('Bind-mount path \'{}\' does not exist.'.format(user_dir[0]))
+            continue
+
+        if os.path.isabs(user_dir[1]):
+            path = user_dir[1]
+        else:
+            path = os.path.join(home_path, user_dir[1])
+
+        utils.get_logger().debug("Mounting {}:{} in container {}".format(user_dir[0], path, container.name))
+
+        container.devices[user_dir[1]] = {
+                'source': _readlink(user_dir[0]),
+                'path': path,
+                'optional': 'true',
+                'type': 'disk'
+        }
+
+    try:
+        container.save(wait=True)
+    except pylxd.exceptions.LXDAPIException as e:
+        utils.get_logger().warning('Saving bind mounts for container \'{}\' raised: {}'.format(container.name, str(e)))
+        # This is most likely the result of the container currently running
+
+
+def update_libertine_profile(client):
+    try:
+        profile = client.profiles.get('libertine')
+
+        utils.get_logger().info('Updating existing lxd profile.')
+        profile.devices = _get_devices_map()
+        profile.config['raw.idmap'] = 'both 1000 1000'
+
+        try:
+            profile.save()
+        except pylxd.exceptions.LXDAPIException as e:
+            utils.get_logger().warning('Saving libertine lxd profile raised: {}'.format(str(e)))
+            # This is most likely the result of an older container currently
+            # running and/or containing a conflicting device entry
+    except pylxd.exceptions.LXDAPIException:
+        utils.get_logger().info('Creating libertine lxd profile.')
+        client.profiles.create('libertine', config={'raw.idmap': 'both 1000 1000'}, devices=_get_devices_map())
+
+
+class LibertineLXD(Libertine.BaseContainer):
+    def __init__(self, name, config):
+        super().__init__(name)
+        self._id = name
+        self._config = config
+        self._host_info = HostInfo.HostInfo()
+        self._container = None
+        self._matchbox_pid = None
+
+        if not _setup_lxd():
+            raise Exception("Failed to setup lxd.")
+
+        self._client = pylxd.Client()
+        self._window_manager = None
+        self.root_path = '{}/containers/{}/rootfs'.format(os.getenv('LXD_DIR', '/var/lib/lxd'), name)
+
+        utils.set_session_dbus_env_var()
+        try:
+            bus = dbus.SessionBus()
+            self._manager = bus.get_object(get_lxd_manager_dbus_name(), get_lxd_manager_dbus_path())
+        except dbus.exceptions.DBusException:
+            utils.get_logger().warning("D-Bus Service not found.")
+            self._manager = None
+
+
+    def create_libertine_container(self, password=None, multiarch=False):
+        if self._try_get_container():
+            utils.get_logger().error("Container already exists")
+            return False
+
+        update_libertine_profile(self._client)
+
+        utils.get_logger().info("Creating container '%s' with distro '%s'" % (self._id, self.installed_release))
+        create = subprocess.Popen(shlex.split('lxc launch ubuntu-daily:{distro} {id} --profile '
+                                              'default --profile libertine'.format(
+                                              distro=self.installed_release, id=self._id)))
+        if create.wait() is not 0:
+            utils.get_logger().error("Creating container '{}' failed with code '{}'".format(self._id, create.returncode))
+            return False
+
+        if not self.start_container():
+            utils.get_logger().error("Failed to start container '{}'".format(self._id))
+            self.destroy_libertine_container()
+            return False
+
+        username = os.environ['USER']
+        uid = str(os.getuid())
+        self.run_in_container("userdel -r ubuntu")
+        self.run_in_container("useradd -u {} -U -p {} -G sudo,audio,video {}".format(
+            uid, crypt.crypt(''), username))
+        self.run_in_container("mkdir -p /home/{}".format(username))
+        self.run_in_container("chown {0}:{0} /home/{0}".format(username))
+
+        _setup_bind_mount_service(self._container, uid, username)
+
+        if multiarch and self.architecture == 'amd64':
+            utils.get_logger().info("Adding i386 multiarch support to container '{}'".format(self._id))
+            self.run_in_container("dpkg --add-architecture i386")
+
+        self.update_packages()
+
+        for package in self.default_packages:
+            utils.get_logger().info("Installing package '%s' in container '%s'" % (package, self._id))
+            if not self.install_package(package, no_dialog=True, update_cache=False):
+                utils.get_logger().error("Failure installing '%s' during container creation" % package)
+                self.destroy_libertine_container()
+                return False
+
+        return True
+
+    def update_packages(self):
+        if not self._timezone_in_sync():
+            utils.get_logger().info("Re-syncing timezones")
+            self.run_in_container("bash -c 'echo \"%s\" > /etc/timezone'" % self._host_info.get_host_timezone())
+            self.run_in_container("rm -f /etc/localtime")
+            self.run_in_container("dpkg-reconfigure -f noninteractive tzdata")
+
+        return super().update_packages()
+
+    def destroy_libertine_container(self):
+        if not self._try_get_container():
+            utils.get_logger().error("No such container '%s'" % self._id)
+            return False
+
+        self.stop_container(wait=True)
+        self._container.delete()
+        return True
+
+    def _timezone_in_sync(self):
+        proc = subprocess.Popen(self._lxc_args('cat /etc/timezone'), stdout=subprocess.PIPE)
+        out, err = proc.communicate()
+        return out.decode('UTF-8').strip('\n') == self._host_info.get_host_timezone()
+
+    def _lxc_args(self, command, environ={}):
+        env_as_args = ' '
+        for k, v in environ.items():
+            env_as_args += '--env {}="{}" '.format(k, v)
+
+        return shlex.split('lxc exec {}{}-- {}'.format(self._id,
+                                                       env_as_args,
+                                                       command))
+
+    def run_in_container(self, command):
+        proc = subprocess.Popen(self._lxc_args(command))
+        return proc.wait()
+
+    def start_container(self):
+        if not self._try_get_container():
+            return False
+
+        if self._manager:
+            result = LifecycleResult.from_dict(self._manager.operation_start(self._id))
+        else:
+            result = lxd_start(self._container)
+
+        if not result.success:
+            utils.get_logger().error(result.error)
+            return False
+
+        if not _wait_for_network(self._container):
+            utils.get_logger().warning("Network unavailable in container '{}'".format(self._id))
+
+        return result.success
+
+    def stop_container(self, wait=False):
+        if not self._try_get_container():
+            return False
+
+        if self._manager:
+            result = LifecycleResult.from_dict(self._manager.operation_stop(self._id))
+        else:
+            result = lxd_stop(self._container, wait)
+
+        if not result.success:
+            utils.get_logger().error(result.error)
+
+        return result.success
+
+    def _get_matchbox_pids(self):
+        p = subprocess.Popen(self._lxc_args('pgrep matchbox'), stdout=subprocess.PIPE)
+        out, err = p.communicate()
+        return out.decode('utf-8').split('\n')
+
+    # FIXME: Remove once window management logic has been moved to the host
+    def _start_window_manager(self, args):
+        args.extend(utils.setup_window_manager(self._id))
+
+        if 'matchbox-window-manager' in args:
+            pids = self._get_matchbox_pids()
+
+        self._window_manager = psutil.Popen(args)
+
+        time.sleep(.25) # Give matchbox a moment to start in the container
+        if self._window_manager.poll() is not None:
+            utils.get_logger().warning("Window manager terminated prematurely with exit code '{}'".format(
+                                       self._window_manager.returncode))
+            self._window_manager = None
+        elif 'matchbox-window-manager' in args:
+            after_pids = self._get_matchbox_pids()
+            if len(after_pids) > len(pids):
+                self._matchbox_pid = (set(after_pids) - set(pids)).pop()
+
+    def start_application(self, app_exec_line, environ):
+        if not self._try_get_container():
+            utils.get_logger().error("Could not get container '{}'".format(self._id))
+            return None
+
+        if self._manager:
+            result = LifecycleResult.from_dict(self._manager.app_start(self._id))
+        else:
+            update_libertine_profile(self._client)
+            update_bind_mounts(self._container, self._config)
+            result = lxd_start(self._container)
+
+        if not result.success:
+            utils.get_logger().error(result.error)
+            return False
+
+        args = self._lxc_args("sudo -E -u {} env PATH={}".format(os.environ['USER'], environ['PATH']), environ)
+
+        self._start_window_manager(args.copy())
+
+        args.extend(app_exec_line)
+        return psutil.Popen(args)
+
+    def finish_application(self, app):
+        if self._window_manager is not None:
+            utils.terminate_window_manager(self._window_manager)
+            self._window_manager = None
+
+            # This is a workaround for an issue on xenial where the process
+            # running the window manager is not killed with the application
+            if self._matchbox_pid is not None:
+                utils.get_logger().debug("Manually killing matchbox-window-manager")
+                self.run_in_container("kill -9 {}".format(self._matchbox_pid))
+                self._matchbox_pid = None
+
+        app.wait()
+
+        if self._manager:
+            self._manager.app_stop(self.container_id)
+        else:
+            lxd_stop(self._container, False)
+
+    def copy_file_to_container(self, source, dest):
+        with open(source, 'rb') as f:
+            return self._container.files.put(dest, f.read())
+
+    def delete_file_in_container(self, path):
+        return self.run_in_container('rm {}'.format(path))
+
+    def _try_get_container(self):
+        if self._container is None:
+            self._container = lxd_container(self._client, self._id)
+
+        return self._container is not None
 
=== modified file 'python/libertine/launcher/session.py'
--- python/libertine/launcher/session.py	2016-10-27 16:57:03 +0000
+++ python/libertine/launcher/session.py	2017-01-05 20:19:05 +0000
@@ -29,9 +29,6 @@
 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.
 
@@ -101,12 +98,12 @@
             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))
+                utils.get_logger().debug('copied {} bytes from fd to {}'.format(len(b), from_socket, to_socket))
             else:
-                log.info('close detected on {}'.format(from_socket))
+                utils.get_logger().info('close detected on {}'.format(from_socket))
             return len(b)
         except Exception as e:
-            log.debug(e)
+            utils.get_logger().debug(e)
             return 0
 
     def _close_up_shop(self, session):
@@ -172,7 +169,7 @@
         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]))
+                    utils.get_logger().info("launching {}".format(task_config.datum[0]))
                     task = LaunchServiceTask(task_config)
                     self._child_processes.append(task)
                     task.start(self._config.host_environ)
@@ -267,7 +264,7 @@
         create a socket bridge to the host when a connection from the session is
         made.
         """
-        log.debug('creating bridge listener for {} on {}'.
+        utils.get_logger().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))
@@ -286,7 +283,7 @@
         """
         (bridge_config, sock) = datum
         conn = sock.accept()
-        log.debug('connection of session socket {} accepted'.format(bridge_config.session_address))
+        utils.get_logger().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):
@@ -316,17 +313,17 @@
         data = os.read(fd, 4)
         sig = struct.unpack('%uB' % len(data), data)
         if sig[0] == signal.SIGCHLD:
-            log.info('SIGCHLD received')
+            utils.get_logger().info('SIGCHLD received')
             if self._handle_child_died():
                 raise StopIteration('launched program exited')
         elif sig[0] == signal.SIGINT:
-            log.info('SIGINT received')
+            utils.get_logger().info('SIGINT received')
             raise StopIteration('keyboard interrupt')
         elif sig[0] == signal.SIGTERM:
-            log.info('SIGTERM received')
+            utils.get_logger().info('SIGTERM received')
             raise StopIteration('terminate')
         else:
-            log.warning('unknown signal {} received'.format(sig[0]))
+            utils.get_logger().warning('unknown signal {} received'.format(sig[0]))
 
     def _set_signal_handlers(self):
         """Set the signal handlers."""
 
=== modified file 'python/libertine/launcher/task.py'
--- python/libertine/launcher/task.py	2016-10-27 17:25:08 +0000
+++ python/libertine/launcher/task.py	2017-01-05 20:19:05 +0000
@@ -44,7 +44,7 @@
 
     def __init__(self, config):
         """
-        :param config: The task configuraiton.
+        :param config: The task configuration.
         :type config: TaskConfig
 
         The constructor unpacks the service commandline from the config datum.
@@ -54,13 +54,13 @@
 
     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.  """
+        """Shuts the service down."""
         try:
             self._process.terminate()
         except ProcessLookupError:
 
=== added directory 'python/libertine/lifecycle'
=== added file 'python/libertine/lifecycle/ContainerLifecycleService.py'
--- python/libertine/lifecycle/ContainerLifecycleService.py	1970-01-01 00:00:00 +0000
+++ python/libertine/lifecycle/ContainerLifecycleService.py	2017-01-05 20:19:05 +0000
@@ -0,0 +1,108 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+# 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 as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import dbus.exceptions
+import dbus.service
+
+from .LifecycleResult import LifecycleResult
+from collections import Counter
+from dbus.mainloop.glib import DBusGMainLoop
+from libertine import utils
+
+
+LIBERTINE_CONTAINER_LIFECYCLE_INTERFACE = 'com.canonical.libertine.ContainerLifecycle'
+
+
+class ContainerLifecycleService(dbus.service.Object):
+    def __init__(self, service_name, service_path):
+        self._apps = Counter()
+        self._operations = Counter()
+
+        DBusGMainLoop(set_as_default=True)
+        try:
+            bus_name = dbus.service.BusName(service_name,
+                                            bus=dbus.SessionBus(),
+                                            do_not_queue=True)
+        except dbus.exceptions.NameExistsException:
+            utils.get_logger().error("service is already running")
+            raise
+        super().__init__(bus_name, service_path)
+
+    def start(self, container):
+        raise NotImplementedError("Subclasses must implement start(container)")
+
+    def stop(self, container):
+        raise NotImplementedError("Subclasses must implement stop(container)")
+
+    @dbus.service.method(LIBERTINE_CONTAINER_LIFECYCLE_INTERFACE,
+                         in_signature='s',
+                         out_signature='a{ss}')
+    def app_start(self, container):
+        utils.get_logger().debug("app_start({})".format(container))
+        if self._operations[container] != 0:
+            return LifecycleResult("Libertine container operation already running: cannot launch application.")
+
+        result = self.start(container, True)
+
+        if result.success:
+            self._apps[container] += 1
+
+        return result.to_dict()
+
+    @dbus.service.method(LIBERTINE_CONTAINER_LIFECYCLE_INTERFACE,
+                         in_signature='s',
+                         out_signature='a{ss}')
+    def app_stop(self, container):
+        utils.get_logger().debug("app_stop({})".format(container))
+        self._apps[container] -= 1
+        result = LifecycleResult()
+
+        if self._apps[container] == 0:
+            result = self.stop(container)
+            del self._apps[container]
+
+        return result.to_dict()
+
+    @dbus.service.method(LIBERTINE_CONTAINER_LIFECYCLE_INTERFACE,
+                         in_signature='s',
+                         out_signature='a{ss}')
+    def operation_start(self, container):
+        utils.get_logger().debug("operation_start({})".format(container))
+        if self._apps[container] != 0:
+            return LifecycleResult("Application already running in container: cannot run operation.")
+
+        result = self.start(container, False)
+
+        if result.success:
+            self._operations[container] += 1
+
+        return result.to_dict()
+
+    @dbus.service.method(LIBERTINE_CONTAINER_LIFECYCLE_INTERFACE,
+                         in_signature='s',
+                         out_signature='a{ss}')
+    def operation_stop(self, container):
+        utils.get_logger().debug("operation_stop({})".format(container))
+        self._operations[container] -= 1
+        result = LifecycleResult()
+
+        if self._operations[container] == 0:
+            result = self.stop(container)
+            del self._operations[container]
+
+        return result.to_dict()
 
=== added file 'python/libertine/lifecycle/ContainerLifecycleServiceRunner.py'
--- python/libertine/lifecycle/ContainerLifecycleServiceRunner.py	1970-01-01 00:00:00 +0000
+++ python/libertine/lifecycle/ContainerLifecycleServiceRunner.py	2017-01-05 20:19:05 +0000
@@ -0,0 +1,46 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+# 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 as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import signal
+
+from gi.repository import GLib
+from libertine import utils
+
+
+class ContainerLifecycleServiceRunner(object):
+    def __init__(self, service):
+        self._service = service
+
+    def _sigterm(self, sig):
+        utils.get_logger().warning("Received SIGTERM")
+        self._shutdown()
+
+    def _shutdown(self):
+        utils.get_logger().info("Shutting down")
+        GLib.MainLoop().quit()
+
+    def run(self):
+        GLib.unix_signal_add(GLib.PRIORITY_HIGH,
+                             signal.SIGTERM,
+                             self._sigterm,
+                             None)
+
+        try:
+            utils.get_logger().info("Starting main loop")
+            GLib.MainLoop().run()
+        except KeyboardInterrupt:
+            self._shutdown()
 
=== added file 'python/libertine/lifecycle/LifecycleResult.py'
--- python/libertine/lifecycle/LifecycleResult.py	1970-01-01 00:00:00 +0000
+++ python/libertine/lifecycle/LifecycleResult.py	2017-01-05 20:19:05 +0000
@@ -0,0 +1,37 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+# 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 as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class LifecycleResult(object):
+    def __init__(self, error=''):
+        self._error = error
+
+    @property
+    def error(self):
+        return self._error or ''
+
+    @property
+    def success(self):
+        return self.error == ''
+
+    @classmethod
+    def from_dict(kls, d):
+        return LifecycleResult(d.get('error', None))
+
+    def to_dict(self):
+        return {
+            'error': self.error
+        }
 
=== added file 'python/libertine/lifecycle/__init__.py'
--- python/libertine/lifecycle/__init__.py	1970-01-01 00:00:00 +0000
+++ python/libertine/lifecycle/__init__.py	2017-01-05 20:19:05 +0000
@@ -0,0 +1,23 @@
+# 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 .ContainerLifecycleServiceRunner import ContainerLifecycleServiceRunner
+from .ContainerLifecycleService import ContainerLifecycleService
+from .LifecycleResult import LifecycleResult
+
+__all__ = [
+          'ContainerLifecycleServiceRunner',
+          'ContainerLifecycleService',
+          'LifecycleResult'
+          ]
 
=== modified file 'python/libertine/utils.py'
--- python/libertine/utils.py	2016-12-02 16:38:11 +0000
+++ python/libertine/utils.py	2017-01-05 20:19:05 +0000
@@ -25,6 +25,7 @@
 require_version('Libertine', '1')
 from gi.repository import Libertine
 
+
 def get_logger():
     logger = logging.getLogger('__libertine_logger__')
 
@@ -40,13 +41,27 @@
         logger.addHandler(stream_handler)
 
     if 'LIBERTINE_DEBUG' in os.environ:
-        logger.setLevel(logging.DEBUG)
+        if os.environ['LIBERTINE_DEBUG'] == '0':
+            logger.setLevel(logging.WARNING)
+        elif os.environ['LIBERTINE_DEBUG'] == '1':
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.DEBUG)
     else:
         logger.setLevel(logging.WARNING)
 
     return logger
 
 
+def set_environmental_verbosity(verbosity):
+    # Set debug levels if not overridden in environment
+    if 'LIBERTINE_DEBUG' not in os.environ:
+        if verbosity is None:
+            os.environ['LIBERTINE_DEBUG'] = '1'
+        else:
+            os.environ['LIBERTINE_DEBUG'] = str(verbosity)
+
+
 def get_libertine_container_rootfs_path(container_id):
     path = Libertine.container_path(container_id)
 
@@ -112,8 +127,8 @@
 
         name = dir
         if name.startswith(prefix):
-            name = name.replace(prefix, '', 1)
-        name = name.lstrip('/')
+            name = name.replace(prefix, '', 1).lstrip('/')
+
         if name in names:
             binding_dirs.append((dir, "%s (%i)" % (name, names.count(name))))
         else:
@@ -201,3 +216,9 @@
         return True
     else:
         return False
+
+
+def get_deb_package_name(package):
+    pkg_name_proc = subprocess.Popen(shlex.split('dpkg --field {} Package'.format(package)), stdout=subprocess.PIPE)
+    out, err = pkg_name_proc.communicate()
+    return out.decode('utf-8').strip()
 
=== added file 'snapcraft.yaml'
--- snapcraft.yaml	1970-01-01 00:00:00 +0000
+++ snapcraft.yaml	2017-01-05 20:19:05 +0000
@@ -0,0 +1,32 @@
+name: libertine
+version: "1.5"
+summary: Libertine suite
+description: |
+    Suite for maintaining deb-based applications in a non-deb environment
+confinement: devmode
+grade: devel
+
+apps:
+  libertine-container-manager:
+    command: usr/bin/snap-runner.wrapper libertine-container-manager
+  libertine-manager-app:
+    command: usr/bin/snap-runner.wrapper libertine-manager-app
+  libertine-launch:
+    command: usr/bin/snap-runner.wrapper libertine-launch
+
+  # For debugging purposes
+  bash:
+    command: usr/bin/snap-runner.wrapper bash
+
+parts:
+  libertine-source:
+    plugin: libertine
+    source: .
+    after:
+      - desktop-qt5
+  libertine-deps:
+    plugin: libertine-deps
+  env:
+    plugin: dump
+    organize:
+      data/snap-runner.wrapper: usr/bin/snap-runner.wrapper
 
=== modified file 'tests/unit/test_libertine_gir.py'
--- tests/unit/test_libertine_gir.py	2016-08-28 00:17:54 +0000
+++ tests/unit/test_libertine_gir.py	2017-01-05 20:19:05 +0000
@@ -49,14 +49,12 @@
             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)
+            container_name = Libertine.container_name('wily')
 
             self.assertThat(container_name, Equals("Ubuntu 'Wily Werewolf'"))
 
-            container_id = 'wily-2'
-            container_name = Libertine.container_name(container_id)
+            container_name = Libertine.container_name('wily-2')
 
             self.assertThat(container_name, Equals("Ubuntu 'Wily Werewolf' (2)"))
 
 
=== modified file 'tests/unit/test_logger.py'
--- tests/unit/test_logger.py	2016-08-25 01:49:07 +0000
+++ tests/unit/test_logger.py	2017-01-05 20:19:05 +0000
@@ -34,6 +34,11 @@
     def test_logger_on_with_env_var(self):
         with patch.dict('os.environ', {'LIBERTINE_DEBUG': '1'}):
             l = libertine.utils.get_logger()
+            self.assertThat(l.getEffectiveLevel(), Equals(logging.INFO))
+
+    def test_logger_on_with_env_var(self):
+        with patch.dict('os.environ', {'LIBERTINE_DEBUG': '2'}):
+            l = libertine.utils.get_logger()
             self.assertThat(l.getEffectiveLevel(), Equals(logging.DEBUG))
 
     def test_logger_only_inits_once(self):
@@ -42,4 +47,3 @@
             l2 = libertine.utils.get_logger()
             l3 = libertine.utils.get_logger()
             self.assertThat(len(l3.handlers), Equals(1))
-
 
=== modified file 'tools/CMakeLists.txt'
--- tools/CMakeLists.txt	2016-10-28 19:39:13 +0000
+++ tools/CMakeLists.txt	2017-01-05 20:19:05 +0000
@@ -1,10 +1,9 @@
-install(PROGRAMS libertine-container-manager libertine-launch libertine-lxc-manager libertine-xmir libertine-lxc-setup libertined
+install(PROGRAMS libertine-container-manager libertine-launch libertine-lxc-manager libertine-lxd-manager
+                 libertine-xmir libertine-lxc-setup libertine-lxd-setup libertined
         DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(FILES libertine-launch.1 libertine-container-manager.1 libertine-lxc-manager.1 libertine-xmir.1
+install(FILES libertine-launch.1 libertine-container-manager.1 libertine-lxc-manager.1
+              libertine-lxd-manager.1 libertine-xmir.1
         DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
         COMPONENT doc)
-install(PROGRAMS update-puritine-containers
-        DESTINATION ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libertine)
-
 install(FILES completions/libertine-container-manager
         DESTINATION ${DESTDIR}/usr/share/bash-completion/completions/)
 
=== modified file 'tools/libertine-container-manager'
--- tools/libertine-container-manager	2016-11-16 17:33:42 +0000
+++ tools/libertine-container-manager	2017-01-05 20:19:05 +0000
@@ -23,7 +23,6 @@
 import sys
 import re
 
-from apt.debfile import DebPackage
 from libertine import LibertineContainer
 from libertine.ContainersConfig import ContainersConfig
 from libertine.HostInfo import HostInfo
@@ -39,22 +38,22 @@
         password = None
 
         if args.distro and not self.host_info.is_distro_valid(args.distro, args.force):
-            print("Invalid distro %s" % args.distro, file=sys.stderr)
+            libertine.utils.get_logger().error("Invalid distro %s" % args.distro)
             sys.exit(1)
 
         if self.containers_config.container_exists(args.id):
-            print("Container id '%s' is already used." % args.id, file=sys.stderr)
+            libertine.utils.get_logger().error("Container id '%s' is already used." % args.id)
             sys.exit(1)
         elif re.match("^[a-z0-9][a-z0-9+.-]+$", args.id) is None:
-            print("Container id '%s' invalid. ID must be of form ([a-z0-9][a-z0-9+.-]+)." % args.id, file=sys.stderr)
+            libertine.utils.get_logger().error("Container id '%s' invalid. ID must be of form ([a-z0-9][a-z0-9+.-]+)." % args.id)
             sys.exit(1)
 
         if not args.type:
             container_type = self.host_info.select_container_type_by_kernel()
         else:
-            if args.type == 'lxc' and not self.host_info.has_lxc_support():
-                print("System kernel does not support lxc type containers. "
-                      "Please either use chroot or omit the -t option.")
+            if (args.type == 'lxc' or args.type == 'lxd') and not self.host_info.has_lxc_support():
+                libertine.utils.get_logger().error("System kernel does not support lxc type containers. "
+                                                   "Please either use chroot or omit the -t option.")
                 sys.exit(1)
             container_type = args.type
 
@@ -64,8 +63,8 @@
             host_distro = self.host_info.get_host_distro_release()
 
             if args.distro != host_distro:
-                print("The container distribution needs to match the host ditribution for chroot"
-                      " based containers. Please either use \'%s\' or omit the -d/--distro option."
+                libertine.utils.get_logger().error("The container distribution needs to match the host ditribution for chroot"
+                                                   " based containers. Please either use \'%s\' or omit the -d/--distro option."
                       % host_distro)
                 sys.exit(1)
 
@@ -88,11 +87,18 @@
             multiarch = 'enabled'
         self.containers_config.update_container_multiarch_support(args.id, multiarch)
 
-        container = LibertineContainer(args.id)
-        self.containers_config.update_container_install_status(args.id, "installing")
-        if not container.create_libertine_container(password, args.multiarch, args.verbosity):
+        try:
+            container = LibertineContainer(args.id)
+            self.containers_config.update_container_install_status(args.id, "installing")
+            if not container.create_libertine_container(password, args.multiarch):
+                libertine.utils.get_logger().error("Failed to create container")
+                self.containers_config.delete_container(args.id)
+                sys.exit(1)
+        except Exception as e:
+            libertine.utils.get_logger().error("Failed to create container: '{}'".format(str(e)))
             self.containers_config.delete_container(args.id)
             sys.exit(1)
+
         self.containers_config.update_container_install_status(args.id, "ready")
 
         libertine.utils.refresh_libertine_scope()
@@ -119,16 +125,16 @@
 
         if is_debian_package:
             if os.path.exists(args.package):
-                package = DebPackage(args.package).pkgname
+                package = libertine.utils.get_deb_package_name(args.package)
             else:
-                print("%s does not exist." % args.package)
+                libertine.utils.get_logger().error("%s does not exist." % args.package)
                 sys.exit(1)
         else:
             package = args.package
 
         if self.containers_config.package_exists(container_id, package):
             if not is_debian_package:
-                print("Package \'%s\' is already installed." % package)
+                libertine.utils.get_logger().error("Package '%s' is already installed." % package)
                 sys.exit(1)
         else:
             self.containers_config.add_new_package(container_id, package)
@@ -136,7 +142,9 @@
         container = LibertineContainer(container_id)
 
         self.containers_config.update_package_install_status(container_id, package, "installing")
-        if not container.install_package(args.package, args.verbosity, args.no_dialog):
+        if not container.install_package(args.package, args.no_dialog):
+            libertine.utils.get_logger().error("Package '{}' failed to install in container '{}'"
+                                               .format(package, container_id))
             self.containers_config.delete_package(container_id, package)
             sys.exit(1)
 
@@ -144,12 +152,12 @@
 
         libertine.utils.refresh_libertine_scope()
 
-    def remove_package_by_name(self, container_id, package_name, verbosity=1, no_dialog=False):
+    def remove_package_by_name(self, container_id, package_name, no_dialog=False):
         fallback_status = self.containers_config.get_package_install_status(container_id, package_name)
         self.containers_config.update_package_install_status(container_id, package_name, "removing")
 
         container = LibertineContainer(container_id)
-        if not container.remove_package(package_name, verbosity, no_dialog) and fallback_status == 'installed':
+        if not container.remove_package(package_name, no_dialog) and fallback_status == 'installed':
             self.containers_config.update_package_install_status(container_id, package_name, fallback_status)
             return False
 
@@ -162,10 +170,12 @@
         container_id = self.containers_config.check_container_id(args.id)
 
         if self.containers_config.get_package_install_status(container_id, args.package) != 'installed':
-            print("Package \'%s\' is not installed." % args.package)
+            libertine.utils.get_logger().error("Package \'%s\' is not installed." % args.package)
             sys.exit(1)
 
-        if not self.remove_package_by_name(container_id, args.package, args.verbosity, args.no_dialog):
+        if not self.remove_package_by_name(container_id, args.package, args.no_dialog):
+            libertine.utils.get_logger().error("Package '{}' failed to be removed from container '{}'"
+                                               .format(args.package, container_id))
             sys.exit(1)
 
         libertine.utils.refresh_libertine_scope()
@@ -175,6 +185,8 @@
 
         container = LibertineContainer(container_id)
         if container.search_package_cache(args.search_string) is not 0:
+            libertine.utils.get_logger().error("Search for '{}' in container '{}' exited with non-zero status"
+                                               .format(args.id, args.search_string))
             sys.exit(1)
 
     def update(self, args):
@@ -183,7 +195,7 @@
         container = LibertineContainer(container_id)
 
         self.containers_config.update_container_install_status(container_id, "updating")
-        if not container.update_libertine_container(args.verbosity):
+        if not container.update_libertine_container():
             self.containers_config.update_container_install_status(container_id, "ready")
             sys.exit(1)
 
@@ -208,10 +220,10 @@
         if not container.exec_command(args.command):
             sys.exit(1)
 
-    def delete_archive_by_name(self, container_id, archive_name, verbosity=1):
+    def delete_archive_by_name(self, container_id, archive_name):
         if self.containers_config.get_archive_install_status(container_id, archive_name) == 'installed':
             self.containers_config.update_archive_install_status(container_id, archive_name, 'removing')
-            if LibertineContainer(container_id).configure_remove_archive("\"" + archive_name + "\"", verbosity) is not 0:
+            if LibertineContainer(container_id).configure_remove_archive("\"" + archive_name + "\"") is not 0:
                 self.containers_config.update_archive_install_status(container_id, archive_name, 'installed')
                 return False
 
@@ -230,17 +242,17 @@
 
             current_multiarch = self.containers_config.get_container_multiarch_support(container_id)
             if current_multiarch == multiarch:
-                print("i386 multiarch support is already %s" % multiarch)
+                libertine.utils.get_logger().error("i386 multiarch support is already %s" % multiarch)
                 sys.exit(1)
 
-            if container.configure_multiarch(args.multiarch, args.verbosity) is not 0:
+            if container.configure_multiarch(args.multiarch) is not 0:
                 sys.exit(1)
 
             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.")
+                libertine.utils.get_logger().error("Configure archive called with no archive name. See configure --help for usage.")
                 sys.exit(1)
 
             archive_name = args.archive_name.strip("\'\"")
@@ -248,12 +260,12 @@
 
             if args.archive == 'add':
                 if self.containers_config.archive_exists(container_id, archive_name):
-                    print("%s already added in container." % archive_name)
+                    libertine.utils.get_logger().error("%s already added in container." % archive_name)
                     sys.exit(1)
 
                 self.containers_config.add_container_archive(container_id, archive_name)
                 self.containers_config.update_archive_install_status(container_id, archive_name, 'installing')
-                if container.configure_add_archive(archive_name_esc, args.public_key_file, args.verbosity) is not 0:
+                if container.configure_add_archive(archive_name_esc, args.public_key_file) is not 0:
                     self.containers_config.delete_container_archive(container_id, archive_name)
                     sys.exit(1)
 
@@ -261,48 +273,47 @@
 
             elif args.archive == 'remove':
                 if not self.containers_config.archive_exists(container_id, archive_name):
-                    print("%s is not added in container." % archive_name)
+                    libertine.utils.get_logger().error("%s is not added in container." % archive_name)
                     sys.exit(1)
 
                 if not self.delete_archive_by_name(container_id, archive_name):
-                    print("%s was not properly deleted." % archive_name)
+                    libertine.utils.get_logger().error("%s was not properly deleted." % archive_name)
                     sys.exit(1)
 
         elif args.bind_mount is not None:
             if args.mount_path is None:
-                print("Configure bind-mounts called without mount path. See configure --help for usage")
+                libertine.utils.get_logger().error("Configure bind-mounts called without mount path. See configure --help for usage")
                 sys.exit(1)
 
             mount_path = args.mount_path.rstrip('/')
 
             # validate bind-mount
             if not mount_path.startswith(os.environ['HOME']) and not mount_path.startswith('/media/%s' % os.environ['USER']):
-                print("Cannot mount '%s', mount path must be in $HOME or /media/$USER." % mount_path)
+                libertine.utils.get_logger().error("Cannot mount {}, mount path must be in {} or /media/{}.".format(mount_path, os.environ['HOME'], os.environ['USER']))
                 sys.exit(1)
             if mount_path.startswith('/media/%s' % os.environ['USER']) and \
                    self.containers_config.get_container_type(container_id) == 'lxc':
-                print("/media mounts not currently supported in lxc.")
+                libertine.utils.get_logger().error("/media mounts not currently supported in lxc.")
                 sys.exit(1)
             if not os.path.isdir(mount_path):
-                print("Cannot mount '%s', mount path must be an existing directory." % mount_path)
+                libertine.utils.get_logger().error("Cannot mount '%s', mount path must be an existing directory." % mount_path)
                 sys.exit(1)
 
             # update database with new bind-mount
             container_bind_mounts = self.containers_config.get_container_bind_mounts(container_id)
             if args.bind_mount == 'add':
                 if mount_path in container_bind_mounts:
-                    print("Cannot add mount '%s', bind-mount already exists." % mount_path)
+                    libertine.utils.get_logger().error("Cannot add mount '%s', bind-mount already exists." % mount_path)
                     sys.exit(1)
                 self.containers_config.add_new_bind_mount(container_id, mount_path)
             elif args.bind_mount == 'remove':
                 if mount_path not in container_bind_mounts:
-                    print("Cannot remove mount '%s', bind-mount does not exist." % mount_path)
+                    libertine.utils.get_logger().error("Cannot remove mount '%s', bind-mount does not exist." % mount_path)
                     sys.exit(1)
                 self.containers_config.delete_bind_mount(container_id, mount_path)
 
-
         else:
-            print("Configure called with no subcommand. See configure --help for usage.")
+            libertine.utils.get_logger().error("Configure called with no subcommand. See configure --help for usage.")
             sys.exit(1)
 
 
@@ -340,17 +351,17 @@
     parser = argparse.ArgumentParser(description="Legacy X application support for Unity 8")
 
     if not os.geteuid():
-        print("Please do not run %s using sudo" % parser.prog)
+        libertine.utils.get_logger().error("Please do not run %s using sudo" % parser.prog)
         sys.exit(1)
 
     container_manager = LibertineContainerManager()
 
     parser.add_argument('-q', '--quiet',
                         action='store_const', dest='verbosity', const=0,
-                        help=('do not print status updates on stdout'))
-    parser.add_argument('-v', '--verbose',
+                        help=('disables all non-vital output'))
+    parser.add_argument('-v', '--verbosity',
                         action='store_const', dest='verbosity', const=2,
-                        help=('extra verbose output'))
+                        help=('enables debug output'))
     subparsers = parser.add_subparsers(dest="subparser_name",
                                        title="subcommands",
                                        metavar='create, destroy, install-package, remove-package, search-cache, update, list, list-apps, configure')
@@ -556,8 +567,8 @@
 
     # Actually parse the args
     args = parser.parse_args()
-    if args.verbosity is None:
-        args.verbosity = 1
+
+    libertine.utils.set_environmental_verbosity(args.verbosity)
 
     if args.subparser_name == None:
         parser.print_help()
 
=== modified file 'tools/libertine-container-manager.1'
--- tools/libertine-container-manager.1	2016-10-14 14:44:17 +0000
+++ tools/libertine-container-manager.1	2017-01-05 20:19:05 +0000
@@ -26,10 +26,10 @@
 .SH OPTIONS
 .TP
 .BR \-q ", " \-\-quiet ""
-do not print status updates on stdout
+disable all non-vital output
 .TP
 .BR \-v ", " \-\-verbose ""
-extra verbose output
+enable debug output
 .TP
 .BR \-h ", " \-\-help ""
 Print a summary of the command line options and exit.
@@ -319,6 +319,12 @@
 Clear default container.
 .RE
 .TP
+.BR
+
+.SH ENVIRONMENT VARIABLES
+.TP
+.BR LIBERTINE_DEBUG
+Overrides verbosity arguments. 0 for quiet, 1 for standard, 2 for debug.
 
 .SH SEE ALSO
 .UR https://launchpad.net/libertine
 
=== modified file 'tools/libertine-lxc-manager'
--- tools/libertine-lxc-manager	2016-11-09 20:59:27 +0000
+++ tools/libertine-lxc-manager	2017-01-05 20:19:05 +0000
@@ -16,90 +16,50 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import dbus
-import dbus.service
 import libertine.LxcContainer
 import libertine.utils
 import os
 import shlex
-import signal
 import subprocess
 
-from collections import Counter
-from dbus.mainloop.glib import DBusGMainLoop
-from gi.repository import GLib
 from libertine.ContainersConfig import ContainersConfig
-
-
-home_path = os.environ['HOME']
+from libertine.lifecycle import *
+
 
 LIBERTINE_LXC_MANAGER_NAME = libertine.LxcContainer.get_lxc_manager_dbus_name()
 LIBERTINE_LXC_MANAGER_PATH = libertine.LxcContainer.get_lxc_manager_dbus_path()
 
 
-class Service(dbus.service.Object):
+class Service(ContainerLifecycleService):
 
     def __init__(self):
-        self.is_pulse_setup = False
-        self.app_counter = Counter()
-        self.containers_config = ContainersConfig()
-        self.operation_counter = Counter()
-
-        DBusGMainLoop(set_as_default=True)
-        try:
-            bus_name = dbus.service.BusName(LIBERTINE_LXC_MANAGER_NAME,
-                                            bus=dbus.SessionBus(),
-                                            do_not_queue=True)
-        except dbus.exceptions.NameExistsException:
-            print("service is already running")
-            raise
-        super().__init__(bus_name, LIBERTINE_LXC_MANAGER_PATH)
-
-    @dbus.service.method(LIBERTINE_LXC_MANAGER_NAME,
-                         in_signature='ss',
-                         out_signature='(bs)')
-    def app_start(self, container_id, lxc_logfile):
-        if self.operation_counter[container_id] != 0:
-            return (False, "Libertine container operation already running: cannot launch application.")
-
-        (started, reason) = self._launch_lxc_container(container_id, lxc_logfile)
-
-        if started:
-            self.app_counter[container_id] += 1
-
-        return (started, reason)
-
-    @dbus.service.method(LIBERTINE_LXC_MANAGER_NAME,
-                         in_signature='s')
-    def app_stop(self, container_id):
-        self.app_counter[container_id] -= 1
-
-        if self.app_counter[container_id] == 0:
-            self._stop_lxc_container(container_id)
-            del self.app_counter[container_id]
-
-    @dbus.service.method(LIBERTINE_LXC_MANAGER_NAME,
-                         in_signature='ss',
-                         out_signature='(bs)')
-    def operation_start(self, container_id, lxc_log_file):
-        if self.app_counter[container_id] != 0:
-            return (False, "Application already running in container: cannot run operation.")
-
-        (started, reason) = self._launch_lxc_container(container_id, lxc_log_file, launchable=False)
-
-        if started:
-            self.operation_counter[container_id] += 1
-
-        return (started, reason)
-
-    @dbus.service.method(LIBERTINE_LXC_MANAGER_NAME,
-                         in_signature='s')
-    def operation_stop(self, container_id):
-        self.operation_counter[container_id] -= 1
-
-        if self.operation_counter[container_id] == 0:
-            self._stop_lxc_container(container_id)
-            del self.operation_counter[container_id]
+        super().__init__(LIBERTINE_LXC_MANAGER_NAME, LIBERTINE_LXC_MANAGER_PATH)
+        self._home = os.environ['HOME']
+        self._containers_config = ContainersConfig()
+        self._is_pulse_setup = False
+
+    def start(self, container_id, launchable):
+        container = libertine.LxcContainer.lxc_container(container_id)
+
+        if not container.defined:
+            return LifecycleResult("Container {} is not valid".format(container_id))
+
+        if launchable and not self._is_pulse_setup:
+            self._setup_pulse()
+
+        if not container.running:
+            if launchable:
+                self._dynamic_bind_mounts(container, container_id)
+
+            return libertine.LxcContainer.lxc_start(container)
+
+        return LifecycleResult()
+
+    def stop(self, container_id):
+        container = libertine.LxcContainer.lxc_container(container_id)
+        libertine.LxcContainer.lxc_stop(container)
+
+        return LifecycleResult() # no error case
 
     def _setup_pulse(self):
         pulse_socket_path = os.path.join(libertine.utils.get_libertine_runtime_dir(), 'pulse_socket')
@@ -118,42 +78,26 @@
 
         self.is_pulse_setup = True
 
-    def _launch_lxc_container(self, container_id, lxc_log_file, launchable=True):
-        container = libertine.LxcContainer.lxc_container(container_id)
-
-        if not container.defined:
-            return (False, "Container {} is not valid".format(container_id))
-
-        if launchable and not self.is_pulse_setup:
-            self._setup_pulse()
-
-        if not container.running:
-            if launchable:
-                self._dynamic_bind_mounts(container, container_id)
-
-            return libertine.LxcContainer.lxc_start(container, lxc_log_file)
-
-        return (True, "")
-
-    def _stop_lxc_container(self, container_id):
-        container = libertine.LxcContainer.lxc_container(container_id)
-
-        libertine.LxcContainer.lxc_stop(container)
-
     def _dynamic_bind_mounts(self, container, container_id):
-        self.containers_config.refresh_database()
+        self._containers_config.refresh_database()
         mounts = self._sanitize_bind_mounts(libertine.utils.get_common_xdg_user_directories() + \
-                                            self.containers_config.get_container_bind_mounts(container_id))
+                                            self._containers_config.get_container_bind_mounts(container_id))
 
         data_dir = libertine.utils.get_libertine_container_userdata_dir_path(container_id)
-        for user_dir in libertine.utils.generate_binding_directories(mounts, home_path):
-            user_dir_fullpath = os.path.join(data_dir, user_dir[1])
-            if not os.path.exists(user_dir_fullpath):
-                os.makedirs(user_dir_fullpath, exist_ok=True)
-
+        for user_dir in libertine.utils.generate_binding_directories(mounts, self._home):
+            if os.path.isabs(user_dir[1]):
+                path = user_dir[1].strip('/')
+                fullpath = os.path.join(libertine.utils.get_libertine_container_rootfs_path(container_id), path)
+            else:
+                path = "{}/{}".format(self._home.strip('/'), user_dir[1])
+                fullpath = os.path.join(data_dir, user_dir[1])
+
+            os.makedirs(fullpath, exist_ok=True)
+
+            libertine.utils.get_logger().debug("Mounting {}:{} in container {}".format(user_dir[0], path, container_id))
             xdg_user_dir_entry = (
-                "%s %s/%s none bind,create=dir,optional"
-                % (user_dir[0], home_path.strip('/'), user_dir[1])
+                "%s %s none bind,create=dir,optional"
+                % (user_dir[0], path)
             )
             container.append_config_item("lxc.mount.entry", xdg_user_dir_entry)
 
@@ -161,26 +105,5 @@
         return [mount.replace(" ", "\\040") for mount in mounts]
 
 
-def sigterm(self):
-    shutdown()
-
-
-def shutdown():
-    GLib.MainLoop().quit()
-
-
-def main():
-    service = Service()
-    GLib.unix_signal_add(GLib.PRIORITY_HIGH,
-                         signal.SIGTERM,
-                         sigterm,
-                         None)
-
-    try:
-        GLib.MainLoop().run()
-    except KeyboardInterrupt:
-        shutdown()
-
-
 if __name__ == '__main__':
-    main()
+    ContainerLifecycleServiceRunner(Service()).run()
 
=== added file 'tools/libertine-lxd-manager'
--- tools/libertine-lxd-manager	1970-01-01 00:00:00 +0000
+++ tools/libertine-lxd-manager	2017-01-05 20:19:05 +0000
@@ -0,0 +1,57 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+# 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 as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import libertine.LxdContainer
+import libertine.utils
+import pylxd
+
+from libertine.ContainersConfig import ContainersConfig
+from libertine.lifecycle import *
+
+
+LIBERTINE_LXD_MANAGER_NAME = libertine.LxdContainer.get_lxd_manager_dbus_name()
+LIBERTINE_LXD_MANAGER_PATH = libertine.LxdContainer.get_lxd_manager_dbus_path()
+
+
+class Service(ContainerLifecycleService):
+
+    def __init__(self):
+        super().__init__(LIBERTINE_LXD_MANAGER_NAME, LIBERTINE_LXD_MANAGER_PATH)
+        self._config = ContainersConfig()
+        self._client = pylxd.Client()
+
+    def start(self, container_id, launchable):
+        container = libertine.LxdContainer.lxd_container(self._client, container_id)
+
+        if not container:
+            return LifecycleResult("Container {} is not valid".format(container_id))
+
+        if container.status != 'Running':
+            libertine.LxdContainer.update_libertine_profile(self._client)
+            if launchable:
+                libertine.LxdContainer.update_bind_mounts(container, self._config)
+
+            return libertine.LxdContainer.lxd_start(container)
+
+        return LifecycleResult()
+
+    def stop(self, container_id):
+        return libertine.LxdContainer.lxd_stop(libertine.LxdContainer.lxd_container(self._client, container_id), False)
+
+
+if __name__ == '__main__':
+    ContainerLifecycleServiceRunner(Service()).run()
 
=== added file 'tools/libertine-lxd-manager.1'
--- tools/libertine-lxd-manager.1	1970-01-01 00:00:00 +0000
+++ tools/libertine-lxd-manager.1	2017-01-05 20:19:05 +0000
@@ -0,0 +1,9 @@
+.TH libertine-lxd-manager "1" "Dec 2016" "libertine-lxd-manager 0.99" "User Commands"
+
+.SH NAME
+libertine-lxd-manager \- monitors LXD activity performed by libertine
+
+.SH DESCRIPTION
+usage: libertine\-lxd\-manager
+.PP
+monitors LXD activity performed by libertine
 
=== added file 'tools/libertine-lxd-setup'
--- tools/libertine-lxd-setup	1970-01-01 00:00:00 +0000
+++ tools/libertine-lxd-setup	2017-01-05 20:19:05 +0000
@@ -0,0 +1,40 @@
+#!/bin/sh
+
+if [ -z $1 ]; then
+  echo "Usage: $0 username"
+  exit 1
+fi
+
+USERNAME=$1
+
+# Create the lxd group and add given user
+if [ -z "`groups ${USERNAME} | grep lxd`" ]; then
+  groupadd --force --system lxd
+  usermod -G lxd -a $USERNAME
+fi
+
+# Map the given user to the container root user
+uid=`id --user ${USERNAME}`
+idmap="root:$uid:1"
+if [ -z "`grep ${idmap} /etc/subuid`" ]; then
+  echo ${idmap} | tee -a /etc/subuid /etc/subgid
+fi
+
+# find the right lxc command
+lxc=`which lxc`
+if [ -z "${lxc}" ]; then
+  if [ -n `which lxd.lxc` ]; then
+    lxc=`which lxd.lxc`
+  else
+    echo "No lxc command found on this system."
+    exit 1
+  fi
+fi
+
+# Run lxd init if there are no containers already on the system
+if [ 3 -ge `${lxc} list | wc -l` ]; then
+  lxd init
+fi
+
+mkdir -p /home/$USERNAME/.config/lxc
+chown -R $USERNAME:$USERNAME /home/$USERNAME/.config/lxc
 
=== modified file 'tools/libertined'
--- tools/libertined	2016-10-26 17:05:34 +0000
+++ tools/libertined	2017-01-05 20:19:05 +0000
@@ -62,11 +62,10 @@
             os.rename(self.cache_file, '%s.1' % self.cache_file)
 
     def __enter__(self):
-        if self.config.debug:
-            os.environ['LIBERTINE_DEBUG'] = '1'
-        else:
+        utils.set_environmental_verbosity(self.config.verbosity)
+
+        if not self.config.debug:
             if self.config.cache_output:
-                os.environ['LIBERTINE_DEBUG'] = '1'
                 self._rotate_logs()
                 self.output_file = open(self.cache_file, 'w')
             else:
@@ -94,7 +93,13 @@
     self._arg_parser.add_argument(u'-d', u"--debug",
                                   action='store_true',
                                   default=False,
-                                  help=u"allow all output on stdout")
+                                  help=u"print output to stdout")
+    self._arg_parser.add_argument('-q', '--quiet', action='store_const',
+                                  dest='verbosity', const=0,
+                                  help=('disables all non-vital output'))
+    self._arg_parser.add_argument('-v', '--verbosity', action='store_const',
+                                  dest='verbosity', const=2,
+                                  help=('enables debug output'))
     self._arg_parser.add_argument(u'-c', u"--cache-output",
                                   action='store_true',
                                   default=False,
@@ -111,7 +116,7 @@
         self.loop = GLib.MainLoop()
 
     def sigterm(self, code):
-        utils.get_logger().info("terminate ('%s') signal received" % code)
+        utils.get_logger().debug("terminate ('%s') signal received" % code)
         self.shutdown()
 
     def shutdown(self):
 
=== removed file 'tools/update-puritine-containers'
--- tools/update-puritine-containers	2016-10-25 15:24:08 +0000
+++ tools/update-puritine-containers	1970-01-01 00:00:00 +0000
@@ -1,183 +0,0 @@
-#!/usr/bin/python3
-# -*- coding: utf-8 -*-
-
-# Copyright (C) 2016 Canonical Ltd.
-# Author: Christopher Townsend <[e-mail]>
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import json
-import libertine.utils
-import os
-import shlex
-import shutil
-import subprocess
-
-from gi.repository import GLib, Gio
-
-puritine_hook_dir = os.path.join(os.environ['HOME'], '.cache', 'libertine', 'puritine')
-puritine_symlink_farm_file = os.path.join(puritine_hook_dir, 'PuritineSymlinkFarm.json')
-puritine_click_config_file = os.path.join('libertine-config', 'libertine', 'ContainersConfig.json')
-
-
-def symlink_farm_entries_count():
-    if (puritine_symlink_farm_list and
-        puritine_symlink_farm_list['customContainers']):
-        return len(puritine_symlink_farm_list['customContainers'])
-
-    return 0
-
-
-def puritine_symlink_exists(symlink):
-    for file in os.listdir(puritine_hook_dir):
-        if file == symlink:
-            return True
-
-    return False
-
-
-def get_symlink_name(puritine_symlink_farm_list, container_id):
-    if puritine_symlink_farm_list:
-        for container in puritine_symlink_farm_list['customContainers']:
-            if container['id'] == container_id:
-                return (puritine_symlink_farm_list['customContainers'].index(container), container['symlinkName'])
-
-    return (0, None)
-
-
-def find_removed_puritine_symlinks(puritine_symlink_farm_list):
-    for container in puritine_symlink_farm_list['customContainers']:
-        if puritine_symlink_exists(container['symlinkName']):
-            continue
-        else:
-            manager_cmd = "libertine-container-manager destroy -i " + container['id']
-            cmd = shlex.split(manager_cmd)
-            subprocess.Popen(cmd).wait()
-            puritine_symlink_farm_list['customContainers'].remove(container)
-
-    return puritine_symlink_farm_list
-
-
-def find_new_or_updated_puritine_symlinks(puritine_symlink_farm_list):
-    symlinks = os.listdir(puritine_hook_dir)
-
-    for symlink in symlinks:
-        puritine_click_path = os.path.join(puritine_hook_dir, symlink)
-        if not os.path.islink(puritine_click_path):
-            continue
-
-        config_file_path = os.path.join(puritine_click_path, puritine_click_config_file)
-
-        with open(config_file_path, 'r') as fd:
-            container_list = json.load(fd)
-
-        container_id = container_list['containerList'][0]['id']
-
-        (index, symlink_name) = get_symlink_name(puritine_symlink_farm_list, container_id)
-
-        if symlink_name:
-            # Package exists and symlink name is the same- no update
-            if symlink_name == symlink:
-                continue
-            else:
-                puritine_symlink_farm_list['customContainers'][index]['symlinkName'] = symlink
-        else:
-            symlink_obj = {'symlinkName': symlink, 'id': container_id}
-            if 'customContainers' not in puritine_symlink_farm_list:
-                puritine_symlink_farm_list['customContainers'] = [symlink_obj]
-            else:
-                puritine_symlink_farm_list['customContainers'].append(symlink_obj)
-
-        puritine_click_rootfs_path = os.path.join(puritine_click_path, 'libertine-data', 'libertine-container',
-                                                  container_id, 'rootfs')
-
-        libertine_containers_path = libertine.utils.get_libertine_containers_dir_path()
-        puritine_container_path = os.path.join(libertine_containers_path, container_id)
-        puritine_container_rootfs_path = os.path.join(puritine_container_path, 'rootfs')
-
-        if not os.path.exists(puritine_container_path):
-            os.makedirs(puritine_container_path)
-        else:
-            os.remove(puritine_container_rootfs_path)
-
-        # Link to the click packages container
-        os.symlink(puritine_click_rootfs_path, puritine_container_rootfs_path)
-
-        # Copy any user data that does not exist
-        libertine_user_data_path = libertine.utils.get_libertine_container_userdata_dir_path(container_id)
-        if not os.path.exists(libertine_user_data_path):
-            puritine_click_user_data_path = os.path.join(puritine_click_path, 'libertine-config', 'libertine-container',
-                                                         'user-data', container_id)
-            shutil.copytree(puritine_click_user_data_path, libertine_user_data_path)
-
-        # Update the main ContainerConfig.json
-        manager_cmd = "libertine-container-manager merge-configs -f " +  config_file_path
-        cmd = shlex.split(manager_cmd)
-        subprocess.Popen(cmd).wait()
-
-    return puritine_symlink_farm_list
-
-
-def favorite_libertine_scope():
-    libertine_scope_value = 'scope://libertine-scope.ubuntu_libertine-scope'
-    click_scope_value = 'scope://clickscope'
-    schema = 'com.canonical.Unity.Dash'
-    schema_key = 'favorite-scopes'
-
-    settings = Gio.Settings.new(schema)
-
-    favorites = settings.get_value(schema_key)
-
-    array = favorites.dup_strv()
-
-    if not libertine_scope_value in array:
-        array.insert(array.index(click_scope_value) + 1, libertine_scope_value)
-        new_favorites = GLib.Variant.new_strv(array)
-        settings.set_value(schema_key, new_favorites)
-        del new_favorites
-
-    del array
-    del favorites
-    del settings
-
-
-if __name__ == '__main__':
-    puritine_symlink_farm_list = {}
-    update_libertine_scope = libertine.utils.set_session_dbus_env_var()
-
-    if not os.path.exists(puritine_hook_dir):
-        os.makedirs(puritine_hook_dir)
-
-    if (os.path.exists(puritine_symlink_farm_file) and
-        os.path.getsize(puritine_symlink_farm_file) != 0):
-        with open(puritine_symlink_farm_file, 'r') as fd:
-            puritine_symlink_farm_list = json.load(fd)
-
-    count_at_start = symlink_farm_entries_count()
-
-    puritine_symlink_farm_list = find_new_or_updated_puritine_symlinks(puritine_symlink_farm_list)
-
-    if puritine_symlink_farm_list:
-        puritine_symlink_farm_list = find_removed_puritine_symlinks(puritine_symlink_farm_list)
-
-    count_at_finish = symlink_farm_entries_count()
-
-    with open(puritine_symlink_farm_file, 'w') as fd:
-        json.dump(puritine_symlink_farm_list, fd, sort_keys=True, indent=4)
-        fd.write('\n')
-
-    if count_at_start == 0 and count_at_finish > 0 and update_libertine_scope:
-        favorite_libertine_scope()
-
-    if update_libertine_scope:
-        libertine.utils.refresh_libertine_scope()