Merge lp:~bregma/libertine/refactor-container-back-ends into lp:libertine

[Stephen M. Webb]

refactor lxc and chroot container back ends into separately-installable packages

Refactored the container handling code into separate plugin packages for LXC and chroot so both are not required everywhere.

In particular, we want to avoid grief from having people attempt to use the LXC back end on click-based images and we want to avoid people using chroots elsewhere.

[Christopher Townsend (townsend)]

Since libertine-lxc-manager has been merged, we should probably install it in the python3-libertine-lxc package instead of libertine-tools.

[Christopher Townsend (townsend)]

Couple of inline comments.

[lp:~bregma/libertine/refactor-container-back-ends]

144. By Stephen M. Webb on 2015-11-30

removed a debug message

[Christopher Townsend (townsend)]

Great, thanks!

review: Approve

=== modified file 'debian/control'
--- debian/control	2015-11-19 20:17:44 +0000
+++ debian/control	2015-11-30 19:37:49 +0000
@@ -23,6 +23,7 @@
 Package: libertine
 Architecture: any
 Depends: libertine-tools,
+         python3-libertine-lxc,
          qml-module-qtquick2,
          qtdeclarative5-ubuntu-ui-toolkit-plugin,
          ${misc:Depends},
@@ -82,25 +83,53 @@
 Architecture: any
 Section: python
 Multi-Arch: allowed
+Depends: gir1.2-libertine,
+         python3-gi,
+         python3-xdg,
+         ${misc:Depends},
+         ${python3:Depends}
+Recommends: python3-libertine-lxc
+Suggests: python3-libertine-chroot
+Description: Python3 scripts for the Libertine application sandbox
+ Python3 modules for the Libertine application sandbox tools.  Requires at
+ least one of the container back end modules installed to be of any use.
+
+Package: python3-libertine-lxc
+Architecture: any
+Section: python
+Multi-Arch: allowed
+Depends: lxc-templates,
+         python3-lxc,
+         python3-xdg,
+         uidmap,
+         ${misc:Depends},
+         ${python3:Depends}
+Description: Python3 scripts for the Libertine application sandbox
+ This package provides the LXC-based container back end module for the
+ Libertine sandbox.  It requires support for unprivileged LXC containers in the
+ Linux kernel.
+
+Package: python3-libertine-chroot
+Architecture: any
+Section: python
+Multi-Arch: allowed
 Depends: debootstrap,
          fakechroot,
          fakeroot,
-         gir1.2-libertine,
-         lxc-templates,
          proot [amd64 arm64 armhf i386],
-         python3-gi,
-         python3-lxc,
-         python3-xdg,
-         uidmap,
          ${misc:Depends},
          ${python3:Depends}
 Description: Python3 scripts for the Libertine application sandbox
- Python3 modules for the Libertine application sandbox tools.
+ This package provides the chroot-based container back end module for the
+ Libertine sandbox.  This container back end module is intended only for
+ curated containers distributed for devices that do not support unprivileged
+ LXC contaiers.
 
 Package: libertine-demo
 Architecture: any
 Multi-Arch: allowed
 Depends: libertine-tools,
+         python3-libertine-chroot,
          ${misc:Depends}
 Description: Adds desktop files and icon for Unity 8 desktop support
  Add desktop files and icons for the targeted applications needed for legacy

=== added file 'debian/python3-libertine-chroot.install'
--- debian/python3-libertine-chroot.install	1970-01-01 00:00:00 +0000
+++ debian/python3-libertine-chroot.install	2015-11-30 19:37:49 +0000
@@ -0,0 +1,1 @@
+usr/lib/python*/*/libertine/ChrootContainer.py

=== added file 'debian/python3-libertine-lxc.install'
--- debian/python3-libertine-lxc.install	1970-01-01 00:00:00 +0000
+++ debian/python3-libertine-lxc.install	2015-11-30 19:37:49 +0000
@@ -0,0 +1,1 @@
+usr/lib/python*/*/libertine/LxcContainer.py

