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

[Christopher Townsend]

* Refactor the libertine-session-bus to be a class, so we will be on the same process and we can actually test LSB more then just running it and checking exit code.
* Add a get_logger function to the libertine utils. This function will get the logger __libertiner_logger__ which will only be setup once, with one handler.
* Switch libertine-lxc-manager to be a DBus service and activate it on demand via DBus. (LP: #1591350)
* Add check for special LIBERTINE_JENKAAS_TESTING environment variable for the smoke testing harness.
* Bump version to 1.4.1.
* Create bind-mount directories based on information from xdg-user-dir, and only mount on container startup. (LP: #1610123)
* Return user to homepage when container has been destroyed from under them. (LP: #1604015)
* Introduce a method in ContainersConfig to refresh the database depending on an md5 checksum.
* Creating the first container moves user to ContainersView screen. (LP: #1615697)
* Inject a ContainersConfig instance when creating containers.
* Fix crash in ContainersConfig when getting host arch by using HostInfo object.
* Create a signal to indicate that container creation has begun.

[Larry Price (larryprice)]

lgtm

review: Approve

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

163. By Christopher Townsend on 2016-09-14

Remove debian/changelog entry that was already included in another landing.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-09-08 19:47:19 +0000
+++ CMakeLists.txt	2016-09-14 14:44:20 +0000
@@ -2,7 +2,7 @@
 cmake_policy(SET CMP0048 NEW)
 
 project(libertine 
-        VERSION 1.4)
+        VERSION 1.4.1)
 
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}")
 

=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2016-08-12 16:11:57 +0000
+++ data/CMakeLists.txt	2016-09-14 14:44:20 +0000
@@ -4,10 +4,12 @@
         DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
 install(FILES libertine_64.png libertine-lxc.conf
   DESTINATION ${CMAKE_INSTALL_DATADIR}/${CMAKE_PROJECT_NAME})
-install(FILES libertine-lxc-manager.conf libertine-xmir.conf
+install(FILES libertine-xmir.conf
         DESTINATION ${CMAKE_INSTALL_DATADIR}/upstart/sessions)
 install(FILES libertine-lxc-sudo
         DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/sudoers.d)
+install(FILES com.canonical.libertine.LxcManager.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"

=== added file 'data/com.canonical.libertine.LxcManager.service'
--- data/com.canonical.libertine.LxcManager.service	1970-01-01 00:00:00 +0000
+++ data/com.canonical.libertine.LxcManager.service	2016-09-14 14:44:20 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=com.canonical.libertine.LxcManager
+Exec=/usr/bin/libertine-lxc-manager

=== removed file 'data/libertine-lxc-manager.conf'
--- data/libertine-lxc-manager.conf	2015-12-01 18:17:43 +0000
+++ data/libertine-lxc-manager.conf	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-description "Service to manage Libertine LXC's"
-author "Christopher Townsend <[e-mail]>"
-
-start on started unity8
-stop on desktop-end
-
-respawn
-
-pre-start script
-	dpkg -s python3-libertine-lxc > /dev/null 2>&1 || { stop; exit 0; } 
-end script
-
-exec /usr/bin/libertine-lxc-manager

=== modified file 'debian/changelog'
--- debian/changelog	2016-09-08 19:54:48 +0000
+++ debian/changelog	2016-09-14 14:44:20 +0000
@@ -1,3 +1,34 @@
+libertine (1.4.1-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Brandon Schaefer ]
+  * Refactor the libertine-session-bus to be a class, so we will be on the
+    same process and we can actually test LSB more then just running it and
+    checking exit code.
+  * Add a get_logger function to the libertine utils. This function will get
+    the logger __libertiner_logger__ which will only be setup once, with one
+    handler.
+
+  [ Chris Townsend ]
+  * Switch libertine-lxc-manager to be a DBus service and activate it on demand
+    via DBus. (LP: #1591350)
+  * Add check for special LIBERTINE_JENKAAS_TESTING environment variable for
+    the smoke testing harness.
+  * Bump version to 1.4.1.
+
+  [ Larry Price ]
+  * Return user to homepage when container has been destroyed from under them.
+    (LP: #1604015)
+  * Introduce a method in ContainersConfig to refresh the database depending 
+    on an md5 checksum.
+  * Creating the first container moves user to ContainersView screen.
+    (LP: #1615697)
+  * Inject a ContainersConfig instance when creating containers.
+  * Fix crash in ContainersConfig when getting host arch by using HostInfo
+    object.
+  * Create a signal to indicate that container creation has begun.
+
+ -- Chris Townsend <[e-mail]>  Tue, 13 Sep 2016 14:03:29 -0400
+
 libertine (1.4+16.10.20160908-0ubuntu1) yakkety; urgency=medium
 
   [ Chris Townsend ]

=== modified file 'debian/control'
--- debian/control	2016-09-08 19:47:19 +0000
+++ debian/control	2016-09-14 14:44:20 +0000
@@ -34,7 +34,6 @@
          python3-libertine-lxc,
          qml-module-qtquick2,
          qtdeclarative5-ubuntu-ui-toolkit-plugin,
-         python3-dbus,
          ${misc:Depends},
          ${shlibs:Depends}
 Description: sandbox for running deb-packaged X11 apps on Ubuntu Personal
@@ -47,6 +46,7 @@
 Depends: libglib2.0-bin,
          lsb-release,
          python3-apt,
+         python3-dbus,
          python3-distro-info,
          python3-libertine,
          ${misc:Depends},

=== modified file 'debian/libertine-tools.install'
--- debian/libertine-tools.install	2016-08-19 20:07:22 +0000
+++ debian/libertine-tools.install	2016-09-14 14:44:20 +0000
@@ -1,5 +1,4 @@
 usr/bin/libertine-launch
-usr/bin/libertine-session-bridge
 usr/bin/libertine-container-manager
 usr/bin/libertine-xmir
 usr/bin/pasted

=== modified file 'debian/python3-libertine-lxc.install'
--- debian/python3-libertine-lxc.install	2016-07-15 18:39:58 +0000
+++ debian/python3-libertine-lxc.install	2016-09-14 14:44:20 +0000
@@ -1,6 +1,6 @@
 usr/lib/python*/*/libertine/LxcContainer.py
 usr/bin/libertine-lxc-manager
+usr/share/dbus-1/services/com.canonical.libertine.LxcManager.service
 usr/share/libertine/libertine-lxc.conf
-usr/share/upstart/sessions/libertine-lxc-manager.conf
 etc/sudoers.d/libertine-lxc-sudo
 usr/bin/libertine-lxc-setup

=== modified file 'libertine/ContainerAppsList.cpp'
--- libertine/ContainerAppsList.cpp	2016-03-24 14:15:26 +0000
+++ libertine/ContainerAppsList.cpp	2016-09-14 14:44:20 +0000
@@ -27,11 +27,6 @@
 { }
 
 
-ContainerAppsList::
-~ContainerAppsList()
-{ }
-
-
 void ContainerAppsList::
 setContainerApps(QString const& container_id)
 {
@@ -51,12 +46,12 @@
 
 bool ContainerAppsList::
 empty() const noexcept
-{ return apps_->empty(); }
+{ return apps_ == nullptr || apps_->empty(); }
 
 
 ContainerAppsList::size_type ContainerAppsList::
 size() const noexcept
-{ return apps_->count(); }
+{ return apps_ != nullptr ? apps_->count() : 0;}
 
 
 int ContainerAppsList::

=== modified file 'libertine/ContainerAppsList.h'
--- libertine/ContainerAppsList.h	2016-03-24 14:15:26 +0000
+++ libertine/ContainerAppsList.h	2016-09-14 14:44:20 +0000
@@ -53,7 +53,8 @@
   ContainerAppsList(ContainerConfigList* container_config_list,
                     QObject* parent = nullptr);
 
-  ~ContainerAppsList();
+  virtual
+  ~ContainerAppsList() = default;
 
   Q_INVOKABLE void
   setContainerApps(QString const& container_id);

=== modified file 'libertine/ContainerArchivesList.cpp'
--- libertine/ContainerArchivesList.cpp	2016-03-10 21:33:25 +0000
+++ libertine/ContainerArchivesList.cpp	2016-09-14 14:44:20 +0000
@@ -27,11 +27,6 @@
 { }
 
 
-ContainerArchivesList::
-~ContainerArchivesList()
-{ }
-
-
 void ContainerArchivesList::
 setContainerArchives(QString const& container_id)
 {
@@ -44,12 +39,12 @@
 
 bool ContainerArchivesList::
 empty() const noexcept
-{ return archives_->empty(); }
+{ return archives_ == nullptr || archives_->empty(); }
 
 
 ContainerArchivesList::size_type ContainerArchivesList::
 size() const noexcept
-{ return archives_->count(); }
+{ return archives_ != nullptr ? archives_->count() : 0; }
 
 
 int ContainerArchivesList::

=== modified file 'libertine/ContainerArchivesList.h'
--- libertine/ContainerArchivesList.h	2016-03-10 21:33:25 +0000
+++ libertine/ContainerArchivesList.h	2016-09-14 14:44:20 +0000
@@ -53,7 +53,8 @@
   ContainerArchivesList(ContainerConfigList* container_config_list,
                         QObject* parent = nullptr);
 
-  ~ContainerArchivesList();
+  virtual
+  ~ContainerArchivesList() = default;
 
   Q_INVOKABLE void
   setContainerArchives(QString const& container_id);

=== modified file 'libertine/ContainerConfigList.cpp'
--- libertine/ContainerConfigList.cpp	2016-06-07 18:45:30 +0000
+++ libertine/ContainerConfigList.cpp	2016-09-14 14:44:20 +0000
@@ -506,6 +506,7 @@
 load_config()
 {
   QFile config_file(config_->containers_config_file_name());
+  flock(config_file.handle(), LOCK_EX);
 
   if (config_file.exists())
   {
@@ -517,9 +518,7 @@
     {
       QJsonParseError parse_error;
 
-      flock(config_file.handle(), LOCK_EX);
       QJsonDocument json = QJsonDocument::fromJson(config_file.readAll(), &parse_error);
-      flock(config_file.handle(), LOCK_UN);
 
       if (parse_error.error)
       {
@@ -543,4 +542,5 @@
       }
     }
   }
+  flock(config_file.handle(), LOCK_UN);
 }

=== modified file 'libertine/qml/ContainerOptionsDialog.qml'
--- libertine/qml/ContainerOptionsDialog.qml	2016-07-15 18:39:58 +0000
+++ libertine/qml/ContainerOptionsDialog.qml	2016-09-14 14:44:20 +0000
@@ -27,6 +27,8 @@
     title: i18n.tr("Container Options")
     text: i18n.tr("Configure options for container creation.")
 
+    signal onCreateInitialized()
+
     Row {
         visible: containerConfigList.getHostArchitecture() == 'x86_64' ? true : false
         spacing: units.gu(1)
@@ -79,6 +81,7 @@
             width: (parent.width - parent.spacing) / 2
             onClicked: {
                 createContainer()
+                onCreateInitialized()
                 PopupUtils.close(containerOptionsDialog)
             }
         }

=== modified file 'libertine/qml/ContainersView.qml'
--- libertine/qml/ContainersView.qml	2016-07-15 18:39:58 +0000
+++ libertine/qml/ContainersView.qml	2016-09-14 14:44:20 +0000
@@ -55,8 +55,12 @@
         }
         model: containerConfigList
 
-        function edit(containerId) {
-            mainView.currentContainer = containerId
+        function edit(id, status) {
+            if (status === "removing") {
+                mainView.error(i18n.tr("Container Unavailable"), i18n.tr("Container is being destroyed and is no longer editable."))
+                return
+            }
+            mainView.currentContainer = id
             containerAppsList.setContainerApps(mainView.currentContainer)
             pageStack.push(Qt.resolvedUrl("HomeView.qml"), {"currentContainer": mainView.currentContainer})
         }
@@ -82,7 +86,7 @@
                 running: containerActivity.visible
             }
 
-            onClicked: { containersList.edit(containerId) }
+            onClicked: { containersList.edit(containerId, installStatus) }
 
             leadingActions: ListItemActions {
                 actions: [
@@ -92,8 +96,8 @@
                         description: i18n.tr("Delete Container")
                         onTriggered: {
                             var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
+                            worker.error.connect(mainView.error)
                             worker.destroyContainer(containerId)
-                            mainView.currentContainer = containerId
                         }
                     }
                 ]
@@ -117,7 +121,7 @@
                         visible: (installStatus === i18n.tr("ready") ||
                                   installStatus === i18n.tr("updating")) ? true : false
                         onTriggered: {
-                            containersList.edit(containerId)
+                            containersList.edit(containerId, installStatus)
                         }
                     }
                 ]
@@ -128,16 +132,18 @@
     Component.onCompleted: {
         containerConfigList.configChanged.connect(updateContainerList)
     }
-    
+
     Component.onDestruction: {
         containerConfigList.configChanged.disconnect(updateContainerList)
     }
 
     function updateContainerList() {
         containerConfigList.reloadContainerList()
-    }
 
-    function showPasswordDialog(enableMultiarch, containerName) {
-        PopupUtils.open(Qt.resolvedUrl("ContainerPasswordDialog.qml"), null, {"enableMultiarch": enableMultiarch, "containerName": containerName})
+        if (mainView.currentContainer && !containerConfigList.getContainerStatus(mainView.currentContainer) && pageStack.currentPage !== containersView) {
+            pageStack.pop()
+            mainView.currentContainer = ""
+            mainView.error(i18n.tr("Container Unavailable"), i18n.tr("This container has been destroyed and is no longer valid. You have been returned to the containers overview."))
+        }
     }
 }

=== modified file 'libertine/qml/WelcomeView.qml'
--- libertine/qml/WelcomeView.qml	2016-07-15 18:39:58 +0000
+++ libertine/qml/WelcomeView.qml	2016-09-14 14:44:20 +0000
@@ -67,12 +67,13 @@
             color: UbuntuColors.green
 
             onClicked: {
-                PopupUtils.open(Qt.resolvedUrl("ContainerOptionsDialog.qml"))
+                var dialog = PopupUtils.open(Qt.resolvedUrl("ContainerOptionsDialog.qml"))
+                dialog.onCreateInitialized.connect(createInitialized)
             }
         }
     }
 
-    function showPasswordDialog(enableMultiarch, containerName) {
-        PopupUtils.open(Qt.resolvedUrl("ContainerPasswordDialog.qml"), null, {"enableMultiarch": enableMultiarch, "containerName": containerName})
+    function createInitialized() {
+        pageStack.push(Qt.resolvedUrl("ContainersView.qml"))
     }
 }

=== modified file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	2016-08-12 16:11:57 +0000
+++ python/libertine/ChrootContainer.py	2016-09-14 14:44:20 +0000
@@ -61,7 +61,10 @@
 
     def destroy_libertine_container(self):
         container_root = os.path.join(utils.get_libertine_containers_dir_path(), self.container_id)
-        shutil.rmtree(container_root)
+        try:
+            shutil.rmtree(container_root)
+        except Exception as e:
+            print("%s" % e)
 
     def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
         # Create the actual chroot

=== modified file 'python/libertine/ContainersConfig.py'
--- python/libertine/ContainersConfig.py	2016-07-07 18:46:21 +0000
+++ python/libertine/ContainersConfig.py	2016-09-14 14:44:20 +0000
@@ -17,6 +17,8 @@
 import libertine.utils
 import os
 import sys
+from hashlib import md5
+from libertine.HostInfo import HostInfo
 
 
 def read_container_config_file():
@@ -41,10 +43,21 @@
         fcntl.lockf(fd, fcntl.LOCK_UN)
 
 
+def container_config_hash():
+    checksum = md5()
+    container_config_file = libertine.utils.get_libertine_database_file_path()
+    if (os.path.exists(container_config_file) and os.path.getsize(container_config_file) != 0):
+        with open(container_config_file, "rb") as f:
+            for chunk in iter(lambda: f.read(128 * checksum.block_size), b""):
+                checksum.update(chunk)
+    return checksum.hexdigest()
+
+
 class ContainersConfig(object):
 
     def __init__(self):
-        self.container_list = read_container_config_file()
+        self.checksum = None
+        self.refresh_database()
 
         if "defaultContainer" in self.container_list:
             self.default_container_id = self.container_list['defaultContainer']
@@ -144,6 +157,12 @@
     """
     Miscellaneous ContainersConfig.json operations
     """
+    def refresh_database(self):
+        checksum = container_config_hash()
+        if checksum != self.checksum:
+            self.container_list = read_container_config_file()
+            self.checksum = checksum
+
     def _find_duplicate_container_entry(self, container_list, container_id):
         for container in container_list['containerList']:
             if container['id'] == container_id:
@@ -243,7 +262,7 @@
         return self._test_key_value_exists(container_id, 'id')
 
     def update_container_multiarch_support(self, container_id, multiarch):
-        if multiarch == 'enabled' and libertine.utils.get_host_architecture() == 'i386':
+        if multiarch == 'enabled' and HostInfo().get_host_architecture() == 'i386':
             multiarch = 'disabled'
 
         self._set_value_by_key(container_id, 'multiarch', multiarch)

=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2016-08-10 12:45:13 +0000
+++ python/libertine/Libertine.py	2016-09-14 14:44:20 +0000
@@ -14,13 +14,19 @@
 
 from .AppDiscovery import AppLauncherCache
 from gi.repository import Libertine
+from multiprocessing import Process, active_children
+from socket import *
 import abc
 import contextlib
 import libertine.utils
 import os
 import psutil
+import select
 import shutil
 import shlex
+import signal
+import sys
+import time
 
 from libertine.ContainersConfig import ContainersConfig
 from libertine.HostInfo import HostInfo
@@ -260,7 +266,7 @@
     A sandbox for DEB-packaged X11-based applications.
     """
 
-    def __init__(self, container_id):
+    def __init__(self, container_id, containers_config=None):
         """
         Initializes the container object.
 
@@ -268,7 +274,9 @@
         """
         super().__init__()
 
-        self.containers_config = ContainersConfig()
+        if containers_config is None:
+            containers_config = ContainersConfig()
+        self.containers_config = containers_config
 
         container_type = self.containers_config.get_container_type(container_id)
 
@@ -435,18 +443,227 @@
             return handle_runtime_error(e)
 
 
+class Socket(object):
+    """
+    A simple socket wrapper class. This will wrap a socket
+
+    :param socket: A python socket to be wrapped
+    """
+    def __init__(self, sock):
+        if not isinstance(sock, socket):
+             raise TypeError("expected socket to be a python socket class instead found: '{}'".format(sock.__class__))
+
+        self.socket = sock
+
+    """
+    Implement equality checking for other instances of this class or ints only.
+
+    :param other: Either a Socket class or an int
+    """
+    def __eq__(self, other):
+        if isinstance(other, Socket):
+            return self.socket == other.socket
+        elif isinstance(other, socket):
+            return self.socket == other
+        elif isinstance(other, int):
+            return self.socket.fileno() == other
+        else:
+             raise TypeError("unsupported operand type(s) for ==: '{}' and '{}'".format(self.__class__, type(other)))
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return self.socket.fileno()
+
+    def socket(self):
+        return self.socket
+
+class SessionSocket(Socket):
+    """
+    Creates a AF_UNIX socket from a path to be used as the session socket.
+    This is used for RAII and to take ownership of the socket
+
+    :param path: The path the socket will be binded with
+    """
+    def __init__(self, session_path):
+        try:
+            sock = socket(AF_UNIX, SOCK_STREAM)
+        except:
+            sock = None
+            raise
+        else:
+            try:
+                sock.bind(session_path)
+                sock.listen(5)
+            except:
+                sock.close()
+                sock = None
+                raise
+            else:
+                super().__init__(sock)
+                self.session_path = session_path
+
+    def __del__(self):
+        self.socket.shutdown(SHUT_RDWR)
+        self.socket.close()
+        os.remove(self.session_path)
+
+
+class HostSessionSocketPair():
+    def __init__(self, host_socket_path, session_socket_path):
+        self.host_socket_path    = host_socket_path
+        self.session_socket_path = session_socket_path
+
+
+class LibertineSessionBridge(object):
+    """
+    Creates a session bridge which will pair host and session sockets to proxy the info
+    from the session to the host and vice versa.
+
+    :param host_session_socket_paths: A list of pairs container valid sockets to proxy {host:session}
+    """
+    def __init__(self, host_session_socket_paths):
+        self.descriptors = []
+        self.host_session_socket_path_map = {}
+        self.socket_pairs = {}
+
+        for host_session_socket_pair in host_session_socket_paths:
+            host_path    = host_session_socket_pair.host_socket_path
+            session_path = host_session_socket_pair.session_socket_path
+
+            socket = SessionSocket(session_path)
+
+            self.descriptors.append(socket)
+            self.host_session_socket_path_map.update({socket:host_path})
+
+    """
+    If we end up going out of scope/error let's make sure we clean up sockets and paths.
+    """
+    def __del__(self):
+        self.socket_pairs = None
+        self.descriptors  = None
+        self.host_session_socket_path_map = None
+
+    """
+    When a new connection is made on one of the main sockets we have to create a new
+    socket pairing with the container socket.
+
+    :param host_path:      The raw path to the container socket
+    :param container_sock: The socket which received a new connection
+    """
+    def accept_new_connection(self, host_path, container_sock):
+        newconn = Socket(container_sock.accept()[0])
+        self.descriptors.append(newconn)
+
+        host_sock = Socket(socket(AF_UNIX, SOCK_STREAM))
+        host_sock.socket.connect(host_path)
+        self.descriptors.append(host_sock)
+
+        self.socket_pairs.update({newconn:host_sock})
+        self.socket_pairs.update({host_sock:newconn})
+
+    """
+    Cleans up a socket that has had its connection closed.
+
+    :param socket_to_remove: The socket that had its connection closed
+    """
+    def close_connections(self, socket_to_remove):
+        partner_socket = self.socket_pairs[socket_to_remove.fileno()]
+
+        self.socket_pairs.pop(socket_to_remove.fileno())
+        self.socket_pairs.pop(partner_socket.socket.fileno())
+
+        self.descriptors.remove(socket_to_remove)
+        self.descriptors.remove(partner_socket)
+
+        if socket_to_remove in self.host_session_socket_path_map:
+            self.host_session_socket_path_map.pop(socket_to_remove)
+
+    """
+    The main loop which uses select to block until one of the sockets we are listening to becomes readable.
+    It is advised this be started in its own process or thread, as this function blocks!
+    """
+    def main_loop(self):
+        while 1:
+            try:
+                raw_sockets = list(map(lambda x : x.socket, self.descriptors))
+                rlist, wlist, elist = select.select(raw_sockets, [], [])
+            except InterruptedError as e:
+                continue
+            except Exception as e:
+                libertine.utils.get_logger().exception(e)
+                break
+
+            for sock in rlist:
+                if sock.fileno() == -1:
+                    continue
+
+                # Its possible to have multiple socket reads that are pairs. If this happens and we remove a pair we
+                # need to ignore the other pair since it no longer has a complete pair
+                if sock.fileno() not in self.host_session_socket_path_map and sock.fileno() not in self.socket_pairs:
+                    continue
+
+                if sock.fileno() in self.host_session_socket_path_map:
+                    self.accept_new_connection(self.host_session_socket_path_map[sock.fileno()], sock)
+
+                else:
+                    try:
+                        data = sock.recv(4096)
+                    except Exception as e:
+                        libertine.utils.get_logger().exception(e)
+                        self.close_connections(sock)
+                        continue
+                    else:
+                        if len(data) == 0:
+                            self.close_connections(sock)
+                            continue
+
+                    send_sock = self.socket_pairs[sock.fileno()].socket
+
+                    if send_sock.fileno() < 0:
+                        continue
+
+                    totalsent = 0
+                    while totalsent < len(data):
+                        try:
+                            sent = send_sock.send(data)
+                        except BrokenPipeError as e:
+                            libertine.utils.get_logger().exception(e)
+                            self.close_connections(sock)
+                            break
+                        else:
+                            if sent == 0:
+                                close_connections(sock)
+                                break
+                            totalsent = totalsent + sent
+
+
 class LibertineApplication(object):
     """
     Launches a libertine container with a session bridge for sockets such as dbus
 
     :param container_id: The container id.
-    "param app_exec_line: The exec line used to start the app in the container.
+    :param app_exec_line: The exec line used to start the app in the container.
     """
     def __init__(self, container_id, app_exec_line):
-        self.container_id   = container_id
-        self.app_exec_line  = app_exec_line
-        self.session_bridge = None
-        self.pasted         = None
+        signal.signal(signal.SIGTERM, self.cleanup_lsb)
+        signal.signal(signal.SIGINT,  self.cleanup_lsb)
+
+        self.container_id  = container_id
+        self.app_exec_line = app_exec_line
+        self.lsb           = None
+        self.pasted        = None
+
+    def cleanup_lsb(self, signum, frame):
+        self.close_lsb()
+
+    def close_lsb(self):
+        if self.lsb is not None:
+            self.lsb_process.terminate()
+
+        while active_children():
+            time.sleep(1)
 
     """
     Launches the libertine session bridge. This creates a proxy socket to read to and from
@@ -455,14 +672,9 @@
     :param session_socket_paths: A list of socket paths the session will create.
     """
     def launch_session_bridge(self, session_socket_paths):
-        session_bridge_arguments = ''
-        for paths in session_socket_paths:
-            session_bridge_arguments += paths + ' '
-
-        libertine_session_bridge_cmd = "libertine-session-bridge " + session_bridge_arguments
-
-        args = shlex.split(libertine_session_bridge_cmd)
-        self.session_bridge = psutil.Popen(args)
+        self.lsb         = LibertineSessionBridge(session_socket_paths)
+        self.lsb_process = Process(target=self.lsb.main_loop)
+        self.lsb_process.start()
 
     """
     Launches the pasted process for allowing copy and paste to work with X apps and
@@ -479,14 +691,12 @@
             raise RuntimeError("Container ID %s does not exist." % self.container_id)
 
         container = LibertineContainer(self.container_id)
-
         try:
             container.launch_application(self.app_exec_line)
         except:
             raise
         finally:
-            if self.session_bridge is not None:
-                self.session_bridge.terminate()
+            self.close_lsb()
 
             if self.pasted is not None:
                 self.pasted.terminate()

=== modified file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	2016-08-12 16:11:57 +0000
+++ python/libertine/LxcContainer.py	2016-09-14 14:44:20 +0000
@@ -12,7 +12,9 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import contextlib
 import crypt
+import dbus
 import lxc
 import os
 import psutil
@@ -23,11 +25,13 @@
 
 from .Libertine import BaseContainer
 from . import utils
-from socket import *
 
 
 home_path = os.environ['HOME']
 
+LIBERTINE_LXC_MANAGER_NAME = "com.canonical.libertine.LxcManager"
+LIBERTINE_LXC_MANAGER_PATH = "/LxcManager"
+
 
 def check_lxc_net_entry(entry):
     lxc_net_file = open('/etc/lxc/lxc-usernet')
@@ -69,6 +73,31 @@
     return host_timezone
 
 
+class EnvLxcSettings(contextlib.ExitStack):
+    """
+    Helper object providing a way to set the proxies for testing
+
+    When running smoke tests on Jenkins, LXC create operations need the proxies
+    set, but subsequent apt operations cannot have the proxies set.  This will
+    set the proxies when called and unset the proxies when the context is
+    destroyed.
+    """
+    def __init__(self):
+        super().__init__()
+        self.set_proxy_env()
+        self.callback(lambda: self.del_proxy_env())
+
+    def set_proxy_env(self):
+        if 'LIBERTINE_JENKAAS_TESTING' in os.environ:
+            os.environ['http_proxy'] = 'http://squid.internal:3128'
+            os.environ['https_proxy'] = 'https://squid.internal:3128'
+
+    def del_proxy_env(self):
+        if 'LIBERTINE_JENKAAS_TESTING' in os.environ:
+            del os.environ['http_proxy']
+            del os.environ['https_proxy']
+
+            
 class LibertineLXC(BaseContainer):
     """
     A concrete container type implemented using an LXC container.
@@ -178,12 +207,13 @@
 
         utils.create_libertine_user_data_dir(self.container_id)
 
-        if not self.container.create("download", 0,
-                                     {"dist": "ubuntu",
-                                      "release": self.installed_release,
-                                      "arch": self.architecture}):
-            print("Failed to create container")
-            return False
+        with EnvLxcSettings():
+            if not self.container.create("download", 0,
+                                         {"dist": "ubuntu",
+                                          "release": self.installed_release,
+                                          "arch": self.architecture}):
+                print("Failed to create container")
+                return False
 
         self.create_libertine_config()
 
@@ -253,17 +283,11 @@
         self.container.save_config()
 
     def launch_application(self, app_exec_line):
-        libertine_lxc_mgr_sock = socket(AF_UNIX, SOCK_STREAM)
-        libertine_lxc_mgr_sock.connect(utils.get_libertine_lxc_socket())
-
-        # Tell libertine-lxc-manager that we are starting a new app
-        message = "start " + self.container_id
-        libertine_lxc_mgr_sock.send(message.encode())
-
-        # Receive the reply from libertine-lxc-manager
-        data = libertine_lxc_mgr_sock.recv(1024)
-
-        if data.decode() == 'OK':
+        bus = dbus.SessionBus()
+        lxc_mgr_service = bus.get_object(LIBERTINE_LXC_MANAGER_NAME, LIBERTINE_LXC_MANAGER_PATH)
+        lxc_manager_interface = dbus.Interface(lxc_mgr_service, LIBERTINE_LXC_MANAGER_NAME)  
+        
+        if lxc_manager_interface.app_start(self.container_id):
             if not self.container.wait("RUNNING", 10):
                 print("Container failed to enter the RUNNING state")
                 return
@@ -290,12 +314,7 @@
         utils.terminate_window_manager(psutil.Process(window_manager))
 
         # Tell libertine-lxc-manager that the app has stopped.
-        message = "stop " + self.container_id
-        libertine_lxc_mgr_sock.send(message.encode())
-
-        # Receive the reply from libertine-lxc-manager (ignore it for now).
-        data = libertine_lxc_mgr_sock.recv(1024)
-        libertine_lxc_mgr_sock.close()
+        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')

=== modified file 'python/libertine/__init__.py'
--- python/libertine/__init__.py	2016-06-27 23:15:13 +0000
+++ python/libertine/__init__.py	2016-09-14 14:44:20 +0000
@@ -22,10 +22,21 @@
 
 __all__ = [
           # from Libertine
-          'LibertineContainer', 'utils', 'LibertineApplication'
+          'LibertineApplication',
+          'LibertineContainer',
+          'LibertineSessionBridge',
+          'LibertineSessionBridge',
+          'HostSessionSocketPair',
+          'SessionSocket',
+          'Socket',
+          'utils',
           ]
 
 __docformat__ = "restructuredtext en"
 
+from libertine.Libertine import LibertineApplication
 from libertine.Libertine import LibertineContainer
-from libertine.Libertine import LibertineApplication
+from libertine.Libertine import LibertineSessionBridge
+from libertine.Libertine import HostSessionSocketPair
+from libertine.Libertine import SessionSocket
+from libertine.Libertine import Socket

=== modified file 'python/libertine/utils.py'
--- python/libertine/utils.py	2016-08-12 16:11:57 +0000
+++ python/libertine/utils.py	2016-09-14 14:44:20 +0000
@@ -16,6 +16,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import logging
 import os
 import shlex
 import subprocess
@@ -25,6 +26,32 @@
 require_version('Libertine', '1')
 from gi.repository import Libertine
 
+def get_logger():
+    logger = logging.getLogger('__libertine_logger__')
+
+    # If someone else sets a handler before this, we wont run this!
+    if not logger.hasHandlers():
+        logger.setLevel(logging.DEBUG)
+        logger.disabled = True
+
+        stream_handler = logging.StreamHandler()
+        stream_handler.setLevel(logging.DEBUG)
+
+        formatter = logging.Formatter('%(filename)s:'
+                                      '%(lineno)d: '
+                                      '%(levelname)s: '
+                                      '%(funcName)s():\t'
+                                      '%(message)s')
+
+        stream_handler.setFormatter(formatter)
+        logger.addHandler(stream_handler)
+
+    # Only enable the logger if we set this
+    if os.getenv('LIBERTINE_DEBUG') is '1':
+        logger.disabled = False
+
+    return logger
+
 
 def get_libertine_container_rootfs_path(container_id):
     path = Libertine.container_path(container_id)
@@ -113,10 +140,6 @@
             os.makedirs(xdg_path)
 
 
-def get_libertine_lxc_socket():
-    return '\0libertine_lxc_socket'
-
-
 def get_libertine_lxc_pulse_socket_path():
     return os.path.join(get_libertine_runtime_dir(), 'pulse_socket')
 

=== modified file 'tests/unit/CMakeLists.txt'
--- tests/unit/CMakeLists.txt	2016-06-27 23:15:13 +0000
+++ tests/unit/CMakeLists.txt	2016-09-14 14:44:20 +0000
@@ -51,3 +51,27 @@
                      PROPERTIES
                      ENVIRONMENT
                      "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
+
+add_test(test_libertine_session_bridge
+  "/usr/bin/python3" "-m" "testtools.run" "libertine_session_bridge_tests"
+)
+set_tests_properties(test_libertine_session_bridge
+                     PROPERTIES
+                     ENVIRONMENT
+                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
+
+add_test(test_libertine_socket
+  "/usr/bin/python3" "-m" "testtools.run" "libertine_socket_tests"
+)
+set_tests_properties(test_libertine_socket
+                     PROPERTIES
+                     ENVIRONMENT
+                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
+
+add_test(test_logger
+  "/usr/bin/python3" "-m" "testtools.run" "libertine_logger_tests"
+)
+set_tests_properties(test_logger
+                     PROPERTIES
+                     ENVIRONMENT
+                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")

=== added file 'tests/unit/libertine_logger_tests.py'
--- tests/unit/libertine_logger_tests.py	1970-01-01 00:00:00 +0000
+++ tests/unit/libertine_logger_tests.py	2016-09-14 14:44:20 +0000
@@ -0,0 +1,49 @@
+# Copyright 2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import shutil
+
+import libertine.utils
+
+from testtools import TestCase
+from testtools.matchers import Equals, NotEquals
+
+class TestLogger(TestCase):
+    def setUp(self):
+        super(TestLogger, self).setUp()
+        os.environ['LIBERTINE_DEBUG'] = '1'
+        self.addCleanup(self.cleanup)
+
+    def cleanup(self):
+        if os.getenv('LIBERTINE_DEBUG', None) is not None:
+            del os.environ['LIBERTINE_DEBUG']
+
+    def test_logger_off_by_default(self):
+        # Need to turn off for this test only!
+        self.cleanup()
+        os.unsetenv('LIBERTINE_DEBUG')
+        l = libertine.utils.get_logger()
+        self.assertTrue(l.disabled)
+
+    def test_logger_on_with_env_var(self):
+        l = libertine.utils.get_logger()
+        self.assertFalse(l.disabled)
+
+    def test_logger_only_inits_once(self):
+        l1 = libertine.utils.get_logger()
+        l2 = libertine.utils.get_logger()
+        l3 = libertine.utils.get_logger()
+        self.assertThat(len(l3.handlers), Equals(1))
+

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

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

=== modified file 'tools/CMakeLists.txt'
--- tools/CMakeLists.txt	2016-07-15 18:39:58 +0000
+++ tools/CMakeLists.txt	2016-09-14 14:44:20 +0000
@@ -1,6 +1,6 @@
-install(PROGRAMS libertine-container-manager libertine-launch libertine-session-bridge libertine-lxc-manager libertine-xmir libertine-lxc-setup
+install(PROGRAMS libertine-container-manager libertine-launch libertine-lxc-manager libertine-xmir libertine-lxc-setup
         DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(FILES libertine-launch.1 libertine-container-manager.1 libertine-session-bridge.1 libertine-lxc-manager.1 libertine-xmir.1
+install(FILES libertine-launch.1 libertine-container-manager.1 libertine-lxc-manager.1 libertine-xmir.1
         DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
         COMPONENT doc)
 install(PROGRAMS update-puritine-containers

=== modified file 'tools/libertine-container-manager'
--- tools/libertine-container-manager	2016-08-12 16:11:57 +0000
+++ tools/libertine-container-manager	2016-09-14 14:44:20 +0000
@@ -274,20 +274,21 @@
         self.containers_config.merge_container_config_files(args.file)
 
     def fix_integrity(self, args):
-        for container in self.containers_config.container_list['containerList']:
-            if 'installStatus' not in container or container['installStatus'] != 'ready':
-                self.destroy_container_by_id(container['id'])
-                continue
-            LibertineContainer(container['id']).exec_command('dpkg --configure -a')
-
-            for package in container['installedApps']:
-                if package['appStatus'] != 'installed':
-                    self.remove_package_by_name(container['id'], package['packageName'])
-
-            if 'extraArchives' in container:
-                for archive in container['extraArchives']:
-                    if archive['archiveStatus'] != 'installed':
-                        self.delete_archive_by_name(container['id'], archive['archiveName'])
+        if 'containerList' in self.containers_config.container_list:
+            for container in self.containers_config.container_list['containerList']:
+                if 'installStatus' not in container or container['installStatus'] != 'ready':
+                    self.destroy_container_by_id(container['id'])
+                    continue
+                LibertineContainer(container['id']).exec_command('dpkg --configure -a')
+
+                for package in container['installedApps']:
+                    if package['appStatus'] != 'installed':
+                        self.remove_package_by_name(container['id'], package['packageName'])
+
+                if 'extraArchives' in container:
+                    for archive in container['extraArchives']:
+                        if archive['archiveStatus'] != 'installed':
+                            self.delete_archive_by_name(container['id'], archive['archiveName'])
 
     def set_default(self, args):
         if args.clear:

=== modified file 'tools/libertine-launch'
--- tools/libertine-launch	2016-08-10 12:45:13 +0000
+++ tools/libertine-launch	2016-09-14 14:44:20 +0000
@@ -17,13 +17,56 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import argparse
+import dbus 
 import os
 import random
 import string
 import libertine.utils
 import shlex
 import time
-from libertine import LibertineApplication
+from libertine import LibertineApplication, HostSessionSocketPair
+
+
+def get_host_maliit_socket():
+    address_bus_name    = 'org.maliit.server'
+    address_object_path = '/org/maliit/server/address'
+    address_interface   = 'org.maliit.Server.Address'
+    address_property    = 'address'
+    address             = ''
+
+    try:
+        session_bus   = dbus.SessionBus()
+        maliit_object = session_bus.get_object('org.maliit.server', '/org/maliit/server/address')
+
+        interface = dbus.Interface(maliit_object, dbus.PROPERTIES_IFACE)
+        address   = interface.Get('org.maliit.Server.Address', 'address')
+
+        partition_key = 'unix:abstract='
+        address = address.split(',')[0]
+        address = address.partition(partition_key)[2]
+        address = "\0%s" % address
+    except:
+        pass
+
+    return address
+
+
+def get_host_dbus_socket():
+    host_dbus_socket = ''
+
+    with open(os.path.join(libertine.utils.get_user_runtime_dir(), 'dbus-session'), 'r') as fd:
+        dbus_session_str = fd.read()
+
+    fd.close()
+
+    dbus_session_split = dbus_session_str.rsplit('=', 1)
+    if len(dbus_session_split) > 1:
+        host_dbus_socket = dbus_session_split[1].rstrip('\n')
+        # We need to add a \0 to the start of an abstract socket path to connect to it
+        if dbus_session_str.find('abstract') >= 0:
+            host_dbus_socket = "\0%s" % host_dbus_socket
+
+    return host_dbus_socket
 
 
 def get_session_socket_path(session_socket_name):
@@ -85,16 +128,28 @@
         if e in os.environ:
             del os.environ[e]
 
-    dbus_socket_path = get_dbus_session_socket_path()
-    maliit_socket_path = get_maliit_session_socket_path()
-
-    la.launch_session_bridge([dbus_socket_path, maliit_socket_path])
-
-    set_dbus_env_socket_path(dbus_socket_path)
-    set_maliit_env_socket_path(maliit_socket_path)
+    socket_paths = []
+
+    maliit_host_path = get_host_maliit_socket()
+
+    # Maliit needs to check with the real session dbus, so it needs to go before setting
+    # the DBUS_SESSION_ADDRESS to the session socket path
+    if maliit_host_path:
+        maliit_session_path = get_maliit_session_socket_path()
+        socket_paths.append(HostSessionSocketPair(maliit_host_path, maliit_session_path))
+        set_maliit_env_socket_path(maliit_session_path)
+
+    dbus_host_path = get_host_dbus_socket()
+
+    if dbus_host_path:
+        dbus_session_path = get_dbus_session_socket_path()
+        socket_paths.append(HostSessionSocketPair(dbus_host_path, dbus_session_path))
+        set_dbus_env_socket_path(dbus_session_path)
+
+    la.launch_session_bridge(socket_paths)
 
     # should detect the maliit socket, but dont know if its around or not here.
-    detect_session_bridge_socket(dbus_socket_path)
+    detect_session_bridge_socket(dbus_session_path)
 
     la.launch_pasted()
 

=== modified file 'tools/libertine-lxc-manager'
--- tools/libertine-lxc-manager	2016-08-12 16:11:57 +0000
+++ tools/libertine-lxc-manager	2016-09-14 14:44:20 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/python3
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2015 Canonical Ltd.
+# Copyright (C) 2016 Canonical Ltd.
 # Author: Christopher Townsend <[e-mail]>
 
 # This program is free software: you can redistribute it and/or modify
@@ -16,121 +16,118 @@
 # 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 select
+import shlex
 import signal
-import shlex
 import subprocess
 
 from collections import Counter
-from socket import *
-
-
-def lxc_setup_pulse():
-    pulse_socket_path = os.path.join(libertine.utils.get_libertine_runtime_dir(), 'pulse_socket')
-
-    lsof_cmd = 'lsof -n %s' % pulse_socket_path
-    args = shlex.split(lsof_cmd)
-    lsof = subprocess.Popen(args, stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
-    lsof.wait()
-
-    if not os.path.exists(pulse_socket_path) or lsof.returncode == 1:
-        pactl_cmd = (
-            'pactl load-module module-native-protocol-unix auth-anonymous=1 socket=%s'
-            % pulse_socket_path)
-        args = shlex.split(pactl_cmd)
-        subprocess.Popen(args).wait()
-
-
-def launch_lxc_container(container_id):
-    container = libertine.LxcContainer.LibertineLXC(container_id)
-    lxc_setup_pulse()
-
-    if not container.is_running():
-        try:
-            container.start_container(True)
-        except RuntimeError as e:
-            print("%s" % e)
-            return False
-
-    return True
-
-
-def stop_lxc_container(container_id):
-    container = libertine.LxcContainer.LibertineLXC(container_id)
-    if container.is_running():
-        container.stop_container()
-
-
-def socket_cleanup(signum, frame):
-    libertine_lxc_mgr_socket.close()
-
-
-def process_data(data):
-    msg = data.decode().split(' ')
-    op_code = msg[0]
-    container_id = msg[1]
-
-    if op_code == 'start':
-        if not launch_lxc_container(container_id):
-            return 'FAILED'
-        app_counter[container_id] += 1
-
-    elif op_code == 'stop':
-       app_counter[container_id] -= 1
-
-       if app_counter[container_id] == 0:
-           stop_lxc_container(container_id)
-
-    return 'OK'
-
-
-def main_loop():
-    while 1:
-        try:
-            rlist, wlist, elist = select.select(descriptors, [], [])
-        except InterruptedError:
-            continue
-        except:
-            break
-
-        for sock in rlist:
-            if sock.fileno() == -1:
-                continue
-
-            if sock == libertine_lxc_mgr_socket:
-                sock_fd = libertine_lxc_mgr_socket.accept()[0]
-                descriptors.append(sock_fd)
-
-            else:
-                data = sock.recv(1024)
-
-                if len(data) == 0:
-                    descriptors.remove(sock)
-                    sock.shutdown(SHUT_RDWR)
-                    sock.close()
-                    continue
-
-
-                message = process_data(data)
-                sock.send(message.encode())
+from dbus.mainloop.glib import DBusGMainLoop
+from gi.repository import GLib
+
+
+LIBERTINE_LXC_MANAGER_NAME = "com.canonical.libertine.LxcManager"
+LIBERTINE_LXC_MANAGER_PATH = "/LxcManager"
+
+
+class Service(dbus.service.Object):
+
+    def __init__(self):
+        self.is_pulse_setup = False
+        self.app_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='s',
+                         out_signature='b')
+    def app_start(self, container_id):
+        started = self._launch_lxc_container(container_id)
+
+        if started:
+            self.app_counter[container_id] += 1
+
+        return started
+
+    @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]
+
+    def _setup_pulse(self):
+        pulse_socket_path = os.path.join(libertine.utils.get_libertine_runtime_dir(), 'pulse_socket')
+
+        lsof_cmd = 'lsof -n %s' % pulse_socket_path
+        args = shlex.split(lsof_cmd)
+        lsof = subprocess.Popen(args, stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
+        lsof.wait()
+
+        if not os.path.exists(pulse_socket_path) or lsof.returncode == 1:
+            pactl_cmd = (
+                'pactl load-module module-native-protocol-unix auth-anonymous=1 socket=%s'
+                % pulse_socket_path)
+            args = shlex.split(pactl_cmd)
+            subprocess.Popen(args).wait()
+
+        self.is_pulse_setup = True
+
+    def _launch_lxc_container(self, container_id):
+        container = libertine.LxcContainer.LibertineLXC(container_id)
+
+        if not self.is_pulse_setup:
+            self._setup_pulse()
+
+        if not container.is_running():
+            try:
+                container.start_container(True)
+            except RuntimeError as e:
+                print("%s" % e)
+                return False
+
+        return True
+
+    def _stop_lxc_container(self, container_id):
+        container = libertine.LxcContainer.LibertineLXC(container_id)
+        if container.is_running():
+            container.stop_container()
+
+
+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__':
-    signal.signal(signal.SIGTERM, socket_cleanup)
-    signal.signal(signal.SIGINT, socket_cleanup)
-
-    if not os.path.exists(libertine.utils.get_libertine_runtime_dir()):
-        os.makedirs(libertine.utils.get_libertine_runtime_dir())
-
-    app_counter = Counter()
-
-    libertine_lxc_mgr_socket = socket(AF_UNIX, SOCK_STREAM)
-    libertine_lxc_mgr_socket.bind(libertine.utils.get_libertine_lxc_socket())
-    libertine_lxc_mgr_socket.listen(20)
-
-    descriptors = [libertine_lxc_mgr_socket]
-
-    main_loop()
+    main()

=== removed file 'tools/libertine-session-bridge'
--- tools/libertine-session-bridge	2016-08-12 16:11:57 +0000
+++ tools/libertine-session-bridge	1970-01-01 00:00:00 +0000
@@ -1,205 +0,0 @@
-#!/usr/bin/python3
-
-import dbus 
-import libertine.utils
-import os
-import select
-import signal
-import sys
-
-from socket import *
-
-
-def accept_new_connection(host_adder, container_sock):
-    newconn = container_sock.accept()[0]
-    descriptors.append(newconn)
-
-    host_sock = socket(AF_UNIX, SOCK_STREAM)
-    host_sock.connect(host_adder)
-    descriptors.append(host_sock)
-
-    socket_pairs.append([newconn, host_sock])
-
-
-def get_socket_pair(socket):
-    for i in range(len(socket_pairs)):
-        if socket in socket_pairs[i]:
-            return socket_pairs[i]
-
-
-def get_socket_partner(socket):
-    socket_pair = get_socket_pair(socket)
-
-    for i in range(len(socket_pair)):
-        if socket != socket_pair[i]:
-            return socket_pair[i]
-
-
-def close_connections(remove_socket):
-    partner_socket = get_socket_partner(remove_socket)
-
-    socket_pair = get_socket_pair(remove_socket)
-    socket_pairs.remove(socket_pair)
-
-    descriptors.remove(remove_socket)
-    remove_socket.shutdown(SHUT_RDWR)
-    remove_socket.close()
-
-    descriptors.remove(partner_socket)
-    partner_socket.shutdown(SHUT_RDWR)
-    partner_socket.close()
-
-
-def close_all_connections():
-    for i, j in socket_pairs:
-        i.shutdown(SHUT_RDWR)
-        i.close()
-        j.shutdown(SHUT_RDWR)
-        j.close()
-
-
-def get_host_maliit_socket():
-    address_bus_name    = "org.maliit.server"
-    address_object_path = "/org/maliit/server/address"
-    address_interface   = "org.maliit.Server.Address"
-    address_property    = "address"
-    
-    session_bus = dbus.SessionBus()
-    maliit_object = session_bus.get_object('org.maliit.server', '/org/maliit/server/address')
-
-    interface = dbus.Interface(maliit_object, dbus.PROPERTIES_IFACE)
-    address = interface.Get('org.maliit.Server.Address', 'address')
-
-    partition_key = 'unix:abstract='
-    address = address.split(',')[0]
-    address = address.partition(partition_key)[2]
-    address = "\0%s" % address
-
-    return address
-
-
-def get_host_dbus_socket():
-    host_dbus_socket = ''
-
-    with open(os.path.join(libertine.utils.get_user_runtime_dir(), 'dbus-session'), 'r') as fd:
-        dbus_session_str = fd.read()
-
-    fd.close()
-
-    dbus_session_split = dbus_session_str.rsplit('=', 1)
-    if len(dbus_session_split) > 1:
-        host_dbus_socket = dbus_session_split[1].rstrip('\n')
-        # We need to add a \0 to the start of an abstract socket path to connect to it
-        if dbus_session_str.find('abstract') >= 0:
-            host_dbus_socket = "\0%s" % host_dbus_socket
-
-    return host_dbus_socket
-
-
-def socket_cleanup(signum, frame):
-    for socket in descriptors:
-        socket.close()
-
-    close_all_connections()
-
-    for socket_path in session_socket_paths:
-        os.remove(socket_path)
-
-
-def main_loop():
-    signal.signal(signal.SIGTERM, socket_cleanup)
-    signal.signal(signal.SIGINT, socket_cleanup)
-
-    while 1:
-        try:
-            rlist, wlist, elist = select.select(descriptors, [], [])
-        except InterruptedError:
-            continue
-        except:
-            break
-
-        for sock in rlist:
-            if sock.fileno() == -1:
-                continue
-
-            if sock in host_session_socket_path_map:
-                accept_new_connection(host_session_socket_path_map[sock], sock)
-
-            else:
-                try:
-                    data = sock.recv(4096)
-                except:
-                    close_connections(sock)
-                    continue
-
-                if len(data) == 0:
-                    close_connections(sock)
-                    continue
-
-                send_sock = get_socket_partner(sock)
-
-                if send_sock.fileno() < 0:
-                    continue
-
-                totalsent = 0
-                while totalsent < len(data):
-                    sent = send_sock.send(data)
-
-                    if sent == 0:
-                        close_connections(sock)
-                        break
-                    totalsent = totalsent + sent
-
-
-def create_socket(session_socket_path):
-    try:
-        sock = socket(AF_UNIX, SOCK_STREAM)
-    except:
-        sock = None
-    else:
-        try:
-            sock.bind(session_socket_path)
-            sock.listen(5)
-        except:
-            sock.close()
-            sock = None
-        else:
-            return sock
-
-    return None
-    
-
-def create_container_socket(session_socket_path, get_host_session_path_function):
-    container_session_sock = create_socket(session_socket_path)
-
-    if container_session_sock is not None:
-        try:
-            host_session_path = get_host_session_path_function()
-        except:
-            container_session_sock.close()
-            container_session_sock = None
-            os.remove(session_socket_path)
-            raise
-        else:
-            host_session_socket_path_map.update({container_session_sock:host_session_path})
-
-            session_socket_paths.append(session_socket_path)
-            descriptors.append(container_session_sock)
-
-
-descriptors = []
-host_session_socket_path_map = {}
-session_socket_paths = []
-
-# Required sockets:
-create_container_socket(sys.argv[1], get_host_dbus_socket)
-
-# Optional sockets:
-try:
-    create_container_socket(sys.argv[2], get_host_maliit_socket)
-except:
-    pass
-
-socket_pairs = []
-
-main_loop()

=== removed file 'tools/libertine-session-bridge.1'
--- tools/libertine-session-bridge.1	2016-04-06 12:31:26 +0000
+++ tools/libertine-session-bridge.1	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-.TH libertine-session-bridge "1" "April 2016" "libertine-session-bridge 0.99" "User Commands"
-
-.SH NAME
-libertine-session-bridge \- listen for data from a DBUS session
-
-.SH DESCRIPTION
-usage: libertine\-session-bridge DBUS_SOCKET
-.PP
-listen for data from a DBUS session on the given socket path
-.SS "positional arguments:"
-.TP
-DBUS_SOCKET
-path to DBUS socket