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

[Christopher Townsend]

* If we fail to find the host path remove the session path since it would have been created with the socket.
* Only set the LXC log file when the container is about to start. (LP: #1596020)
* Add a new ContainersConfig Python class for managing all things ContainersConfig.json.
* Refactor host information into a new HostInfo class.
* Check if the LXC container is defined before trying to start it.
* Remove dependency on DISPLAY variable and use random string to generate session socket path.
* Prevent showing multiple error dialogs when adding archive fails. (LP: #1594957)
* Only generate translations when manually running `make translations`.
* Ensure /usr/games is in PATH before launching applications. (LP: #1598227)
* Make error details selectable and add clipboard button. (LP: #1598786)
* Use dialog instead of ActionSelectionPopover to address focusing issues when installing packages.
* Verify host kernel has lxc support. (LP: #1599193)
* Set DEBIAN_FRONTEND directly in environment for chroot containers. (LP: #1599246)

[Larry Price (larryprice)]

When creating a container, I get the following error:

```
Traceback (most recent call last):
  File "tools/libertine-container-manager", line 492, in <module>
    args.func(args)
  File "tools/libertine-container-manager", line 51, in create
    container_type = self.host_info.select_container_type_by_kernel()
  File "/home/lrp/Projects/2016/libertine-1.2.2/python/libertine/HostInfo.py", line 25, in select_container_type_by_kernel
    if has_lxc_support():
NameError: name 'has_lxc_support' is not defined
```

Probably missing a `self`? See minor diff comments.

review: Needs Fixing

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

139. By Christopher Townsend on 2016-07-07

Merged hot fix from lp:libertine.
Fix typo in debian/changelog.

[Larry Price (larryprice)]

Alright - lgtm!

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2016-06-23 14:01:47 +0000
+++ debian/changelog	2016-07-07 20:14:07 +0000
@@ -1,3 +1,33 @@
+libertine (1.2.2-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Brandon Schaefer ]
+  * If we fail to find the host path remove the session path since it would
+    have been created with the socket.
+
+  [ Chris Townsend ]
+  * Only set the LXC log file when the container is about to start.
+    (LP: #1596020)
+  * Add a new ContainersConfig Python class for managing all things
+    ContainersConfig.json.
+  * Refactor host information into a new HostInfo class.
+  * Check if the LXC container is defined before trying to start it.
+
+  [ Larry Price ]
+  * Remove dependency on DISPLAY variable and use random string to generate
+    session socket path.
+  * Prevent showing multiple error dialogs when adding archive fails.
+    (LP: #1594957)
+  * Only generate translations when manually running `make translations`.
+  * Ensure /usr/games is in PATH before launching applications. (LP: #1598227)
+  * Make error details selectable and add clipboard button. (LP: #1598786)
+  * Use dialog instead of ActionSelectionPopover to address focusing issues
+    when installing packages.
+  * Verify host kernel has lxc support. (LP: #1599193)
+  * Set DEBIAN_FRONTEND directly in environment for chroot containers.
+    (LP: #1599246)
+
+ -- Chris Townsend <[e-mail]>  Thu, 07 Jul 2016 15:08:59 -0400
+
 libertine (1.2.1+16.10.20160623-0ubuntu1) yakkety; urgency=medium
 
   [ Chris Townsend ]

=== modified file 'debian/python3-libertine.install'
--- debian/python3-libertine.install	2015-12-15 15:46:58 +0000
+++ debian/python3-libertine.install	2016-07-07 20:14:07 +0000
@@ -1,4 +1,6 @@
 usr/lib/python*/*/libertine/AppDiscovery.py
 usr/lib/python*/*/libertine/Libertine.py
+usr/lib/python*/*/libertine/ContainersConfig.py
+usr/lib/python*/*/libertine/HostInfo.py
 usr/lib/python*/*/libertine/utils.py
 usr/lib/python*/*/libertine/__init__.py

=== modified file 'debian/rules'
--- debian/rules	2016-06-22 19:52:24 +0000
+++ debian/rules	2016-07-07 20:14:07 +0000
@@ -2,3 +2,6 @@
 
 %:
 	dh $@ --with python3,gir,click
+
+override_dh_auto_build:
+	dh_auto_build -- all translations

=== modified file 'libertine/qml/ExtraArchivesView.qml'
--- libertine/qml/ExtraArchivesView.qml	2016-05-19 17:56:43 +0000
+++ libertine/qml/ExtraArchivesView.qml	2016-07-07 20:14:07 +0000
@@ -126,25 +126,22 @@
     }
 
     function addArchive(archive) {
-        var comp = Qt.createComponent("ContainerManager.qml")
-        worker = comp.createObject(mainView)
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
         worker.finishedConfigure.connect(finishedConfigure)
         worker.error.connect(sendAddError)
-        error.connect(mainView.error)
         worker.configureContainer(mainView.currentContainer, containerConfigList.getContainerName(mainView.currentContainer), ["--add-archive", archive])
     }
 
     function deleteArchive(archive) {
-        var comp = Qt.createComponent("ContainerManager.qml")
-        worker = comp.createObject(mainView)
+        var worker = Qt.createComponent("ContainerManager.qml").createObject(mainView)
         worker.finishedConfigure.connect(finishedConfigure)
         worker.error.connect(sendDeleteError)
-        error.connect(mainView.error)
         worker.configureContainer(mainView.currentContainer, containerConfigList.getContainerName(mainView.currentContainer), ["--delete-archive", archive])
     }
 
     Component.onCompleted: {
         containerConfigList.configChanged.connect(reloadArchives)
+        error.connect(mainView.error)
     }
 
     Component.onDestruction: {

=== modified file 'libertine/qml/GenericErrorDialog.qml'
--- libertine/qml/GenericErrorDialog.qml	2016-05-10 14:55:15 +0000
+++ libertine/qml/GenericErrorDialog.qml	2016-07-07 20:14:07 +0000
@@ -22,11 +22,25 @@
 
 Dialog {
     id: genericErrorDialog
-    property var short_description: null
-    property var details: null
+    property string short_description: ""
+    property string details: ""
 
     title: short_description
-    text: details
+
+    TextEdit {
+        color: UbuntuColors.darkGrey
+        text: details
+        readOnly: true
+        selectByMouse: true
+        wrapMode: TextEdit.WordWrap
+    }
+
+    Button {
+        text: i18n.tr("Copy to Clipboard")
+        onClicked: {
+            Clipboard.push(details)
+        }
+    }
 
     Button {
         text: i18n.tr("Dismiss")

=== modified file 'libertine/qml/HomeView.qml'
--- libertine/qml/HomeView.qml	2016-06-08 21:36:14 +0000
+++ libertine/qml/HomeView.qml	2016-07-07 20:14:07 +0000
@@ -31,11 +31,11 @@
             Action {
                 id: settingsButton
                 iconName: "settings"
-                onTriggered: PopupUtils.open(settingsMenu, homeView)
+                onTriggered: PopupUtils.open(settingsMenu)
             },
             Action {
                 iconName: "add"
-                onTriggered: PopupUtils.open(addAppsMenu, homeView)
+                onTriggered: PopupUtils.open(addAppsMenu)
             }
         ]
     }
@@ -98,26 +98,28 @@
 
     Component {
         id: settingsMenu
-        ActionSelectionPopover {
-            actions: ActionList {
-                Action {
-                    text: i18n.tr("Manage Container")
-                    onTriggered: {
-                        pageStack.push(Qt.resolvedUrl("ManageContainer.qml"), {currentContainer: currentContainer})
-                    }
-                }
-                Action {
-                    text: i18n.tr("Container Information")
-                    onTriggered: {
-                        pageStack.push(Qt.resolvedUrl("ContainerInfoView.qml"), {currentContainer: currentContainer})
-                    }
-                }
-                Action {
-                    text: i18n.tr("Switch Container")
-                    onTriggered: {
-                        pageStack.pop()
-                        pageStack.push(Qt.resolvedUrl("ContainersView.qml"))
-                    }
+        Dialog {
+            id: settingsDialog
+            __closeOnDismissAreaPress: true
+            Button {
+                text: i18n.tr("Manage Container")
+                onTriggered: {
+                    PopupUtils.close(settingsDialog)
+                    pageStack.push(Qt.resolvedUrl("ManageContainer.qml"), {currentContainer: currentContainer})
+                }
+            }
+            Button {
+                text: i18n.tr("Container Information")
+                onTriggered: {
+                    PopupUtils.close(settingsDialog)
+                    pageStack.push(Qt.resolvedUrl("ContainerInfoView.qml"), {currentContainer: currentContainer})
+                }
+            }
+            Button {
+                text: i18n.tr("Switch Container")
+                onTriggered: {
+                    PopupUtils.close(settingsDialog)
+                    pageStack.pop()
                 }
             }
         }
@@ -125,27 +127,33 @@
 
     Component {
         id: addAppsMenu
-        ActionSelectionPopover {
-            id: addAppsActions
-            actions: ActionList {
-                Action {
-                    text: i18n.tr("Enter package name or Debian file")
-                    onTriggered: {
-                        PopupUtils.open(enterPackagePopup)
-                    }
-                }
-                Action {
-                    text: i18n.tr("Choose Debian package to install")
-                    onTriggered: {
-                        var packages = containerConfigList.getDebianPackageFiles()
-                        pageStack.push(Qt.resolvedUrl("DebianPackagePicker.qml"), {packageList: packages}) 
-                   }
-                }
-                Action {
-                    text: i18n.tr("Search archives for a package")
-                    onTriggered: {
-                        PopupUtils.open(Qt.resolvedUrl("SearchPackagesDialog.qml"))
-                    }
+        Dialog {
+            id: addAppsDialog
+            __closeOnDismissAreaPress: true
+
+            Button {
+                text: i18n.tr("Enter package name or Debian file")
+                width: parent.width
+                onClicked: {
+                    PopupUtils.close(addAppsDialog)
+                    PopupUtils.open(enterPackagePopup)
+                }
+            }
+            Button {
+                text: i18n.tr("Choose Debian package to install")
+                width: parent.width
+                onClicked: {
+                    PopupUtils.close(addAppsDialog)
+                    var packages = containerConfigList.getDebianPackageFiles()
+                    pageStack.push(Qt.resolvedUrl("DebianPackagePicker.qml"), {packageList: packages})
+                }
+            }
+            Button {
+                text: i18n.tr("Search archives for a package")
+                width: parent.width
+                onClicked: {
+                    PopupUtils.close(addAppsDialog)
+                    PopupUtils.open(Qt.resolvedUrl("SearchPackagesDialog.qml"))
                 }
             }
         }

=== modified file 'po/CMakeLists.txt'
--- po/CMakeLists.txt	2016-02-29 18:07:02 +0000
+++ po/CMakeLists.txt	2016-07-07 20:14:07 +0000
@@ -1,7 +1,6 @@
 set (GETTEXT_PACKAGE "libertine")
 
 intltool_update_potfile(
-  ALL
   UBUNTU_SDK_DEFAULTS
   POTFILES_TEMPLATE POTFILES.in.in
   COPYRIGHT_HOLDER "Canonical Ltd."
@@ -9,14 +8,12 @@
 )
 
 intltool_install_translations(
-  ALL
   GETTEXT_PACKAGE ${GETTEXT_PACKAGE}
 )
 
 file(GLOB_RECURSE ALL_POFILES "*.po")
 
 add_custom_target(potfiles
-  ALL
   SOURCES
     POTFILES.in.in
     ${GETTEXT_PACKAGE}.pot

=== modified file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	2016-06-15 18:10:05 +0000
+++ python/libertine/ChrootContainer.py	2016-07-07 20:14:07 +0000
@@ -17,6 +17,7 @@
 import shlex
 import shutil
 import subprocess
+
 from .Libertine import BaseContainer
 from . import utils
 
@@ -53,10 +54,7 @@
 
     def run_in_container(self, command_string):
         cmd_args = shlex.split(command_string)
-        if self.get_container_distro(self.container_id) == "trusty":
-            command_prefix = self._build_privileged_proot_cmd()
-        else:
-            command_prefix = "fakechroot fakeroot chroot " + self.root_path
+        command_prefix = "fakechroot fakeroot chroot " + self.root_path
         args = shlex.split(command_prefix + ' ' + command_string)
         cmd = subprocess.Popen(args)
         return cmd.wait()
@@ -66,15 +64,9 @@
         shutil.rmtree(container_root)
 
     def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
-        installed_release = self.get_container_distro(self.container_id)
-        architecture = utils.get_host_architecture()
-
         # Create the actual chroot
-        if installed_release == "trusty":
-            command_line = "debootstrap --verbose " + installed_release + " " + self.root_path
-        else:
-            command_line = "fakechroot fakeroot debootstrap --verbose --variant=fakechroot {} {}".format(
-                    installed_release, self.root_path)
+        command_line = "fakechroot fakeroot debootstrap --verbose --variant=fakechroot {} {}".format(
+                    self.installed_release, self.root_path)
         args = shlex.split(command_line)
         cmd = subprocess.Popen(args)
         cmd.wait()
@@ -84,25 +76,24 @@
             self.destroy_libertine_container()
             return False
 
-        # Remove symlinks as they can ill-behaved recursive behavior in the chroot
-        if installed_release != "trusty":
-            print("Fixing chroot symlinks...")
-            os.remove(os.path.join(self.root_path, 'dev'))
-            os.remove(os.path.join(self.root_path, 'proc'))
+        # Remove symlinks as they can cause ill-behaved recursive behavior in the chroot
+        print("Fixing chroot symlinks...")
+        os.remove(os.path.join(self.root_path, 'dev'))
+        os.remove(os.path.join(self.root_path, 'proc'))
 
-            with open(os.path.join(self.root_path, 'usr', 'sbin', 'policy-rc.d'), 'w+') as fd:
-                fd.write("#!/bin/sh\n\n")
-                fd.write("while true; do\n")
-                fd.write("case \"$1\" in\n")
-                fd.write("  -*) shift ;;\n")
-                fd.write("  makedev) exit 0;;\n")
-                fd.write("  *)  exit 101;;\n")
-                fd.write("esac\n")
-                fd.write("done\n")
-                os.fchmod(fd.fileno(), 0o755)
+        with open(os.path.join(self.root_path, 'usr', 'sbin', 'policy-rc.d'), 'w+') as fd:
+            fd.write("#!/bin/sh\n\n")
+            fd.write("while true; do\n")
+            fd.write("case \"$1\" in\n")
+            fd.write("  -*) shift ;;\n")
+            fd.write("  makedev) exit 0;;\n")
+            fd.write("  *)  exit 101;;\n")
+            fd.write("esac\n")
+            fd.write("done\n")
+            os.fchmod(fd.fileno(), 0o755)
 
         # Add universe, multiverse, and -updates to the chroot's sources.list
-        if (utils.get_host_architecture() == 'armhf'):
+        if (self.architecture == 'armhf'):
             archive = "deb http://ports.ubuntu.com/ubuntu-ports "
         else:
             archive = "deb http://archive.ubuntu.com/ubuntu "
@@ -110,52 +101,15 @@
         if verbosity == 1:
             print("Updating chroot's sources.list entries...")
         with open(os.path.join(self.root_path, 'etc', 'apt', 'sources.list'), 'a') as fd:
-            fd.write(archive + installed_release + "-updates main\n")
-            fd.write(archive + installed_release + " universe\n")
-            fd.write(archive + installed_release + "-updates universe\n")
-            fd.write(archive + installed_release + " multiverse\n")
-            fd.write(archive + installed_release + "-updates multiverse\n")
+            fd.write(archive + self.installed_release + "-updates main\n")
+            fd.write(archive + self.installed_release + " universe\n")
+            fd.write(archive + self.installed_release + "-updates universe\n")
+            fd.write(archive + self.installed_release + " multiverse\n")
+            fd.write(archive + self.installed_release + "-updates multiverse\n")
 
         utils.create_libertine_user_data_dir(self.container_id)
 
-        if installed_release == "trusty":
-            print("Additional configuration for Trusty chroot...")
-
-            cmd_line_prefix = self._build_privileged_proot_cmd()
-
-            command_line = cmd_line_prefix + " dpkg-divert --local --rename --add /etc/init.d/systemd-logind"
-            args = shlex.split(command_line)
-            cmd = subprocess.Popen(args).wait()
-
-            command_line = cmd_line_prefix + " dpkg-divert --local --rename --add /sbin/initctl"
-            args = shlex.split(command_line)
-            cmd = subprocess.Popen(args).wait()
-
-            command_line = cmd_line_prefix + " dpkg-divert --local --rename --add /sbin/udevd"
-            args = shlex.split(command_line)
-            cmd = subprocess.Popen(args).wait()
-
-            command_line = cmd_line_prefix + " dpkg-divert --local --rename --add /usr/sbin/rsyslogd"
-            args = shlex.split(command_line)
-            cmd = subprocess.Popen(args).wait()
-
-            command_line = cmd_line_prefix + " ln -s /bin/true /etc/init.d/systemd-logind"
-            args = shlex.split(command_line)
-            cmd = subprocess.Popen(args).wait()
-
-            command_line = cmd_line_prefix + " ln -s /bin/true /sbin/initctl"
-            args = shlex.split(command_line)
-            cmd = subprocess.Popen(args).wait()
-
-            command_line = cmd_line_prefix + " ln -s /bin/true /sbin/udevd"
-            args = shlex.split(command_line)
-            cmd = subprocess.Popen(args).wait()
-
-            command_line = cmd_line_prefix + " ln -s /bin/true /usr/sbin/rsyslogd"
-            args = shlex.split(command_line)
-            cmd = subprocess.Popen(args).wait()
-
-        if multiarch and architecture == 'amd64':
+        if multiarch and self.architecture == 'amd64':
             if verbosity == 1:
                 print("Adding i386 multiarch support...")
             self.run_in_container("dpkg --add-architecture i386")
@@ -170,7 +124,7 @@
                 self.destroy_libertine_container()
                 return False
 
-        if installed_release == "vivid":
+        if self.installed_release == "vivid":
             if verbosity == 1:
                 print("Installing the Vivid Stable Overlay PPA...")
             self.run_in_container("add-apt-repository ppa:ci-train-ppa-service/stable-phone-overlay -y")

=== added file 'python/libertine/ContainersConfig.py'
--- python/libertine/ContainersConfig.py	1970-01-01 00:00:00 +0000
+++ python/libertine/ContainersConfig.py	2016-07-07 20:14:07 +0000
@@ -0,0 +1,309 @@
+# 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 fcntl
+import json
+import libertine.utils
+import os
+import sys
+
+
+def read_container_config_file():
+    container_list = {}
+    container_config_file = libertine.utils.get_libertine_database_file_path()
+
+    if (os.path.exists(container_config_file) and
+        os.path.getsize(container_config_file) != 0):
+        with open(container_config_file, 'r') as fd:
+            container_list = json.load(fd)
+
+    return container_list
+
+
+def write_container_config_file(container_list):
+    container_config_file = libertine.utils.get_libertine_database_file_path()
+
+    with open(container_config_file, 'w') as fd:
+        fcntl.lockf(fd, fcntl.LOCK_EX)
+        json.dump(container_list, fd, sort_keys=True, indent=4)
+        fd.write('\n')
+        fcntl.lockf(fd, fcntl.LOCK_UN)
+
+
+class ContainersConfig(object):
+
+    def __init__(self):
+        self.container_list = read_container_config_file()
+
+        if "defaultContainer" in self.container_list:
+            self.default_container_id = self.container_list['defaultContainer']
+        else:
+            self.default_container_id = None
+
+    """
+    Private helper methods
+    """
+    def _get_container_entry(self, container_id):
+        if not self.container_list:
+            return None
+
+        for container in self.container_list['containerList']:
+            if container['id'] == container_id:
+                return container
+
+        return None
+
+    def _get_value_by_key(self, container_id, key):
+        container = self._get_container_entry(container_id)
+
+        if not container or key not in container:
+            return None
+        else:
+            return container[key]
+
+    def _get_array_object_value_by_key(self, container_id, array_key, object_key, matcher, key):
+        for item in self._get_value_by_key(container_id, array_key):
+            if item[object_key] == matcher:
+                return item[key]
+
+    def _set_value_by_key(self, container_id, key, value):
+        container = self._get_container_entry(container_id)
+
+        if not container:
+            return
+
+        if type(value) is str:
+            container[key] = value
+        elif type(value) is dict:
+            if key not in container:
+                container[key] = [value]
+            else:
+                container[key].append(value)
+
+        write_container_config_file(self.container_list)
+
+    def _set_array_object_value_by_key(self, container_id, array_key, object_key, matcher, key, value):
+        container = self._get_container_entry(container_id)
+
+        if not container:
+            return
+
+        for item in container[array_key]:
+            if item[object_key] == matcher:
+                item[key] = value
+                write_container_config_file(self.container_list)
+                return
+
+    def _delete_array_object_by_key_value(self, container_id, array_key, object_key, value):
+        container = self._get_container_entry(container_id)
+
+        if not container:
+            return
+
+        for item in container[array_key]:
+            if item[object_key] == value:
+                container[array_key].remove(item)
+                write_container_config_file(self.container_list)
+                return    
+
+    def _test_key_value_exists(self, container_id, key, value=None):
+        key_value = self._get_value_by_key(container_id, key)
+
+        if not key_value:
+            return False
+        elif key == 'id':
+            return True
+        elif key_value == value:
+            return True
+        else:
+            return False
+
+    def _test_array_object_key_value_exists(self, container_id, array_key, object_key, value):
+        array = self._get_value_by_key(container_id, array_key)
+
+        if not array:
+            return False
+
+        for item in array:
+            if item[object_key] == value:
+                return True
+
+        return False
+
+    """
+    Miscellaneous ContainersConfig.json operations
+    """
+    def _find_duplicate_container_entry(self, container_list, container_id):
+        for container in container_list['containerList']:
+            if container['id'] == container_id:
+                return container
+
+        return None 
+
+    def merge_container_config_files(self, filepath):
+        merged_json = []
+
+        with open(filepath, 'r') as fd:
+            merge_source = json.load(fd)
+
+        if "containerList" in self.container_list:
+            # Finds any duplicate entries and assumes we want to update the main config
+            # with entries from the merge source.
+            for i, container in enumerate(self.container_list['containerList']):
+                merge_container = self._find_duplicate_container_entry(merge_source, container['id'])
+                if merge_container:
+                    self.container_list['containerList'][i] = merge_container
+                    merge_source['containerList'].remove(merge_container)
+
+            # Merges in any remaining non-duplicate entries.
+            for container in merge_source['containerList']:
+                self.container_list['containerList'].append(container)
+
+        else:
+            self.container_list = merge_source
+
+        write_container_config_file(self.container_list)
+
+    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)
+            sys.exit(1)
+        elif not container_id:
+            return self.get_default_container_id()
+
+        return container_id
+
+    def get_default_container_id(self):
+        return self.default_container_id
+
+    def set_default_container_id(self, container_id, write_json=False):
+        self.default_container_id = container_id
+        self.container_list['defaultContainer'] = container_id
+
+        if write_json:
+            write_container_config_file(self.container_list)
+
+    def clear_default_container_id(self, write_json=False):
+        self.default_container_id = None
+        self.container_list.pop('defaultContainer', None)
+
+        if write_json:
+            write_container_config_file(self.container_list)        
+
+    """
+    Operations for the container itself.
+    """
+    def add_new_container(self, container_id, container_name, container_type, container_distro):
+        container_obj = {'id': container_id, 'installStatus': 'new', 'type': container_type,
+                         'distro': container_distro, 'name': container_name, 'installedApps': []}
+
+        if "defaultContainer" not in self.container_list:
+            self.set_default_container_id(container_id)
+
+        if "containerList" not in self.container_list:
+            self.container_list['containerList'] = [container_obj]
+        else:
+            self.container_list['containerList'].append(container_obj)
+
+        write_container_config_file(self.container_list)
+
+    def delete_container(self, container_id):
+        if not self.container_list:
+            print("Unable to delete container.  No containers defined.")
+            sys.exit(1)
+
+        container = self._get_container_entry(container_id)
+
+        self.container_list['containerList'].remove(container)
+
+        # Set a new defaultContainer if the current default is being deleted.
+        if self.container_list['defaultContainer'] == container_id and self.container_list['containerList']:
+            self.set_default_container_id(self.container_list['containerList'][0]['id'])
+        # Remove the defaultContainer if there are no more containers left.
+        elif not self.container_list['containerList']:
+            self.clear_default_container_id()
+
+        write_container_config_file(self.container_list)
+
+    def update_container_install_status(self, container_id, new_status):
+        self._set_value_by_key(container_id, 'installStatus', new_status)
+
+    def container_exists(self, container_id):
+        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':
+            multiarch = 'disabled'
+
+        self._set_value_by_key(container_id, 'multiarch', multiarch)
+
+    def get_container_multiarch_support(self, container_id):
+        multiarch_support = self._get_value_by_key(container_id, 'multiarch')
+
+        if multiarch_support == None:
+            return 'disabled'
+        else:
+            return multiarch_support
+
+    """
+    Operations for archive (PPA) maintenance in a Libertine container.
+    """
+    def add_container_archive(self, container_id, archive_name):
+        archive_obj = {'archiveName': archive_name, 'archiveStatus': 'new'}
+        self._set_value_by_key(container_id, 'extraArchives', archive_obj) 
+
+    def delete_container_archive(self, container_id, archive_name):
+        self._delete_array_object_by_key_value(container_id, 'extraArchives',
+                                               'archiveName', archive_name)
+
+    def update_archive_install_status(self, container_id, archive_name, new_status):
+        self._set_array_object_value_by_key(container_id, 'extraArchives', 'archiveName',
+                                            archive_name, 'archiveStatus', new_status)
+
+    def archive_exists(self, container_id, archive_name):
+        return self._test_array_object_key_value_exists(container_id, 'extraArchives', 'archiveName',
+                                                        archive_name)
+
+    """
+    Operations for package maintenance in a Libertine container.
+    """
+    def add_new_package(self, container_id, package_name):
+        package_obj = {'packageName': package_name, 'appStatus': 'new'}
+        self._set_value_by_key(container_id, 'installedApps', package_obj)
+
+    def delete_package(self, container_id, package_name):
+        self._delete_array_object_by_key_value(container_id, 'installedApps',
+                                               'packageName', package_name)
+
+    def update_package_install_status(self, container_id, package_name, new_status):
+        self._set_array_object_value_by_key(container_id, 'installedApps', 'packageName',
+                                            package_name, 'appStatus', new_status)
+
+    def get_package_install_status(self, container_id, package_name):
+        return self._get_array_object_value_by_key(container_id, 'installedApps', 'packageName',
+                                                   package_name, 'appStatus')
+
+    def package_exists(self, container_id, package_name):
+        return self._test_array_object_key_value_exists(container_id, 'installedApps', 'packageName',
+                                                        package_name)
+
+    """
+    Fetcher functions for various configuration information.
+    """
+    def get_container_distro(self, container_id):
+        return self._get_value_by_key(container_id, 'distro')
+
+    def get_container_type(self, container_id):
+        return self._get_value_by_key(container_id, 'type')
+

=== added file 'python/libertine/HostInfo.py'
--- python/libertine/HostInfo.py	1970-01-01 00:00:00 +0000
+++ python/libertine/HostInfo.py	2016-07-07 20:14:07 +0000
@@ -0,0 +1,71 @@
+# 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 lsb_release
+import platform
+import subprocess
+
+from distro_info import UbuntuDistroInfo
+
+
+class HostInfo(object):
+
+    def select_container_type_by_kernel(self):
+        if self.has_lxc_support():
+            return "lxc"
+        else:
+            return "chroot"
+
+    def has_lxc_support(self):
+        kernel_release = platform.release().split('.')
+        return int(kernel_release[0]) >= 4 or (int(kernel_release[0]) == 3 and int(kernel_release[1]) >= 13)
+
+    def get_host_distro_release(self):
+        distinfo = lsb_release.get_distro_information()
+
+        return distinfo.get('CODENAME', 'n/a')
+
+    def is_distro_valid(self, distro, force):
+        if force:
+            return UbuntuDistroInfo().valid(distro)
+
+        if distro == self.get_host_distro_release():
+            return True
+
+        supported_distros = UbuntuDistroInfo().supported()
+
+        try:
+            supported_distros.index(distro)
+        except ValueError:
+            return False
+
+        return True
+
+    def get_distro_codename(self, distro):
+        ubuntu_distro_info = UbuntuDistroInfo()
+
+        for row in ubuntu_distro_info._rows:
+            if row['series'] == distro:
+                return row['codename']
+
+        return None
+
+    def get_host_architecture(self):
+        dpkg = subprocess.Popen(['dpkg', '--print-architecture'],
+                                stdout=subprocess.PIPE,
+                                universal_newlines=True)
+        if dpkg.wait() != 0:
+            parser.error("Failed to determine the local architecture.")
+
+        return dpkg.stdout.read().strip()

=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2016-06-14 20:05:24 +0000
+++ python/libertine/Libertine.py	2016-07-07 20:14:07 +0000
@@ -16,30 +16,12 @@
 from gi.repository import Libertine
 import abc
 import contextlib
-import json
 import libertine.utils
 import os
 import shutil
 
-
-def get_container_type(container_id):
-    """
-    Retrieves the type of container for a given container ID.
-    :param container_id: The Container ID to search for.
-    """
-    try:
-        with open(libertine.utils.get_libertine_database_file_path()) as fd:
-            container_list = json.load(fd)
-
-        for container in container_list["containerList"]:
-            if container["id"] == container_id:
-                return container["type"]
-
-    except FileNotFoundError:
-        pass
-
-    # Return lxc as the default container type
-    return "lxc"
+from libertine.ContainersConfig import ContainersConfig
+from libertine.HostInfo import HostInfo
 
 
 def apt_args_for_verbosity_level(verbosity):
@@ -175,10 +157,9 @@
 
             return ret
         else:
-            cmd = apt_command_prefix(verbosity) + " install '" + package_name + "'"
             if readline:
-                cmd = "env DEBIAN_FRONTEND=readline " + cmd
-            return self.run_in_container(cmd) == 0
+                os.environ['DEBIAN_FRONTEND'] = 'readline'
+            return self.run_in_container(apt_command_prefix(verbosity) + " install '" + package_name + "'") == 0
 
     def configure_command(self, command, *args, verbosity=1):
         """
@@ -207,21 +188,6 @@
         elif command == 'delete-archive':
             return self.run_in_container("add-apt-repository -y -r " + args[0])
 
-    def get_container_distro(self, container_id):
-        """
-        Retrieves the distro code name for a given container ID.
-
-        :param container_id: The Container ID to search for.
-        """
-        with open(libertine.utils.get_libertine_database_file_path()) as fd:
-            container_list = json.load(fd)
-
-        for container in container_list["containerList"]:
-            if container["id"] == container_id:
-                return container["distro"]
-
-        return ""
-
     @property
     def name(self):
         """
@@ -281,9 +247,9 @@
         """
         super().__init__()
 
-        container_type = get_container_type(container_id)
+        container_type = ContainersConfig().get_container_type(container_id)
 
-        if container_type == "lxc":
+        if container_type == None or container_type == "lxc":
             from  libertine.LxcContainer import LibertineLXC
             self.container = LibertineLXC(container_id)
         elif container_type == "chroot":
@@ -320,6 +286,9 @@
         """
         Creates the container.
         """
+        self.container.architecture = HostInfo().get_host_architecture()
+        self.container.installed_release = ContainersConfig().get_container_distro(self.container_id)
+
         return self.container.create_libertine_container(password, multiarch, verbosity)
 
     def update_libertine_container(self, verbosity=1):
@@ -351,10 +320,10 @@
         """
         try:
             with ContainerRunning(self.container):
-                cmd = apt_command_prefix(verbosity) + " purge '" + package_name + "'"
                 if readline:
-                    cmd = "env DEBIAN_FRONTEND=readline " + cmd
-                if self.container.run_in_container(cmd) != 0:
+                    os.environ['DEBIAN_FRONTEND'] = 'readline'
+
+                if self.container.run_in_container(apt_command_prefix(verbosity) + " purge '" + package_name + "'") != 0:
                     return False
                 return self.container.run_in_container(apt_command_prefix(verbosity) + "autoremove --purge") == 0
         except RuntimeError as e:
@@ -380,7 +349,11 @@
         :param app_exec_line: the application exec line as passed in by
             ubuntu-app-launch
         """
-        if libertine.utils.container_exists(self.container.container_id):
+        if ContainersConfig().container_exists(self.container.container_id):
+            # Update $PATH as necessary
+            if '/usr/games' not in os.environ['PATH']:
+                os.environ['PATH'] = os.environ['PATH'] + ":/usr/games"
+
             self.container.launch_application(app_exec_line)
         else:
             raise RuntimeError("Container with id %s does not exist." % self.container.container_id)

=== modified file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	2016-06-22 16:26:15 +0000
+++ python/libertine/LxcContainer.py	2016-07-07 20:14:07 +0000
@@ -18,6 +18,7 @@
 import psutil
 import shlex
 import subprocess
+import sys
 import tempfile
 
 from .Libertine import BaseContainer
@@ -85,11 +86,6 @@
         self.container_type = "lxc"
         self.container = lxc_container(container_id)
 
-        if self.container.defined:
-            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 is_running(self):
         return self.container.running
 
@@ -105,7 +101,11 @@
             return True
 
     def start_container(self):
+        if not self.container.defined:
+            raise RuntimeError("Container %s is not valid" % self.container_id)
+
         if not self.container.running:
+            self._set_lxc_log()
             if not self.container.start():
                 self._dump_lxc_log()
                 raise RuntimeError("Container failed to start")
@@ -147,8 +147,6 @@
         if password is None:
             return False
 
-        installed_release = self.get_container_distro(self.container_id)
-
         username = os.environ['USER']
         user_id = os.getuid()
         group_id = os.getgid()
@@ -177,13 +175,10 @@
 
         utils.create_libertine_user_data_dir(self.container_id)
 
-        # Figure out the host architecture
-        architecture = utils.get_host_architecture()
-
         if not self.container.create("download", 0,
                                      {"dist": "ubuntu",
-                                      "release": installed_release,
-                                      "arch": architecture}):
+                                      "release": self.installed_release,
+                                      "arch": self.architecture}):
             print("Failed to create container")
             return False
 
@@ -202,7 +197,7 @@
         self.run_in_container("useradd -u {} -p {} -G sudo {}".format(
                 str(user_id), crypt.crypt(password), str(username)))
 
-        if multiarch and architecture == 'amd64':
+        if multiarch and self.architecture == 'amd64':
             if verbosity == 1:
                 print("Adding i386 multiarch support...")
             self.run_in_container("dpkg --add-architecture i386")
@@ -308,7 +303,15 @@
         data = libertine_lxc_mgr_sock.recv(1024)
         libertine_lxc_mgr_sock.close()
 
+    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):
-        with open(self.lxc_log_file, 'r') as fd:
-            for line in fd:
-                print(line.lstrip())
+        try:
+            with open(self.lxc_log_file, 'r') as fd:
+                for line in fd:
+                    print(line.lstrip())
+        except Exception as ex:
+            print("Could not open LXC log file: %s" % ex, file=sys.stderr)

=== modified file 'python/libertine/utils.py'
--- python/libertine/utils.py	2016-06-23 13:27:26 +0000
+++ python/libertine/utils.py	2016-07-07 20:14:07 +0000
@@ -16,9 +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 json
 import os
-import psutil
 import shlex
 import subprocess
 import xdg.BaseDirectory as basedir
@@ -28,22 +26,6 @@
 from gi.repository import Libertine
 
 
-def container_exists(container_id):
-    container_config_file_path = get_libertine_database_file_path()
-
-    if (os.path.exists(container_config_file_path) and
-        os.path.getsize(container_config_file_path) != 0):
-        with open(get_libertine_database_file_path()) as fd:
-            container_list = json.load(fd)
-
-        if container_list:
-            for container in container_list['containerList']:
-                if container['id'] == container_id:
-                    return True
-
-    return False
-
-
 def get_libertine_container_rootfs_path(container_id):
     path = Libertine.container_path(container_id)
 
@@ -97,16 +79,6 @@
     return os.path.join(get_user_runtime_dir(), 'libertine')
 
 
-def get_host_architecture():
-    dpkg = subprocess.Popen(['dpkg', '--print-architecture'],
-                            stdout=subprocess.PIPE,
-                            universal_newlines=True)
-    if dpkg.wait() != 0:
-        parser.error("Failed to determine the local architecture.")
-
-    return dpkg.stdout.read().strip()
-
-
 def get_common_xdg_directories():
     return ['Documents', 'Music', 'Pictures', 'Videos', 'Downloads']
 
@@ -167,4 +139,4 @@
     gdbus_cmd = ("gdbus emit --session --object-path %s --signal %s %s" %
                  (scopes_object_path, invalidate_signal, libertine_scope_id))
 
-    subprocess.Popen(shlex.split(gdbus_cmd))
+    subprocess.Popen(shlex.split(gdbus_cmd), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

=== modified file 'tests/unit/CMakeLists.txt'
--- tests/unit/CMakeLists.txt	2015-12-21 21:02:33 +0000
+++ tests/unit/CMakeLists.txt	2016-07-07 20:14:07 +0000
@@ -44,10 +44,14 @@
                      ENVIRONMENT
                      "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
 
-add_test(test_libertine_launch
-  "/usr/bin/python3" "-m" "testtools.run" "libertine_launch_tests"
-)
-set_tests_properties(test_libertine_launch
-                     PROPERTIES
-                     ENVIRONMENT
-                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
+set(DISABLED 1)
+
+if (NOT DISABLED)
+    add_test(test_libertine_launch
+      "/usr/bin/python3" "-m" "testtools.run" "libertine_launch_tests"
+    )
+    set_tests_properties(test_libertine_launch
+                         PROPERTIES
+                         ENVIRONMENT
+                         "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
+endif()

=== modified file 'tools/libertine-container-manager'
--- tools/libertine-container-manager	2016-06-20 15:15:38 +0000
+++ tools/libertine-container-manager	2016-07-07 20:14:07 +0000
@@ -17,637 +17,270 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import argparse
-import fcntl
-import json
 import libertine.utils
-import lsb_release
 import getpass
 import os
-import platform
 import sys
 
 from apt.debfile import DebPackage
-from distro_info import UbuntuDistroInfo, DistroDataOutdated
 from libertine import LibertineContainer
-
-
-def find_duplicate_container_entry(container_list, container_id):
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            return container
-
-    return None
-
-
-def merge_container_config_files(filepath):
-    merged_json = []
-    main_config = read_container_config_file()
-
-    with open(filepath, 'r') as fd:
-        merge_source = json.load(fd)
-
-    if "containerList" in main_config:
-        # Finds any duplicate entries and assumes we want to update the main config
-        # with entries from the merge source.
-        for i, container in enumerate(main_config['containerList']):
-            merge_container = find_duplicate_container_entry(merge_source, container['id'])
-            if merge_container:
-                 main_config['containerList'][i] = merge_container
-                 merge_source['containerList'].remove(merge_container)
-
-        # Merges in any remaining non-duplicate entries.
-        for container in merge_source['containerList']:
-            main_config['containerList'].append(container)
-
-    else:
-        main_config = merge_source
-
-    write_container_config_file(main_config)
-
-
-def read_container_config_file():
-    container_list = {}
-    container_config_file = libertine.utils.get_libertine_database_file_path()
-
-    if (os.path.exists(container_config_file) and
-        os.path.getsize(container_config_file) != 0):
-        with open(container_config_file, 'r') as fd:
-            container_list = json.load(fd)
-
-    return container_list
-
-
-def write_container_config_file(container_list):
-    container_config_file = libertine.utils.get_libertine_database_file_path()
-
-    with open(container_config_file, 'w') as fd:
-        fcntl.lockf(fd, fcntl.LOCK_EX)
-        json.dump(container_list, fd, sort_keys=True, indent=4)
-        fd.write('\n')
-        fcntl.lockf(fd, fcntl.LOCK_UN)
-
-
-def get_default_container_id():
-    default_container_id = None
-
-    container_list = read_container_config_file()
-
-    if "defaultContainer" in container_list:
-        default_container_id = container_list['defaultContainer']
-
-    return default_container_id
-
-
-def select_container_type():
-    kernel_release = platform.release().split('.')
-
-    if int(kernel_release[0]) >= 4:
-        return "lxc"
-    elif int(kernel_release[0]) == 3 and int(kernel_release[1]) >= 13:
-        return "lxc"
-    else:
-        return "chroot"
-
-
-def get_host_distro_release():
-    distinfo = lsb_release.get_distro_information()
-
-    return distinfo.get('CODENAME', 'n/a')
-
-
-def is_distro_valid(distro, force):
-    if force:
-        return UbuntuDistroInfo().valid(distro)
-
-    if distro == get_host_distro_release():
-        return True
-
-    supported_distros = UbuntuDistroInfo().supported()
-
-    try:
-        supported_distros.index(distro)
-    except ValueError:
-        return False
-
-    return True
-
-
-def get_distro_codename(distro):
-    ubuntu_distro_info = UbuntuDistroInfo()
-
-    for row in ubuntu_distro_info._rows:
-        if row['series'] == distro:
-            return row['codename']
-
-    return None
-
-
-def update_container_install_status(container_id, new_status):
-    container_list = read_container_config_file()
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            container['installStatus'] = new_status
-
-            write_container_config_file(container_list)
-            break
-
-
-def update_container_multiarch_support(container_id, multiarch):
-    container_list = read_container_config_file()
-
-    if multiarch == 'enabled' and libertine.utils.get_host_architecture() == 'i386':
-        multiarch = 'disabled'
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            container['multiarch'] = multiarch
-
-            write_container_config_file(container_list)
-            break
-
-
-def get_container_multiarch_support(container_id):
-    container_list = read_container_config_file()
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            if not 'multiarch' in container:
-                return 'disabled'
-            else:
-                return container['multiarch']
-
-
-def update_archive_install_status(container_id, archive_name, new_status):
-    container_list = read_container_config_file()
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            for archive in container['extraArchives']:
-                if archive['archiveName'] == archive_name:
-                    archive['archiveStatus'] = new_status
-                    write_container_config_file(container_list)
-                    return
-
-
-def add_container_archive(container_id, archive_name):
-    container_list = read_container_config_file()
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            archive_obj = {'archiveName': archive_name, 'archiveStatus': 'new'}
-
-            if 'extraArchives' not in container:
-                container['extraArchives'] = [archive_obj]
-            else:
-                container['extraArchives'].append(archive_obj)
-
-            write_container_config_file(container_list)
-            break
-
-
-def delete_container_archive(container_id, archive_name):
-    container_list = read_container_config_file()
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            for archive in container['extraArchives']:
-                if archive['archiveName'] == archive_name:
-                    container['extraArchives'].remove(archive)
-                    write_container_config_file(container_list)
-                    return
-
-    print("%s does not exist." % archive_name)
-    sys.exit(1)
-
-
-def archive_exists(container_id, archive_name):
-    container_list = read_container_config_file()
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            if 'extraArchives' not in container:
-                return False
-            else:
-                for archive in container['extraArchives']:
-                    if archive['archiveName'] == archive_name:
-                        return True
-
-    return False
-
-
-def add_new_container(id, name, type, distro):
-    if not os.path.exists(libertine.utils.get_libertine_database_dir_path()):
-        os.makedirs(libertine.utils.get_libertine_database_dir_path())
-
-    container_list = read_container_config_file()
-
-    container_obj = {'id': id, 'installStatus': 'new', 'type': type,
-                     'distro': distro, 'name': name, 'installedApps': []}
-
-    if "defaultContainer" not in container_list:
-        container_list['defaultContainer'] = id
-
-    if "containerList" not in container_list:
-        container_list['containerList'] = [container_obj]
-    else:
-        container_list['containerList'].append(container_obj)
-
-    write_container_config_file(container_list)
-
-
-def delete_container(container_id):
-    container_list = read_container_config_file()
-
-    if not container_list:
-        print("Unable to delete container.  No containers defined.")
-        sys.exit(1)
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            container_list['containerList'].remove(container)
-
-            # Set a new defaultContainer if the current default is being deleted.
-            if container_list['defaultContainer'] == container_id and container_list['containerList']:
-                container_list['defaultContainer'] = container_list['containerList'][0]['id']
-            # Remove the defaultContainer if there are no more containers left.
-            elif not container_list['containerList']:
-                del container_list['defaultContainer']
-
-            write_container_config_file(container_list)
-            break
-
-
-def package_exists(container_id, package_name):
-    container_list = read_container_config_file()
-
-    if not container_list:
-        return False
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            for package in container['installedApps']:
-                if package['packageName'] == package_name:
-                    return True
-
-    return False
-
-
-def update_package_install_status(container_id, package_name, new_status):
-    container_list = read_container_config_file()
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            for package in container['installedApps']:
-                if package['packageName'] == package_name:
-                    package['appStatus'] = new_status
-                    write_container_config_file(container_list)
-                    return
-
-
-def get_package_install_status(container_id, package_name):
-    container_list = read_container_config_file()
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            for package in container['installedApps']:
-                if package['packageName'] == package_name:
-                    return package['appStatus']
-
-
-def add_new_package(container_id, package_name):
-    container_list = read_container_config_file()
-
-    if not container_list:
-        print("No containers defined.  Please create a new container before installing a package.")
-        sys.exit(1)
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            package_obj = {'packageName': package_name, 'appStatus': 'new'}
-
-            if not container['installedApps']:
-                container['installedApps'] = [package_obj]
-            else:
-                container['installedApps'].append(package_obj)
-
-            write_container_config_file(container_list)
-            break
-
-
-def delete_package(container_id, package_name):
-    container_list = read_container_config_file()
-
-    if not container_list:
-        print("No containers defined.  Please create a new container before installing a package.")
-        sys.exit(1)
-
-    for container in container_list['containerList']:
-        if container['id'] == container_id:
-            for package in container['installedApps']:
-                if package['packageName'] == package_name:
-                    container['installedApps'].remove(package)
-                    write_container_config_file(container_list)
-                    return
-
-    print("Package \'%s\' does not exist." % package_name)
-    sys.exit(1)
-
-
-def create(args):
-    password = None
-
-    if args.distro and not is_distro_valid(args.distro, args.force):
-        print("Invalid distro %s" % args.distro, file=sys.stderr)
-        sys.exit(1)
-
-    if args.id and libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' is already used." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_unique_container_id(distro)
-
-    if not args.type:
-        container_type = select_container_type()
-    else:
-        container_type = args.type
-
-    if not args.distro:
-        args.distro = get_host_distro_release()
-    elif container_type == "chroot":
-        host_distro = 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."
-                  % host_distro)
-            sys.exit(1)
-
-    if not args.name:
-        args.name = "Ubuntu \'" + get_distro_codename(args.distro) + "\'"
-
-    if container_type == "lxc":
-        if args.password:
-            password = args.password
-        elif sys.stdin.isatty():
-            print("Your user password is required for creating a Libertine container.")
-            password = getpass.getpass()
-        else:
-            password = sys.stdin.readline().rstrip()
-
-    add_new_container(args.id, args.name, container_type, args.distro)
-
-    multiarch = 'disabled'
-    if args.multiarch:
-        multiarch = 'enabled'
-    update_container_multiarch_support(args.id, multiarch)
-
-    container = LibertineContainer(args.id)
-    update_container_install_status(args.id, "installing")
-    if not container.create_libertine_container(password, args.multiarch, args.verbosity):
-        delete_container(args.id)
-        sys.exit(1)
-    update_container_install_status(args.id, "ready")
-
-    libertine.utils.refresh_libertine_scope()
-
-
-def destroy_container_by_id(id):
-    container = LibertineContainer(id)
-    update_container_install_status(id, "removing")
-    container.destroy_libertine_container()
-    update_container_install_status(id, "removed")
-    delete_container(id)
-
-
-def destroy(args):
-    if args.id and not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_default_container_id()
-
-    destroy_container_by_id(args.id)
-
-    libertine.utils.refresh_libertine_scope()
-
-
-def install_package(args):
-    if args.id and not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_default_container_id()
-
-    is_debian_package = args.package.endswith('.deb')
-
-    if is_debian_package:
-        if os.path.exists(args.package):
-            package = DebPackage(args.package).pkgname
-        else:
-            print("%s does not exist." % args.package)
-            sys.exit(1)
-    else:
-        package = args.package
-
-    if package_exists(args.id, package):
-        if not is_debian_package:
-            print("Package \'%s\' is already installed." % package)
-            sys.exit(1)
-    else:
-        add_new_package(args.id, package)
-
-    container = LibertineContainer(args.id)
-
-    update_package_install_status(args.id, package, "installing")
-    if not container.install_package(args.package, args.verbosity, args.readline):
-        delete_package(args.id, package)
-        sys.exit(1)
-
-    update_package_install_status(args.id, package, "installed")
-
-    libertine.utils.refresh_libertine_scope()
-
-
-def remove_package_by_name(container_id, package_name, verbosity=1, readline=False):
-    fallback_status = get_package_install_status(container_id, package_name)
-    update_package_install_status(container_id, package_name, "removing")
-
-    container = LibertineContainer(container_id)
-    if not container.remove_package(package_name, verbosity, readline):
-        update_package_install_status(container_id, package_name, fallback_status)
-        return False
-
-    update_package_install_status(container_id, package_name, "removed")
-    delete_package(container_id, package_name)
-
-    return True
-
-
-def remove_package(args):
-    if args.id and not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_default_container_id()
-
-    if get_package_install_status(args.id, args.package) != 'installed':
-        print("Package \'%s\' is not installed." % args.package)
-        sys.exit(1)
-
-    if not remove_package_by_name(args.id, args.package, args.verbosity, args.readline):
-        sys.exit(1)
-
-    libertine.utils.refresh_libertine_scope()
-
-
-def search_cache(args):
-    if args.id and not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_default_container_id()
-
-    container = LibertineContainer(args.id)
-    if container.search_package_cache(args.search_string) is not 0:
-        sys.exit(1)
-
-
-def update(args):
-    if args.id and not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_default_container_id()
-
-    container = LibertineContainer(args.id)
-
-    update_container_install_status(args.id, "updating")
-    if container.update_libertine_container(args.verbosity) is not 0:
-        update_container_install_status(args.id, "ready")
-        sys.exit(1)
-
-    update_container_install_status(args.id, "ready")
-
-
-def list(args):
-    containers = libertine.utils.Libertine.list_containers()
-    for container in containers:
-        print("%s" % container)
-
-
-def list_apps(args):
-    if args.id and not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_default_container_id()
-
-    container = LibertineContainer(args.id)
-    print(container.list_app_launchers(use_json=args.json))
-
-
-def exec(args):
-    if args.id and not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_default_container_id()
-
-    container = LibertineContainer(args.id)
-
-    if not container.exec_command(args.command):
-        sys.exit(1)
-
-
-def delete_archive_by_name(container_id, archive_name):
-    update_archive_install_status(container_id, archive_name, 'removing')
-    if LibertineContainer(container_id).configure_command('delete-archive', archive_name) is not 0:
-        return False
-    delete_container_archive(container_id, archive_name)
-    return True
-
-
-def configure(args):
-    if args.id and not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-    elif not args.id:
-        args.id = get_default_container_id()
-
-    container = LibertineContainer(args.id)
-
-    if args.multiarch and libertine.utils.get_host_architecture() == 'amd64':
+from libertine.ContainersConfig import ContainersConfig
+from libertine.HostInfo import HostInfo
+
+
+class LibertineContainerManager(object):
+
+    def __init__(self):
+        self.containers_config = ContainersConfig()
+        self.host_info = HostInfo()
+
+    def create(self, args):
+        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)
+            sys.exit(1)
+
+        if args.id and self.containers_config.container_exists(args.id):
+            print("Container id \'%s\' is already used." % args.id, file=sys.stderr)
+            sys.exit(1)
+        elif not args.id:
+            args.id = get_unique_container_id(distro)
+
+        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.")
+                sys.exit(1)
+            container_type = args.type
+
+        if not args.distro:
+            args.distro = self.host_info.get_host_distro_release()
+        elif container_type == "chroot":
+            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."
+                      % host_distro)
+                sys.exit(1)
+
+        if not args.name:
+            args.name = "Ubuntu \'" + self.host_info.get_distro_codename(args.distro) + "\'"
+
+        if container_type == "lxc":
+            if args.password:
+                password = args.password
+            elif sys.stdin.isatty():
+                print("Your user password is required for creating a Libertine container.")
+                password = getpass.getpass()
+            else:
+                password = sys.stdin.readline().rstrip()
+
+        self.containers_config.add_new_container(args.id, args.name, container_type, args.distro)
+
         multiarch = 'disabled'
         if args.multiarch == 'enable':
             multiarch = 'enabled'
-
-        current_multiarch = get_container_multiarch_support(args.id)
-        if current_multiarch == multiarch:
-            print("i386 multiarch support is already %s" % multiarch)
-            sys.exit(1)
-
-        if container.configure_command('multiarch', args.multiarch) is not 0:
-            sys.exit(1)
-
-        update_container_multiarch_support(args.id, multiarch)
-
-    elif args.add_archive:
-        if archive_exists(args.id, args.add_archive):
-            print("%s already added in container." % args.add_archive)
-            sys.exit(1)
-
-        add_container_archive(args.id, args.add_archive)
-        update_archive_install_status(args.id, args.add_archive, 'installing')
-        if container.configure_command('add-archive', args.add_archive) is not 0:
-            delete_container_archive(args.id, args.add_archive)
-            sys.exit(1)
-
-        update_archive_install_status(args.id, args.add_archive, 'installed')
-
-    elif args.delete_archive:
-        if not archive_exists(args.id, args.delete_archive):
-            print("%s is not added in container." % args.delete_archive)
-            sys.exit(1)
-
-        if not delete_archive_by_name(args.id, args.delete_archive):
-            sys.exit(1)
-
-
-def merge(args):
-    merge_container_config_files(args.file)
-
-
-def fix_integrity(args):
-    for container in read_container_config_file()['containerList']:
-        if container['installStatus'] != 'ready':
-            destroy_container_by_id(container['id'])
-            continue
-        LibertineContainer(container['id']).exec_command('dpkg --configure -a')
-
-        for package in container['installedApps']:
-            if package['appStatus'] != 'installed':
-                remove_package_by_name(container['id'], package['packageName'])
-        if 'extraArchives' in container:
-            for archive in container['extraArchives']:
-                if archive['archiveStatus'] != 'installed':
-                    delete_archive_by_name(container['id'], archive['archiveName'])
-
-
-def set_default(args):
-    if args.clear:
-        container_list = read_container_config_file()
-        container_list.pop('defaultContainer', None)
-        write_container_config_file(container_list)
-        sys.exit(0)
-
-    if not libertine.utils.container_exists(args.id):
-        print("Container id \'%s\' does not exist." % args.id, file=sys.stderr)
-        sys.exit(1)
-
-    container_list = read_container_config_file()
-    container_list['defaultContainer'] = args.id
-    write_container_config_file(container_list)
+        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):
+            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()
+
+    def destroy_container_by_id(self, id):
+        container = LibertineContainer(id)
+
+        self.containers_config.update_container_install_status(id, "removing")
+        container.destroy_libertine_container()
+        self.containers_config.update_container_install_status(id, "removed")
+        self.containers_config.delete_container(id)
+
+    def destroy(self, args):
+        args.id = self.containers_config.check_container_id(args.id)
+
+        self.destroy_container_by_id(args.id)
+
+        libertine.utils.refresh_libertine_scope()
+
+    def install_package(self, args):
+        container_id = self.containers_config.check_container_id(args.id)
+
+        is_debian_package = args.package.endswith('.deb')
+
+        if is_debian_package:
+            if os.path.exists(args.package):
+                package = DebPackage(args.package).pkgname
+            else:
+                print("%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)
+                sys.exit(1)
+        else:
+            self.containers_config.add_new_package(container_id, package)
+
+        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.readline):
+            self.containers_config.delete_package(container_id, package)
+            sys.exit(1)
+
+        self.containers_config.update_package_install_status(container_id, package, "installed")
+
+        libertine.utils.refresh_libertine_scope()
+
+    def remove_package_by_name(self, container_id, package_name, verbosity=1, readline=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, readline) and fallback_status == 'installed':
+            self.containers_config.update_package_install_status(container_id, package_name, fallback_status)
+            return False
+
+        self.containers_config.update_package_install_status(container_id, package_name, "removed")
+        self.containers_config.delete_package(container_id, package_name)
+
+        return True
+
+    def remove_package(self, args):
+        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)
+            sys.exit(1)
+
+        if not self.remove_package_by_name(container_id, args.package, args.verbosity, args.readline):
+            sys.exit(1)
+
+        libertine.utils.refresh_libertine_scope()
+
+    def search_cache(self, args):
+        container_id = self.containers_config.check_container_id(args.id)
+
+        container = LibertineContainer(container_id)
+        if container.search_package_cache(args.search_string) is not 0:
+            sys.exit(1)
+
+    def update(self, args):
+        container_id = self.containers_config.check_container_id(args.id)
+
+        container = LibertineContainer(container_id)
+
+        self.containers_config.update_container_install_status(container_id, "updating")
+        if container.update_libertine_container(args.verbosity) is not 0:
+            self.containers_config.update_container_install_status(container_id, "ready")
+            sys.exit(1)
+
+        self.containers_config.update_container_install_status(container_id, "ready")
+
+    def list(self, args):
+        containers = libertine.utils.Libertine.list_containers()
+        for container in containers:
+            print("%s" % container)
+
+    def list_apps(self, args):
+        container_id = self.containers_config.check_container_id(args.id)
+
+        container = LibertineContainer(container_id)
+        print(container.list_app_launchers(use_json=args.json))
+
+    def exec(self, args):
+        container_id = self.containers_config.check_container_id(args.id)
+
+        container = LibertineContainer(container_id)
+
+        if not container.exec_command(args.command):
+            sys.exit(1)
+
+    def delete_archive_by_name(self, container_id, archive_name):
+        self.containers_config.update_archive_install_status(container_id, archive_name, 'removing')
+        if LibertineContainer(container_id).configure_command('delete-archive', archive_name) is not 0:
+            return False
+        self.containers_config.delete_container_archive(container_id, archive_name)
+        return True
+
+    def configure(self, args):
+        container_id = self.containers_config.check_container_id(args.id)
+
+        container = LibertineContainer(container_id)
+
+        if args.multiarch and self.host_info.get_host_architecture() == 'amd64':
+            multiarch = 'disabled'
+            if args.multiarch == 'enable':
+                multiarch = 'enabled'
+
+            current_multiarch = self.containers_config.get_container_multiarch_support(container_id)
+            if current_multiarch == multiarch:
+                print("i386 multiarch support is already %s" % multiarch)
+                sys.exit(1)
+
+            if container.configure_command('multiarch', args.multiarch) is not 0:
+                sys.exit(1)
+
+            self.containers_config.update_container_multiarch_support(container_id, multiarch)
+
+        elif args.add_archive:
+            if self.containers_config.archive_exists(container_id, args.add_archive):
+                print("%s already added in container." % args.add_archive)
+                sys.exit(1)
+
+            self.containers_config.add_container_archive(container_id, args.add_archive)
+            self.containers_config.update_archive_install_status(container_id, args.add_archive, 'installing')
+            if container.configure_command('add-archive', args.add_archive) is not 0:
+                self.containers_config.delete_container_archive(container_id, args.add_archive)
+                sys.exit(1)
+
+            self.containers_config.update_archive_install_status(container_id, args.add_archive, 'installed')
+
+        elif args.delete_archive:
+            if not self.containers_config.archive_exists(container_id, args.delete_archive):
+                print("%s is not added in container." % args.delete_archive)
+                sys.exit(1)
+
+            if not self.delete_archive_by_name(container_id, args.delete_archive):
+                sys.exit(1)
+
+    def merge(self, args):
+        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'])
+
+    def set_default(self, args):
+        if args.clear:
+            self.containers_config.clear_default_container_id(True)
+            sys.exit(0)
+
+        container_id = self.containers_config.check_container_id(args.id)
+
+        self.containers_config.set_default_container_id(container_id, True)
 
 
 if __name__ == '__main__':
@@ -657,6 +290,8 @@
         print("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'))
@@ -696,7 +331,7 @@
         '--password',
         help=("Pass in the user's password when creating an LXC container.  This "
               "is intended for testing only and is very insecure."))
-    parser_create.set_defaults(func=create)
+    parser_create.set_defaults(func=container_manager.create)
 
     # Handle the destroy command and its options
     parser_destroy = subparsers.add_parser(
@@ -705,7 +340,7 @@
     parser_destroy.add_argument(
         '-i', '--id',
         help=("Container identifier.  Default container is used if omitted."))
-    parser_destroy.set_defaults(func=destroy)
+    parser_destroy.set_defaults(func=container_manager.destroy)
 
     # Handle the install-package command and its options
     parser_install = subparsers.add_parser(
@@ -721,7 +356,7 @@
     parser_install.add_argument(
         '-r', '--readline', action='store_true',
         help=("Readline mode. Use text-based frontend during debconf interactions."))
-    parser_install.set_defaults(func=install_package)
+    parser_install.set_defaults(func=container_manager.install_package)
 
     # Handle the remove-package command and its options
     parser_remove = subparsers.add_parser(
@@ -737,7 +372,7 @@
     parser_remove.add_argument(
         '-r', '--readline', action='store_true',
         help=("Readline mode. Use text-based frontend during debconf interactions."))
-    parser_remove.set_defaults(func=remove_package)
+    parser_remove.set_defaults(func=container_manager.remove_package)
 
     # Handle the search-cache command and its options
     parser_search = subparsers.add_parser(
@@ -750,7 +385,7 @@
     parser_search.add_argument(
         '-i', '--id',
         help=("Container identifier.  Default container is used if omitted."))
-    parser_search.set_defaults(func=search_cache)
+    parser_search.set_defaults(func=container_manager.search_cache)
 
     # Handle the update command and its options
     parser_update = subparsers.add_parser(
@@ -759,13 +394,13 @@
     parser_update.add_argument(
         '-i', '--id',
         help=("Container identifier.  Default container is used if omitted."))
-    parser_update.set_defaults(func=update)
+    parser_update.set_defaults(func=container_manager.update)
 
     # Handle the list command
     parser_list = subparsers.add_parser(
         "list",
         help=("List all Libertine containers."))
-    parser_list.set_defaults(func=list)
+    parser_list.set_defaults(func=container_manager.list)
 
     # Handle the list-apps command and its options
     parser_list_apps = subparsers.add_parser(
@@ -778,7 +413,7 @@
         '-j', '--json',
         action='store_true',
         help=("use JSON output format."))
-    parser_list_apps.set_defaults(func=list_apps)
+    parser_list_apps.set_defaults(func=container_manager.list_apps)
 
     # Handle the execute command and it's options
     parser_exec = subparsers.add_parser(
@@ -791,7 +426,7 @@
     parser_exec.add_argument(
         '-c', '--command',
         help=("The command to run in the specified container."))
-    parser_exec.set_defaults(func=exec)
+    parser_exec.set_defaults(func=container_manager.exec)
 
     # Handle the configure command and it's options
     parser_configure = subparsers.add_parser(
@@ -816,7 +451,7 @@
         metavar='Archive name',
         help=("Deletes an existing archive (PPA) in the specified Libertine container.  "
               "Needs to be in the form of \"ppa:user/ppa-name\"."))
-    parser_configure.set_defaults(func=configure)
+    parser_configure.set_defaults(func=container_manager.configure)
 
     # Handle merging another ContainersConfig.json file into the main ContainersConfig.json file
     parser_merge = subparsers.add_parser(
@@ -825,13 +460,13 @@
     parser_merge.add_argument(
         '-f', '--file',
         required=True)
-    parser_merge.set_defaults(func=merge)
+    parser_merge.set_defaults(func=container_manager.merge)
 
     # Indiscriminately destroy containers, packages, and archives which are not fully installed
     parser_integrity = subparsers.add_parser(
         'fix-integrity',
         add_help=False)
-    parser_integrity.set_defaults(func=fix_integrity)
+    parser_integrity.set_defaults(func=container_manager.fix_integrity)
 
     # Set the default container in ContainersConfig
     parser_default = subparsers.add_parser(
@@ -844,7 +479,7 @@
     parser_default.add_argument(
         '-c', '--clear', action='store_true',
         help=("Clear the default container."))
-    parser_default.set_defaults(func=set_default)
+    parser_default.set_defaults(func=container_manager.set_default)
 
     # Actually parse the args
     args = parser.parse_args()

=== modified file 'tools/libertine-launch'
--- tools/libertine-launch	2016-05-10 20:17:44 +0000
+++ tools/libertine-launch	2016-07-07 20:14:07 +0000
@@ -18,21 +18,24 @@
 
 import argparse
 import os
+import random
+import string
 import libertine.utils
 import psutil
 import shlex
 import time
+
 from libertine import LibertineContainer
 
 
 def get_session_socket_path(session_socket_name):
-    unique_id = os.environ['DISPLAY'].strip(':')
+    unique_id = ''.join(random.choice(string.ascii_lowercase + string.digits) for i in range(8))
 
     if not os.path.exists(libertine.utils.get_libertine_runtime_dir()):
         os.makedirs(libertine.utils.get_libertine_runtime_dir())
 
     session_socket_path = (
-        os.path.join(libertine.utils.get_libertine_runtime_dir(), session_socket_name + unique_id))
+        os.path.join(libertine.utils.get_libertine_runtime_dir(), session_socket_name + '-' + unique_id))
 
     return session_socket_path
 
@@ -69,8 +72,8 @@
 
     while not os.path.exists(session_socket_path):
         if retries >= 10:
-            raise RuntimeError("Timeout waiting for Libertine Dbus session bridge socket") 
-        
+            raise RuntimeError("Timeout waiting for Libertine Dbus session bridge socket")
+
         print("Libertine Dbus session bridge socket is not ready.  Waiting...")
         retries += 1
         time.sleep(.5)
@@ -84,9 +87,6 @@
                             help='exec line')
     args = arg_parser.parse_args()
 
-    if not libertine.utils.container_exists(args.container_id):
-        raise RuntimeError("Container ID %s does not exist." % args.container_id)
-
     # remove problematic environment variables
     for e in ['QT_QPA_PLATFORM', 'LD_LIBRARY_PATH', 'FAKECHROOT_BASE', 'FAKECHROOT_CMD_SUBST']:
         if e in os.environ:
@@ -104,7 +104,7 @@
     # should detect the maliit socket, but dont know if its around or not here.
     detect_session_bridge_socket(dbus_socket_path)
 
-    container = LibertineContainer(args.container_id) 
+    container = LibertineContainer(args.container_id)
 
     try:
         container.launch_application(args.app_exec_line)

=== modified file 'tools/libertine-session-bridge'
--- tools/libertine-session-bridge	2016-05-19 20:00:22 +0000
+++ tools/libertine-session-bridge	2016-07-07 20:14:07 +0000
@@ -170,6 +170,7 @@
         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})