=== modified file 'debian/python3-libertine.install'
--- debian/python3-libertine.install	2015-08-24 16:32:41 +0000
+++ debian/python3-libertine.install	2015-11-30 19:37:49 +0000
@@ -1,1 +1,3 @@
-usr/lib/python*/*/libertine
+usr/lib/python*/*/libertine/__init__.py
+usr/lib/python*/*/libertine/Libertine.py
+usr/lib/python*/*/libertine/utils.py

=== added file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	1970-01-01 00:00:00 +0000
+++ python/libertine/ChrootContainer.py	2015-11-30 19:37:49 +0000
@@ -0,0 +1,168 @@
+# Copyright 2015 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import shlex
+import shutil
+import subprocess
+from .Libertine import (
+        BaseContainer, get_container_distro, get_host_architecture,
+        create_libertine_user_data_dir, create_compiz_config)
+from . import utils
+
+
+def chown_recursive_dirs(path):
+    uid = None
+    gid = None
+
+    if 'SUDO_UID' in os.environ:
+        uid = int(os.environ['SUDO_UID'])
+    if 'SUDO_GID' in os.environ:
+        gid = int(os.environ['SUDO_GID'])
+
+    if uid is not None and gid is not None:
+        for root, dirs, files in os.walk(path):
+            for d in dirs:
+                os.chown(os.path.join(root, d), uid, gid)
+            for f in files:
+                os.chown(os.path.join(root, f), uid, gid)
+
+        os.chown(path, uid, gid)
+
+
+class LibertineChroot(BaseContainer):
+    """
+    A concrete container type implemented using a plain old chroot.
+    """
+
+    def __init__(self, container_id):
+        super().__init__(container_id)
+        self.series = get_container_distro(container_id)
+        self.chroot_path = utils.get_libertine_container_rootfs_path(container_id)
+        os.environ['FAKECHROOT_CMD_SUBST'] = '$FAKECHROOT_CMD_SUBST:/usr/bin/chfn=/bin/true'
+        os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
+
+    def run_in_container(self, command_string):
+        cmd_args = shlex.split(command_string)
+        if self.series == "trusty":
+            proot_cmd = '/usr/bin/proot'
+            if not os.path.isfile(proot_cmd) or not os.access(proot_cmd, os.X_OK):
+                raise RuntimeError('executable proot not found')
+            command_prefix = proot_cmd + " -b /usr/lib/locale -S " + self.chroot_path
+        else:
+            command_prefix = "fakechroot fakeroot chroot " + self.chroot_path
+        args = shlex.split(command_prefix + ' ' + command_string)
+        cmd = subprocess.Popen(args)
+        return cmd.wait()
+
+    def destroy_libertine_container(self):
+        shutil.rmtree(self.chroot_path)
+
+    def create_libertine_container(self, password=None, verbosity=1):
+        installed_release = self.series
+
+        # Create the actual chroot
+        if installed_release == "trusty":
+            command_line = "debootstrap --verbose " + installed_release + " " + self.chroot_path
+        else:
+            command_line = "fakechroot fakeroot debootstrap --verbose --variant=fakechroot {} {}".format(
+                    installed_release, self.chroot_path)
+        args = shlex.split(command_line)
+        subprocess.Popen(args).wait()
+
+        # 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.chroot_path, 'dev'))
+            os.remove(os.path.join(self.chroot_path, 'proc'))
+
+            with open(os.path.join(self.chroot_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 and -updates to the chroot's sources.list
+        if (get_host_architecture() == 'armhf'):
+            archive = "deb http://ports.ubuntu.com/ubuntu-ports "
+        else:
+            archive = "deb http://archive.ubuntu.com/ubuntu "
+
+        if verbosity == 1:
+            print("Updating chroot's sources.list entries...")
+        with open(os.path.join(self.chroot_path, 'etc', 'apt', 'sources.list'), 'a') as fd:
+            fd.write(archive + installed_release + " universe\n")
+            fd.write(archive + installed_release + "-updates main\n")
+            fd.write(archive + installed_release + "-updates universe\n")
+
+        create_libertine_user_data_dir(self.container_id)
+
+        if installed_release == "trusty":
+            print("Additional configuration for Trusty chroot...")
+
+            proot_cmd = '/usr/bin/proot'
+            if not os.path.isfile(proot_cmd) or not os.access(proot_cmd, os.X_OK):
+                raise RuntimeError('executable proot not found')
+            cmd_line_prefix = proot_cmd + " -b /usr/lib/locale -S " + self.chroot_path
+
+            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 verbosity == 1:
+            print("Updating the contents of the container after creation...")
+        self.update_packages(verbosity)
+        self.install_package("libnss-extrausers", verbosity)
+
+        if verbosity == 1:
+            print("Installing Compiz as the Xmir window manager...")
+        self.install_package("compiz", verbosity)
+        create_compiz_config(self.container_id)
+
+        # Check if the container was created as root and chown the user directories as necessary
+        chown_recursive_dirs(utils.get_libertine_container_userdata_dir_path(self.container_id))
+

=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2015-11-30 19:37:49 +0000
+++ python/libertine/Libertine.py	2015-11-30 19:37:49 +0000
@@ -14,47 +14,12 @@
 
 import abc
 import contextlib
-import crypt
 import json
-import lxc
 import os
 import shlex
-import shutil
 import subprocess
 import libertine.utils
 
-home_path = os.environ['HOME']
-
-
-def check_lxc_net_entry(entry):
-    lxc_net_file = open('/etc/lxc/lxc-usernet')
-    found = False
-
-    for line in lxc_net_file:
-        if entry in line:
-            found = True
-            break
-
-    return found
-
-
-def setup_host_environment(username, password):
-    lxc_net_entry = "%s veth lxcbr0 10" % str(username)
-
-    if not check_lxc_net_entry(lxc_net_entry):
-        passwd = subprocess.Popen(["sudo", "--stdin", "usermod", "--add-subuids", "100000-165536",
-                                   "--add-subgids", "100000-165536", str(username)],
-                                  stdin=subprocess.PIPE, stdout=subprocess.DEVNULL,
-                                  stderr=subprocess.STDOUT)
-        passwd.communicate((password + '\n').encode('UTF-8'))
-
-        add_user_cmd = "echo %s | sudo tee -a /etc/lxc/lxc-usernet > /dev/null" % lxc_net_entry
-        subprocess.Popen(add_user_cmd, shell=True)
-
-
-def get_lxc_default_config_path():
-    return os.path.join(home_path, '.config', 'lxc')
-
 
 def get_container_distro(container_id):
     container_distro = ""
@@ -79,25 +44,6 @@
     return dpkg.stdout.read().strip()
 
 
-def chown_recursive_dirs(path):
-    uid = None
-    gid = None
-
-    if 'SUDO_UID' in os.environ:
-        uid = int(os.environ['SUDO_UID'])
-    if 'SUDO_GID' in os.environ:
-        gid = int(os.environ['SUDO_GID'])
-
-    if uid is not None and gid is not None:
-        for root, dirs, files in os.walk(path):
-            for d in dirs:
-                os.chown(os.path.join(root, d), uid, gid)
-            for f in files:
-                os.chown(os.path.join(root, f), uid, gid)
-
-        os.chown(path, uid, gid)
-
-
 def create_libertine_user_data_dir(container_id):
     user_data = libertine.utils.get_libertine_container_userdata_dir_path(container_id)
 
@@ -126,13 +72,6 @@
         fd.write("s0_mode = 3")
 
 
-def lxc_container(container_id):
-    config_path = libertine.utils.get_libertine_containers_dir_path()
-    container = lxc.Container(container_id, config_path)
-
-    return container
-
-
 def apt_args_for_verbosity_level(verbosity):
     """
     Maps numeric verbosity levels onto APT command-line arguments.
@@ -202,273 +141,18 @@
 
         :param verbosity: the chattiness of the output on a range from 0 to 2
         """
-        self.run_in_container(apt_command_prefix(verbosity) + 'update')
-        self.run_in_container(apt_command_prefix(verbosity) + 'upgrade')
+        self.run_in_container(apt_command_prefix(verbosity) + '--force-yes update')
+        self.run_in_container(apt_command_prefix(verbosity) + '--force-yes upgrade')
 
-    def install_package(self, package_name, verbosity=1):
+    def install_package(self, package_name, verbosity=1, extra_apt_args=""):
         """
         Installs a named package in the container.
 
         :param package_name: The name of the package as APT understands it.
         :param verbosity: the chattiness of the output on a range from 0 to 2
         """
-        return self.run_in_container(apt_command_prefix(verbosity) + "install --no-install-recommends '" + package_name + "'") == 0
-
-
-class LibertineLXC(BaseContainer):
-    """
-    A concrete container type implemented using an LXC container.
-    """
-
-    def __init__(self, container_id):
-        super().__init__(container_id)
-        self.container = lxc_container(container_id)
-        self.series = get_container_distro(container_id)
-
-    def is_running(self):
-        return self.container.running
-
-    def start_container(self):
-        if not self.container.running:
-            if not self.container.start():
-                raise RuntimeError("Container failed to start")
-            if not self.container.wait("RUNNING", 10):
-                raise RuntimeError("Container failed to enter the RUNNING state")
-
-        if not self.container.get_ips(timeout=30):
-            raise RuntimeError("Not able to connect to the network.")
-
-        self.run_in_container("umount /tmp/.X11-unix")
-
-    def stop_container(self):
-        self.container.stop()
-
-    def run_in_container(self, command_string):
-        cmd_args = shlex.split(command_string)
-        return self.container.attach_wait(lxc.attach_run_command, cmd_args)
-
-    def destroy_libertine_container(self):
-        if self.container.defined:
-            self.container.stop()
-            self.container.destroy()
-
-    def create_libertine_container(self, password=None, verbosity=1):
-        if password is None:
-            return
-
-        installed_release = self.series
-
-        username = os.environ['USER']
-        user_id = os.getuid()
-        group_id = os.getgid()
-
-        setup_host_environment(username, password)
-
-        # Generate the default lxc default config, if it doesn't exist
-        config_path = get_lxc_default_config_path()
-        config_file = "%s/default.conf" % config_path
-
-        if not os.path.exists(config_path):
-            os.mkdir(config_path)
-
-        if not os.path.exists(config_file):
-            with open(config_file, "w+") as fd:
-                fd.write("lxc.network.type = veth\n")
-                fd.write("lxc.network.link = lxcbr0\n")
-                fd.write("lxc.network.flags = up\n")
-                fd.write("lxc.network.hwaddr = 00:16:3e:xx:xx:xx\n")
-                fd.write("lxc.id_map = u 0 100000 %s\n" % user_id)
-                fd.write("lxc.id_map = g 0 100000 %s\n" % group_id)
-                fd.write("lxc.id_map = u %s %s 1\n" % (user_id, user_id))
-                fd.write("lxc.id_map = g %s %s 1\n" % (group_id, group_id))
-                fd.write("lxc.id_map = u %s %s %s\n" % (user_id + 1, (user_id + 1) + 100000, 65536 - (user_id + 1)))
-                fd.write("lxc.id_map = g %s %s %s\n" % (group_id + 1, (group_id + 1) + 100000, 65536 - (user_id + 1)))
-
-        create_libertine_user_data_dir(self.container_id)
-
-        # Figure out the host architecture
-        architecture = get_host_architecture()
-
-        if not self.container.create("download", 0,
-                                     {"dist": "ubuntu",
-                                      "release": installed_release,
-                                      "arch": architecture}):
-            return False
-
-        self.create_libertine_config()
-
-        if self.container.start():
-            self.run_in_container("userdel-r ubuntu")
-            self.run_in_container("useradd -u {} -p {} -G sudo {}".format(str(user_id), crypt.crypt(password), str(username)))
-
-            if verbosity == 1:
-                print("Updating the contents of the container after creation...")
-            self.update_packages(verbosity)
-
-            if verbosity == 1:
-                print("Installing Compiz as the Xmir window manager...")
-            self.install_package('compiz', verbosity)
-            create_compiz_config(self.container.name)
-
-            self.container.stop()
-        else:
-            raise RuntimeError("Container failed to start.")
-
-    def create_libertine_config(self):
-        user_id = os.getuid()
-        home_entry = (
-            "%s %s none bind,create=dir"
-            % (libertine.utils.get_libertine_container_userdata_dir_path(self.container_id),
-               home_path.strip('/'))
-        )
-
-        # Bind mount the user's home directory
-        self.container.append_config_item("lxc.mount.entry", home_entry)
-
-        xdg_user_dirs = ['Documents', 'Music', 'Pictures', 'Videos']
-
-        for user_dir in xdg_user_dirs:
-            xdg_user_dir_entry = (
-                "%s/%s %s/%s none bind,create=dir,optional"
-                % (home_path, user_dir, home_path.strip('/'), user_dir)
-            )
-            self.container.append_config_item("lxc.mount.entry", xdg_user_dir_entry)
-
-        # Setup the mounts for /run/user/$user_id
-        run_user_entry = "/run/user/%s run/user/%s none rbind,create=dir" % (user_id, user_id)
-        self.container.append_config_item("lxc.mount.entry", "tmpfs run tmpfs rw,nodev,noexec,nosuid,size=5242880")
-        self.container.append_config_item("lxc.mount.entry",
-                                          "none run/user tmpfs rw,nodev,noexec,nosuid,size=104857600,mode=0755,create=dir")
-        self.container.append_config_item("lxc.mount.entry", run_user_entry)
-
-        self.container.append_config_item("lxc.include", "/usr/share/libertine/libertine-lxc.conf")
-
-        # Dump it all to disk
-        self.container.save_config()
-
-
-class LibertineChroot(BaseContainer):
-    """
-    A concrete container type implemented using a plain old chroot.
-    """
-
-    def __init__(self, container_id):
-        super().__init__(container_id)
-        self.series = get_container_distro(container_id)
-        self.chroot_path = libertine.utils.get_libertine_container_rootfs_path(container_id)
-        os.environ['FAKECHROOT_CMD_SUBST'] = '$FAKECHROOT_CMD_SUBST:/usr/bin/chfn=/bin/true'
-        os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
-
-    def run_in_container(self, command_string):
-        cmd_args = shlex.split(command_string)
-        if self.series == "trusty":
-            proot_cmd = '/usr/bin/proot'
-            if not os.path.isfile(proot_cmd) or not os.access(proot_cmd, os.X_OK):
-                raise RuntimeError('executable proot not found')
-            command_prefix = proot_cmd + " -b /usr/lib/locale -S " + self.chroot_path
-        else:
-            command_prefix = "fakechroot fakeroot chroot " + self.chroot_path
-        args = shlex.split(command_prefix + ' ' + command_string)
-        cmd = subprocess.Popen(args).wait()
-
-    def destroy_libertine_container(self):
-        shutil.rmtree(self.chroot_path)
-
-    def create_libertine_container(self, password=None, verbosity=1):
-        installed_release = self.series
-
-        # Create the actual chroot
-        if installed_release == "trusty":
-            command_line = "debootstrap --verbose " + installed_release + " " + self.chroot_path
-        else:
-            command_line = "fakechroot fakeroot debootstrap --verbose --variant=fakechroot " + installed_release + " " + self.chroot_path
-        args = shlex.split(command_line)
-        subprocess.Popen(args).wait()
-
-        # 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.chroot_path, 'dev'))
-            os.remove(os.path.join(self.chroot_path, 'proc'))
-
-            with open(os.path.join(self.chroot_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 and -updates to the chroot's sources.list
-        if (get_host_architecture() == 'armhf'):
-            archive = "deb http://ports.ubuntu.com/ubuntu-ports "
-        else:
-            archive = "deb http://archive.ubuntu.com/ubuntu "
-
-        if verbosity == 1:
-            print("Updating chroot's sources.list entries...")
-        with open(os.path.join(self.chroot_path, 'etc', 'apt', 'sources.list'), 'a') as fd:
-            fd.write(archive + installed_release + " universe\n")
-            fd.write(archive + installed_release + "-updates main\n")
-            fd.write(archive + installed_release + "-updates universe\n")
-
-        create_libertine_user_data_dir(self.container_id)
-
-        if installed_release == "trusty":
-            print("Additional configuration for Trusty chroot...")
-
-            proot_cmd = '/usr/bin/proot'
-            if not os.path.isfile(proot_cmd) or not os.access(proot_cmd, os.X_OK):
-                raise RuntimeError('executable proot not found')
-            cmd_line_prefix = proot_cmd + " -b /usr/lib/locale -S " + self.chroot_path
-
-            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 verbosity == 1:
-            print("Updating the contents of the container after creation...")
-        self.update_packages(verbosity)
-        self.install_package("libnss-extrausers", verbosity)
-
-        if verbosity == 1:
-            print("Installing Compiz as the Xmir window manager...")
-        self.install_package("compiz", verbosity)
-        create_compiz_config(self.container_id)
-
-        # Check if the container was created as root and chown the user directories as necessary
-        chown_recursive_dirs(libertine.utils.get_libertine_container_userdata_dir_path(self.container_id))
+        return self.run_in_container(apt_command_prefix(verbosity) +
+                extra_apt_args + " install --no-install-recommends '" + package_name + "'") == 0
 
 
 class LibertineMock(BaseContainer):
@@ -511,8 +195,10 @@
         """
         super().__init__()
         if container_type == "lxc":
+            from  libertine.LxcContainer import LibertineLXC
             self.container = LibertineLXC(container_id)
         elif container_type == "chroot":
+            from  libertine.ChrootContainer import LibertineChroot
             self.container = LibertineChroot(container_id)
         elif container_type == "mock":
             self.container = LibertineMock(container_id)

=== added file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	1970-01-01 00:00:00 +0000
+++ python/libertine/LxcContainer.py	2015-11-30 19:37:49 +0000
@@ -0,0 +1,199 @@
+# Copyright 2015 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import crypt
+import lxc
+import os
+import shlex
+import subprocess
+from .Libertine import (
+        BaseContainer, get_container_distro, get_host_architecture,
+        create_libertine_user_data_dir, create_compiz_config)
+from . import utils
+
+
+home_path = os.environ['HOME']
+
+
+def check_lxc_net_entry(entry):
+    lxc_net_file = open('/etc/lxc/lxc-usernet')
+    found = False
+
+    for line in lxc_net_file:
+        if entry in line:
+            found = True
+            break
+
+    return found
+
+
+def setup_host_environment(username, password):
+    lxc_net_entry = "%s veth lxcbr0 10" % str(username)
+
+    if not check_lxc_net_entry(lxc_net_entry):
+        passwd = subprocess.Popen(["sudo", "--stdin", "usermod", "--add-subuids", "100000-165536",
+                                   "--add-subgids", "100000-165536", str(username)],
+                                  stdin=subprocess.PIPE, stdout=subprocess.DEVNULL,
+                                  stderr=subprocess.STDOUT)
+        passwd.communicate((password + '\n').encode('UTF-8'))
+
+        add_user_cmd = "echo %s | sudo tee -a /etc/lxc/lxc-usernet > /dev/null" % lxc_net_entry
+        subprocess.Popen(add_user_cmd, shell=True)
+
+
+def get_lxc_default_config_path():
+    return os.path.join(home_path, '.config', 'lxc')
+
+
+def lxc_container(container_id):
+    config_path = utils.get_libertine_containers_dir_path()
+    container = lxc.Container(container_id, config_path)
+
+    return container
+
+
+class LibertineLXC(BaseContainer):
+    """
+    A concrete container type implemented using an LXC container.
+    """
+
+    def __init__(self, container_id):
+        super().__init__(container_id)
+        self.container = lxc_container(container_id)
+        self.series = get_container_distro(container_id)
+
+    def is_running(self):
+        return self.container.running
+
+    def start_container(self):
+        if not self.container.running:
+            if not self.container.start():
+                raise RuntimeError("Container failed to start")
+            if not self.container.wait("RUNNING", 10):
+                raise RuntimeError("Container failed to enter the RUNNING state")
+
+        if not self.container.get_ips(timeout=30):
+            raise RuntimeError("Not able to connect to the network.")
+
+        self.run_in_container("umount /tmp/.X11-unix")
+
+    def stop_container(self):
+        self.container.stop()
+
+    def run_in_container(self, command_string):
+        cmd_args = shlex.split(command_string)
+        return self.container.attach_wait(lxc.attach_run_command, cmd_args)
+
+    def destroy_libertine_container(self):
+        if self.container.defined:
+            self.container.stop()
+            self.container.destroy()
+
+    def create_libertine_container(self, password=None, verbosity=1):
+        if password is None:
+            return
+
+        installed_release = self.series
+
+        username = os.environ['USER']
+        user_id = os.getuid()
+        group_id = os.getgid()
+
+        setup_host_environment(username, password)
+
+        # Generate the default lxc default config, if it doesn't exist
+        config_path = get_lxc_default_config_path()
+        config_file = "%s/default.conf" % config_path
+
+        if not os.path.exists(config_path):
+            os.mkdir(config_path)
+
+        if not os.path.exists(config_file):
+            with open(config_file, "w+") as fd:
+                fd.write("lxc.network.type = veth\n")
+                fd.write("lxc.network.link = lxcbr0\n")
+                fd.write("lxc.network.flags = up\n")
+                fd.write("lxc.network.hwaddr = 00:16:3e:xx:xx:xx\n")
+                fd.write("lxc.id_map = u 0 100000 %s\n" % user_id)
+                fd.write("lxc.id_map = g 0 100000 %s\n" % group_id)
+                fd.write("lxc.id_map = u %s %s 1\n" % (user_id, user_id))
+                fd.write("lxc.id_map = g %s %s 1\n" % (group_id, group_id))
+                fd.write("lxc.id_map = u %s %s %s\n" % (user_id + 1, (user_id + 1) + 100000, 65536 - (user_id + 1)))
+                fd.write("lxc.id_map = g %s %s %s\n" % (group_id + 1, (group_id + 1) + 100000, 65536 - (user_id + 1)))
+
+        create_libertine_user_data_dir(self.container_id)
+
+        # Figure out the host architecture
+        architecture = get_host_architecture()
+
+        if not self.container.create("download", 0,
+                                     {"dist": "ubuntu",
+                                      "release": installed_release,
+                                      "arch": architecture}):
+            return False
+
+        self.create_libertine_config()
+
+        if verbosity == 1:
+            print("starting container ...")
+        self.start_container()
+        self.run_in_container("userdel -r ubuntu")
+        self.run_in_container("useradd -u {} -p {} -G sudo {}".format(
+                str(user_id), crypt.crypt(password), str(username)))
+
+        if verbosity == 1:
+            print("Updating the contents of the container after creation...")
+        self.update_packages(verbosity)
+
+        if verbosity == 1:
+            print("Installing Compiz as the Xmir window manager...")
+        self.install_package('compiz', verbosity=verbosity)
+        create_compiz_config(self.container.name)
+
+        if verbosity == 1:
+            print("stopping container ...")
+        self.stop_container()
+
+    def create_libertine_config(self):
+        user_id = os.getuid()
+        home_entry = (
+            "%s %s none bind,create=dir"
+            % (utils.get_libertine_container_userdata_dir_path(self.container_id),
+               home_path.strip('/'))
+        )
+
+        # Bind mount the user's home directory
+        self.container.append_config_item("lxc.mount.entry", home_entry)
+
+        xdg_user_dirs = ['Documents', 'Music', 'Pictures', 'Videos']
+
+        for user_dir in xdg_user_dirs:
+            xdg_user_dir_entry = (
+                "%s/%s %s/%s none bind,create=dir,optional"
+                % (home_path, user_dir, home_path.strip('/'), user_dir)
+            )
+            self.container.append_config_item("lxc.mount.entry", xdg_user_dir_entry)
+
+        # Setup the mounts for /run/user/$user_id
+        run_user_entry = "/run/user/%s run/user/%s none rbind,create=dir" % (user_id, user_id)
+        self.container.append_config_item("lxc.mount.entry", "tmpfs run tmpfs rw,nodev,noexec,nosuid,size=5242880")
+        self.container.append_config_item("lxc.mount.entry",
+                                          "none run/user tmpfs rw,nodev,noexec,nosuid,size=104857600,mode=0755,create=dir")
+        self.container.append_config_item("lxc.mount.entry", run_user_entry)
+
+        self.container.append_config_item("lxc.include", "/usr/share/libertine/libertine-lxc.conf")
+
+        # Dump it all to disk
+        self.container.save_config()
+