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

[Christopher Townsend]

* Remove the /tmp/.X11-unix umount during LXC container start for operations as it seems it's not needed. (LP: #1654650)
* Remove extra finish_application() in chroot backend.
* Set container's locale and language based on the host including installing necessary language packs. (LP: #1609982)
* Bump version to 1.5.1.
* Manually execute lxd bind mount script to fix /run/user and remove service. (LP: #1654647)
* Convert results to dicts on operation/application collision in container lifecycle managers.
* Stop bind-mounting /usr/lib/locale and let environment do all the work. (LP: #1654648)
* Mount lxd home directory in $HOME/.local/libertine-container where it belongs.
* Manually wait for lxd container to stop when specified after calling the service. (LP: #1655980)
* Ask for container user password when creating lxd containers. (LP: #1655977)
* Bind-mount lxd container applications and icons directories into user's home directory.

[Larry Price (larryprice)]

lgtm!

review: Approve

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

183. By Christopher Townsend on 2017-01-17

Merge lp:libertine for fix on starting the window manager.

184. By Christopher Townsend on 2017-01-18

Merge lp:libertine for fix to remove bind-mount rootfs directories in LXD.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-01-05 18:29:51 +0000
+++ CMakeLists.txt	2017-01-18 14:37:20 +0000
@@ -2,7 +2,7 @@
 cmake_policy(SET CMP0048 NEW)
 
 project(libertine
-        VERSION 1.5)
+        VERSION 1.5.1)
 
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}")
 

=== modified file 'data/libertine-lxc.conf'
--- data/libertine-lxc.conf	2016-03-21 19:26:22 +0000
+++ data/libertine-lxc.conf	2017-01-18 14:37:20 +0000
@@ -3,5 +3,4 @@
 lxc.mount.entry = /dev/snd dev/snd none bind,optional,create=dir
 lxc.mount.entry = /dev/video0 dev/video0 none bind,optional,create=file
 lxc.mount.entry = /dev/fuse dev/fuse none bind,optional,create=file
-lxc.mount.entry = /usr/lib/locale usr/lib/locale none optional,bind
 lxc.tty = 0

=== modified file 'debian/changelog'
--- debian/changelog	2017-01-05 20:20:33 +0000
+++ debian/changelog	2017-01-18 14:37:20 +0000
@@ -1,3 +1,30 @@
+libertine (1.5.1-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Chris Townsend ]
+  * Remove the /tmp/.X11-unix umount during LXC container start for operations
+    as it seems it's not needed. (LP: #1654650)
+  * Remove extra finish_application() in chroot backend.
+  * Set container's locale and language based on the host including installing
+    necessary language packs. (LP: #1609982)
+  * Bump version to 1.5.1.
+
+  [ Larry Price ]
+  * Manually execute lxd bind mount script to fix /run/user and remove
+    service. (LP: #1654647)
+  * Convert results to dicts on operation/application collision in container
+    lifecycle managers.
+  * Stop bind-mounting /usr/lib/locale and let environment do all the work.
+    (LP: #1654648)
+  * Mount lxd home directory in $HOME/.local/libertine-container where it
+    belongs.
+  * Manually wait for lxd container to stop when specified after calling the
+    service. (LP: #1655980)
+  * Ask for container user password when creating lxd containers. (LP: #1655977)
+  * Bind-mount lxd container applications and icons directories into user's
+    home directory.
+
+ -- Chris Townsend <[e-mail]>  Fri, 13 Jan 2017 14:59:52 -0500
+
 libertine (1.5+17.04.20170105.1-0ubuntu1) zesty; urgency=medium
 
   [ Chris Townsend ]

=== modified file 'liblibertine/libertine.cpp'
--- liblibertine/libertine.cpp	2016-12-07 18:04:08 +0000
+++ liblibertine/libertine.cpp	2017-01-18 14:37:20 +0000
@@ -148,16 +148,8 @@
   g_return_val_if_fail(container_id != nullptr, nullptr);
   LibertineConfig config;
   ContainerConfigList container_list(&config);
-  gchar * path = nullptr;
 
-  if (g_strcmp0((gchar*)container_list.getContainerType(container_id).toStdString().c_str(), "lxd") == 0)
-  {
-    path = g_build_filename("/", "var", "lib", "lxd", "containers", container_id, "rootfs", nullptr);
-  }
-  else
-  {
-    path = g_build_filename(g_get_user_cache_dir(), "libertine-container", container_id, "rootfs", nullptr);
-  }
+  gchar * path = g_build_filename(g_get_user_cache_dir(), "libertine-container", container_id, "rootfs", nullptr);
 
   if (g_file_test(path, G_FILE_TEST_EXISTS))
   {
@@ -175,16 +167,8 @@
   g_return_val_if_fail(container_id != nullptr, nullptr);
   LibertineConfig config;
   ContainerConfigList container_list(&config);
-  gchar * path = nullptr;
 
-  if (g_strcmp0((gchar*)container_list.getContainerType(container_id).toStdString().c_str(), "lxd") == 0)
-  {
-    path = g_build_filename("/", "var", "lib", "lxd", "containers", container_id, "rootfs", "home", g_get_user_name(), nullptr);
-  }
-  else
-  {
-    path = g_build_filename(g_get_user_data_dir(), "libertine-container", "user-data", container_id, nullptr);
-  }
+  gchar * path =  g_build_filename(g_get_user_data_dir(), "libertine-container", "user-data", container_id, nullptr);
 
   if (g_file_test(path, G_FILE_TEST_EXISTS))
   {

=== modified file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	2017-01-04 20:22:33 +0000
+++ python/libertine/ChrootContainer.py	2017-01-18 14:37:20 +0000
@@ -66,13 +66,7 @@
         return cmd.wait()
 
     def destroy_libertine_container(self):
-        container_root = os.path.join(utils.get_libertine_containers_dir_path(), self.container_id)
-        try:
-            shutil.rmtree(container_root)
-            return True
-        except Exception as e:
-            utils.get_logger().error("%s" % e)
-            return False
+        return self._delete_rootfs()
 
     def create_libertine_container(self, password=None, multiarch=False):
         # Create the actual chroot
@@ -120,6 +114,8 @@
 
         utils.create_libertine_user_data_dir(self.container_id)
 
+        self.update_locale()
+
         if multiarch and self.architecture == 'amd64':
             utils.get_logger().info("Adding i386 multiarch support...")
             self.run_in_container("dpkg --add-architecture i386")
@@ -146,10 +142,12 @@
         # 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))
 
+        super().create_libertine_container()
+
         return True
 
-    def update_packages(self):
-        retcode = super().update_packages()
+    def update_packages(self, new_locale=None):
+        retcode = super().update_packages(new_locale)
         self._run_ldconfig()
         return retcode == 0
 
@@ -229,7 +227,7 @@
         proot_cmd = self._build_proot_command()
 
         args = shlex.split(proot_cmd)
-        args.extend(utils.setup_window_manager(self.container_id, enable_toolbars=True))
+        args.extend(self.setup_window_manager(enable_toolbars=True))
         self._window_manager = psutil.Popen(args, env=environ)
 
         args = shlex.split(proot_cmd)
@@ -248,6 +246,3 @@
         args = shlex.split(command_line)
         app = subprocess.Popen(args)
         return app
-
-    def finish_application(self, app):
-        app.wait()

=== modified file 'python/libertine/ContainersConfig.py'
--- python/libertine/ContainersConfig.py	2016-12-07 21:50:36 +0000
+++ python/libertine/ContainersConfig.py	2017-01-18 14:37:20 +0000
@@ -296,6 +296,12 @@
         else:
             return multiarch_support
 
+    def update_container_locale(self, container_id, locale):
+        self._set_value_by_key(container_id, 'locale', locale)
+
+    def get_container_locale(self, container_id):
+        return self._get_value_by_key(container_id, 'locale')
+
     """
     Operations for archive (PPA) maintenance in a Libertine container.
     """

=== modified file 'python/libertine/HostInfo.py'
--- python/libertine/HostInfo.py	2016-11-21 17:18:55 +0000
+++ python/libertine/HostInfo.py	2017-01-18 14:37:20 +0000
@@ -12,6 +12,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 locale
 import lsb_release
 import os
 import platform
@@ -74,3 +75,14 @@
     def get_host_timezone(self):
         with open(os.path.join('/', 'etc', 'timezone'), 'r') as fd:
             return fd.read().strip('\n')
+
+    def get_host_locale(self):
+        host_locale = locale.getlocale()
+        full_locale = None
+
+        if len(host_locale) == 2:
+            full_locale = "{}.{}".format(host_locale[0], host_locale[1])
+        elif len(host_locale) == 1:
+            full_locale = "{}".format(host_locale[0])
+
+        return full_locale

=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2017-01-03 17:51:30 +0000
+++ python/libertine/Libertine.py	2017-01-18 14:37:20 +0000
@@ -16,7 +16,6 @@
 from gi.repository import Libertine
 import abc
 import contextlib
-import libertine.utils
 import os
 import shutil
 
@@ -82,10 +81,15 @@
 
     :param container_id: The machine-readable container name.
     """
-    def __init__(self, container_id):
+    def __init__(self, container_id, containers_config=None):
+        if containers_config is None:
+            containers_config = ContainersConfig()
+
         self.container_type = 'unknown'
         self.container_id = container_id
-        self.root_path = libertine.utils.get_libertine_container_rootfs_path(self.container_id)
+        self.root_path = utils.get_libertine_container_rootfs_path(self.container_id)
+        self.locale = containers_config.get_container_locale(container_id)
+        self.language = self._get_language_from_locale()
         self.default_packages = ['matchbox-window-manager',
                                  'libnss-extrausers',
                                  'humanity-icon-theme',
@@ -93,8 +97,62 @@
                                  'maliit-inputcontext-gtk3',
                                  'maliit-framework']
 
+    def _get_language_from_locale(self):
+        language = None
+
+        if self.locale is not None:
+            language = self.locale.split('.')[0]
+            if not language.startswith('zh_'):
+                language = language.split('_')[0]
+            elif language.startswith('zh_CN'):
+                language = 'zh-hans'
+            else:
+                language = 'zh-hant'
+
+        return language
+
+    def _binary_exists(self, binary):
+        return self.run_in_container("bash -c \"which {} &> /dev/null\"".format(binary)) == 0
+
+    def _delete_rootfs(self):
+        container_root = os.path.join(utils.get_libertine_containers_dir_path(), self.container_id)
+        if not os.path.exists(container_root):
+            return True
+
+        try:
+            shutil.rmtree(container_root)
+            return True
+        except Exception as e:
+            utils.get_logger().error("%s" % e)
+            return False
+
+    def setup_window_manager(self, enable_toolbars=False):
+        if self._binary_exists('matchbox-window-manager'):
+            if enable_toolbars:
+                return ['matchbox-window-manager']
+
+            return ['matchbox-window-manager', '-use_titlebar', 'no']
+        else:
+            return ['compiz']
+
+
+    def check_language_support(self):
+        if not self._binary_exists('check-language-support'):
+            self.install_package('language-selector-common', update_cache=False)
+
+        self.run_in_container("bash -c \"{} install $(check-language-support -l {})\"".format(_apt_command_prefix(), self.language))
+
+    def update_locale(self):
+        self.run_in_container("locale-gen {}".format(self.locale))
+
+    def install_base_language_packs(self):
+        base_language_packs = ['language-pack-{}', 'language-pack-gnome-{}']
+
+        for language_pack in [p.format(self.language) for p in base_language_packs]:
+            self.install_package(language_pack, update_cache=False)
+
     def create_libertine_container(self, password=None, multiarch=False):
-        pass
+        self.install_base_language_packs()
 
     def destroy_libertine_container(self):
         pass
@@ -150,11 +208,18 @@
         """
         return self.run_in_container(_apt_command_prefix() + 'update')
 
-    def update_packages(self):
+    def update_packages(self, new_locale=None):
         """
         Updates all packages installed in the container.
         """
         self.update_apt_cache()
+
+        if new_locale:
+            self.locale = new_locale
+            self.language = self._get_language_from_locale()
+            self.update_locale()
+            self.install_base_language_packs()
+
         return self.run_in_container(_apt_command_prefix() + '--force-yes dist-upgrade') == 0
 
     def install_package(self, package_name, no_dialog=False, update_cache=True):
@@ -185,7 +250,11 @@
         else:
             if no_dialog:
                 os.environ['DEBIAN_FRONTEND'] = 'teletype'
-            return self.run_in_container(_apt_command_prefix() + " install '" + package_name + "'") == 0
+            ret = self.run_in_container(_apt_command_prefix() + " install '" + package_name + "'") == 0
+
+        self.check_language_support()
+
+        return ret
 
     def remove_package(self, package_name):
         """
@@ -219,7 +288,7 @@
         :param archive: The configuration command to run.
         :param public_key_file: file containing the public key used to sign this archive
         """
-        if not os.path.exists(os.path.join(self.root_path, 'usr', 'bin', 'add-apt-repository')):
+        if not self._binary_exists('add-apt-repository'):
             self.install_package("software-properties-common")
         if 'https://' in archive and not os.path.exists(os.path.join(self.root_path, 'usr', 'lib', 'apt', 'methods', 'https')):
             self.install_package("apt-transport-https")
@@ -254,8 +323,8 @@
     """
     A concrete mock container type.  Used for unit testing.
     """
-    def __init__(self, container_id):
-        super().__init__(container_id)
+    def __init__(self, container_id, containers_config=None):
+        super().__init__(container_id, containers_config)
         self.container_type = "mock"
 
     def create_libertine_container(self, password=None, multiarch=False):
@@ -264,7 +333,7 @@
     def destroy_libertine_container(self):
         return True
 
-    def update_packages(self):
+    def update_packages(self, new_locale=None):
         return True
 
     def install_package(self, package_name, no_dialog=False, update_cache=True):
@@ -328,7 +397,7 @@
             from  libertine.ChrootContainer import LibertineChroot
             self.container = LibertineChroot(container_id)
         elif container_type == "mock":
-            self.container = LibertineMock(container_id)
+            self.container = LibertineMock(container_id, self.containers_config)
         else:
             raise RuntimeError("Unsupported container type %s" % container_type)
 
@@ -363,13 +432,13 @@
 
         return self.container.create_libertine_container(password, multiarch)
 
-    def update_libertine_container(self):
+    def update_libertine_container(self, new_locale=None):
         """
         Updates the contents of the container.
         """
         try:
             with ContainerRunning(self.container):
-                return self.container.update_packages()
+                return self.container.update_packages(new_locale)
         except RuntimeError as e:
             return handle_runtime_error(e)
 

=== modified file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	2017-01-05 15:25:21 +0000
+++ python/libertine/LxcContainer.py	2017-01-18 14:37:20 +0000
@@ -179,11 +179,6 @@
             _dump_lxc_log(result.logfile)
             raise RuntimeError(result.error)
 
-        if self.run_in_container("mountpoint -q /tmp/.X11-unix") == 0:
-            self.run_in_container("umount /tmp/.X11-unix")
-        if self.run_in_container("mountpoint -q /usr/lib/locale") == 0:
-            self.run_in_container("umount -l /usr/lib/locale")
-
     def stop_container(self):
         if self.lxc_manager_interface:
             self.lxc_manager_interface.operation_stop(self.container_id)
@@ -194,14 +189,14 @@
         cmd_args = shlex.split(command_string)
         return self.container.attach_wait(lxc.attach_run_command, cmd_args)
 
-    def update_packages(self):
+    def update_packages(self, update_locale=False):
         if self.timezone_needs_update():
             self.run_in_container("bash -c \'echo \"{}\" >/etc/timezone\'".format(
                                   self.host_info.get_host_timezone()))
             self.run_in_container("rm -f /etc/localtime")
             self.run_in_container("dpkg-reconfigure -f noninteractive tzdata")
 
-        return super().update_packages()
+        return super().update_packages(update_locale)
 
     def destroy_libertine_container(self):
         if not self.container.defined:
@@ -265,6 +260,8 @@
             self.destroy_libertine_container()
             return False
 
+        self.update_locale()
+
         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)))
@@ -282,6 +279,8 @@
                 self.destroy_libertine_container()
                 return False
 
+        super().create_libertine_container()
+
         utils.get_logger().info("stopping container ...")
         self.stop_container()
 
@@ -334,7 +333,7 @@
             return
 
         self.window_manager = self.container.attach(lxc.attach_run_command,
-                                                    utils.setup_window_manager(self.container_id))
+                                                    self.setup_window_manager())
 
         # Setup pulse to work inside the container
         os.environ['PULSE_SERVER'] = utils.get_libertine_lxc_pulse_socket_path()

=== modified file 'python/libertine/LxdContainer.py'
--- python/libertine/LxdContainer.py	2017-01-05 20:16:25 +0000
+++ python/libertine/LxdContainer.py	2017-01-18 14:37:20 +0000
@@ -12,6 +12,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 contextlib
 import crypt
 import dbus
 import os
@@ -98,20 +99,6 @@
 
 
 def _setup_bind_mount_service(container, uid, username):
-    utils.get_logger().info("Creating systemd mount override service")
-    service = '''
-[Unit]
-Description=Fix system mounts for libertine
-
-[Service]
-ExecStart=/usr/bin/libertine-lxd-mount-update
-
-[Install]
-WantedBy=multi-user.target
-'''[1:-1]
-    container.files.put('/etc/systemd/system/libertine-lxd-mount-update.service', service.encode('utf-8'))
-    container.execute(shlex.split('chmod 644 /etc/systemd/system/libertine-lxd-mount-update.service'))
-
     utils.get_logger().info("Creating mount update shell script")
     script = '''
 #!/bin/sh
@@ -128,9 +115,6 @@
     container.files.put('/usr/bin/libertine-lxd-mount-update', script.format(uid=uid, username=username).encode('utf-8'))
     container.execute(shlex.split('chmod 755 /usr/bin/libertine-lxd-mount-update'))
 
-    utils.get_logger().info("Enabling systemd mount update service")
-    container.execute(shlex.split('systemctl enable libertine-lxd-mount-update.service'))
-
 
 def lxd_container(client, container_id):
     try:
@@ -174,11 +158,72 @@
     return LifecycleResult()
 
 
+def _lxd_save(entity, error, wait=True):
+    try:
+        entity.save(wait=wait)
+    except pylxd.exceptions.LXDAPIException as e:
+        utils.get_logger().warning('{} {}'.format(error, str(e)))
+
+
+_CONTAINER_DATA_DIRS = ["/usr/share/applications", "/usr/share/icons", "/usr/local/share/applications", "/usr/share/pixmaps"]
+
+
+class RestoreDevice(contextlib.ExitStack):
+    def __init__(self, container, device):
+        super().__init__()
+        self._container = container
+        self._device = device
+        self._source = None
+        self.remove()
+        self.callback(self.restore)
+
+    def remove(self):
+        if self._device in self._container.devices:
+            self._source = self._container.devices[self._device]
+            del self._container.devices[self._device]
+            _lxd_save(self._container, 'Saving bind mounts for container \'{}\' raised:'.format(self._container.name))
+
+    def restore(self):
+        if self._source is not None:
+            self._container.devices[self._device] = self._source
+            _lxd_save(self._container, 'Saving bind mounts for container \'{}\' raised:'.format(self._container.name), False)
+
+
+def _sync_application_dirs_to_host(container):
+    host_root = utils.get_libertine_container_rootfs_path(container.name)
+    for container_path in _CONTAINER_DATA_DIRS:
+        utils.get_logger().info("Syncing applications directory: {}".format(container_path))
+        os.makedirs(os.path.join(host_root, container_path.lstrip("/")), exist_ok=True)
+        with RestoreDevice(container, container_path):
+            # find a list of files within the container
+            find = subprocess.Popen(shlex.split("lxc exec {} -- find {} -type f".format(container.name, container_path)), stdout=subprocess.PIPE)
+            stdout, stderr = find.communicate()
+
+        if find.returncode == 0:
+            for filepath in stdout.decode('utf-8').strip().split('\n'):
+                if filepath:
+                    host_path = os.path.join(host_root, filepath.lstrip("/"))
+                    if not os.path.exists(host_path):
+                        utils.get_logger().debug("Syncing file: {}:{}".format(filepath, host_path))
+                        os.makedirs(os.path.dirname(host_path), exist_ok=True)
+                        with open(host_path, 'wb') as f:
+                            f.write(container.files.get(filepath))
+
+
 def update_bind_mounts(container, config):
     home_path = os.environ['HOME']
+    userdata_dir = utils.get_libertine_container_userdata_dir_path(container.name)
 
     container.devices.clear()
     container.devices['root'] = {'type': 'disk', 'path': '/'}
+    container.devices['home'] = {'type': 'disk', 'path': home_path, 'source': userdata_dir}
+
+    # applications and icons directories
+    rootfs_path = utils.get_libertine_container_rootfs_path(container.name)
+    for data_dir in _CONTAINER_DATA_DIRS:
+        host_path = "{}{}".format(rootfs_path, data_dir)
+        os.makedirs(host_path, exist_ok=True)
+        container.devices[data_dir] = {'type': 'disk', 'path': data_dir, 'source': host_path}
 
     if os.path.exists(os.path.join(home_path, '.config', 'dconf')):
         container.devices['dconf'] = {
@@ -201,6 +246,8 @@
             path = user_dir[1]
         else:
             path = os.path.join(home_path, user_dir[1])
+            hostpath = os.path.join(userdata_dir, user_dir[1])
+            os.makedirs(hostpath, exist_ok=True)
 
         utils.get_logger().debug("Mounting {}:{} in container {}".format(user_dir[0], path, container.name))
 
@@ -211,11 +258,7 @@
                 'type': 'disk'
         }
 
-    try:
-        container.save(wait=True)
-    except pylxd.exceptions.LXDAPIException as e:
-        utils.get_logger().warning('Saving bind mounts for container \'{}\' raised: {}'.format(container.name, str(e)))
-        # This is most likely the result of the container currently running
+    _lxd_save(container, 'Saving bind mounts for container \'{}\' raised:'.format(container.name))
 
 
 def update_libertine_profile(client):
@@ -226,12 +269,7 @@
         profile.devices = _get_devices_map()
         profile.config['raw.idmap'] = 'both 1000 1000'
 
-        try:
-            profile.save()
-        except pylxd.exceptions.LXDAPIException as e:
-            utils.get_logger().warning('Saving libertine lxd profile raised: {}'.format(str(e)))
-            # This is most likely the result of an older container currently
-            # running and/or containing a conflicting device entry
+        _lxd_save(profile, 'Saving libertine lxd profile raised:')
     except pylxd.exceptions.LXDAPIException:
         utils.get_logger().info('Creating libertine lxd profile.')
         client.profiles.create('libertine', config={'raw.idmap': 'both 1000 1000'}, devices=_get_devices_map())
@@ -251,7 +289,6 @@
 
         self._client = pylxd.Client()
         self._window_manager = None
-        self.root_path = '{}/containers/{}/rootfs'.format(os.getenv('LXD_DIR', '/var/lib/lxd'), name)
 
         utils.set_session_dbus_env_var()
         try:
@@ -277,19 +314,22 @@
             utils.get_logger().error("Creating container '{}' failed with code '{}'".format(self._id, create.returncode))
             return False
 
-        if not self.start_container():
-            utils.get_logger().error("Failed to start container '{}'".format(self._id))
-            self.destroy_libertine_container()
-            return False
+        self._try_get_container()
+        _sync_application_dirs_to_host(self._container)
+        update_bind_mounts(self._container, self._config)
+
+        self.update_locale()
 
         username = os.environ['USER']
         uid = str(os.getuid())
         self.run_in_container("userdel -r ubuntu")
         self.run_in_container("useradd -u {} -U -p {} -G sudo,audio,video {}".format(
-            uid, crypt.crypt(''), username))
+            uid, crypt.crypt(password or ''), username))
         self.run_in_container("mkdir -p /home/{}".format(username))
         self.run_in_container("chown {0}:{0} /home/{0}".format(username))
 
+        utils.create_libertine_user_data_dir(self._id)
+
         _setup_bind_mount_service(self._container, uid, username)
 
         if multiarch and self.architecture == 'amd64':
@@ -305,25 +345,34 @@
                 self.destroy_libertine_container()
                 return False
 
+        super().create_libertine_container()
+
         return True
 
-    def update_packages(self):
+    def update_packages(self, update_locale=False):
         if not self._timezone_in_sync():
             utils.get_logger().info("Re-syncing timezones")
             self.run_in_container("bash -c 'echo \"%s\" > /etc/timezone'" % self._host_info.get_host_timezone())
             self.run_in_container("rm -f /etc/localtime")
             self.run_in_container("dpkg-reconfigure -f noninteractive tzdata")
 
-        return super().update_packages()
+        _sync_application_dirs_to_host(self._container)
+        update_bind_mounts(self._container, self._config)
+
+        return super().update_packages(update_locale)
 
     def destroy_libertine_container(self):
         if not self._try_get_container():
             utils.get_logger().error("No such container '%s'" % self._id)
             return False
 
-        self.stop_container(wait=True)
+        if not self.stop_container(wait=True):
+            utils.get_logger().error("Canceling destruction due to running container")
+            return False
+
         self._container.delete()
-        return True
+
+        return self._delete_rootfs()
 
     def _timezone_in_sync(self):
         proc = subprocess.Popen(self._lxc_args('cat /etc/timezone'), stdout=subprocess.PIPE)
@@ -366,7 +415,7 @@
             return False
 
         if self._manager:
-            result = LifecycleResult.from_dict(self._manager.operation_stop(self._id))
+            result = LifecycleResult.from_dict(self._manager.operation_stop(self._id, {'wait': wait}))
         else:
             result = lxd_stop(self._container, wait)
 
@@ -382,7 +431,7 @@
 
     # FIXME: Remove once window management logic has been moved to the host
     def _start_window_manager(self, args):
-        args.extend(utils.setup_window_manager(self._id))
+        args.extend(self.setup_window_manager())
 
         if 'matchbox-window-manager' in args:
             pids = self._get_matchbox_pids()
@@ -404,6 +453,8 @@
             utils.get_logger().error("Could not get container '{}'".format(self._id))
             return None
 
+        requires_remount = self._container.status != 'Running'
+
         if self._manager:
             result = LifecycleResult.from_dict(self._manager.app_start(self._id))
         else:
@@ -415,7 +466,10 @@
             utils.get_logger().error(result.error)
             return False
 
-        args = self._lxc_args("sudo -E -u {} env PATH={}".format(os.environ['USER'], environ['PATH']), environ)
+        if requires_remount:
+            self._container.execute(shlex.split('/usr/bin/libertine-lxd-mount-update'))
+
+        args = self._lxc_args("sudo -E -u {} env PATH={}".format(environ['USER'], environ['PATH']), environ)
 
         self._start_window_manager(args.copy())
 

=== modified file 'python/libertine/lifecycle/ContainerLifecycleService.py'
--- python/libertine/lifecycle/ContainerLifecycleService.py	2016-12-23 15:46:44 +0000
+++ python/libertine/lifecycle/ContainerLifecycleService.py	2017-01-18 14:37:20 +0000
@@ -46,7 +46,7 @@
     def start(self, container):
         raise NotImplementedError("Subclasses must implement start(container)")
 
-    def stop(self, container):
+    def stop(self, container, options={}):
         raise NotImplementedError("Subclasses must implement stop(container)")
 
     @dbus.service.method(LIBERTINE_CONTAINER_LIFECYCLE_INTERFACE,
@@ -55,7 +55,7 @@
     def app_start(self, container):
         utils.get_logger().debug("app_start({})".format(container))
         if self._operations[container] != 0:
-            return LifecycleResult("Libertine container operation already running: cannot launch application.")
+            return LifecycleResult("Libertine container operation already running: cannot launch application.").to_dict()
 
         result = self.start(container, True)
 
@@ -84,7 +84,7 @@
     def operation_start(self, container):
         utils.get_logger().debug("operation_start({})".format(container))
         if self._apps[container] != 0:
-            return LifecycleResult("Application already running in container: cannot run operation.")
+            return LifecycleResult("Application already running in container: cannot run operation.").to_dict()
 
         result = self.start(container, False)
 
@@ -94,15 +94,15 @@
         return result.to_dict()
 
     @dbus.service.method(LIBERTINE_CONTAINER_LIFECYCLE_INTERFACE,
-                         in_signature='s',
+                         in_signature='sa{ss}',
                          out_signature='a{ss}')
-    def operation_stop(self, container):
-        utils.get_logger().debug("operation_stop({})".format(container))
+    def operation_stop(self, container, options={}):
+        utils.get_logger().debug("operation_stop({}, {})".format(container, options))
         self._operations[container] -= 1
         result = LifecycleResult()
 
         if self._operations[container] == 0:
-            result = self.stop(container)
+            result = self.stop(container, options)
             del self._operations[container]
 
         return result.to_dict()

=== modified file 'python/libertine/utils.py'
--- python/libertine/utils.py	2017-01-05 14:23:21 +0000
+++ python/libertine/utils.py	2017-01-18 14:37:20 +0000
@@ -103,6 +103,9 @@
     if path is None:
         path = os.path.join(basedir.xdg_data_home, 'libertine-container', 'user-data', container_id)
 
+    if is_snap_environment():
+        path = path.replace(os.environ['HOME'], os.getenv('SNAP_USER_COMMON'))
+
     return path
 
 
@@ -163,17 +166,6 @@
     return os.path.join(get_libertine_runtime_dir(), 'pulse_socket')
 
 
-def setup_window_manager(container_id, enable_toolbars=False):
-    if os.path.exists(os.path.join(get_libertine_container_rootfs_path(container_id),
-                                   'usr', 'bin', 'matchbox-window-manager')):
-        if enable_toolbars:
-            return ['matchbox-window-manager']
-
-        return ['matchbox-window-manager', '-use_titlebar', 'no']
-    else:
-        return ['compiz']
-
-
 def terminate_window_manager(window_manager):
     for child in window_manager.children():
         child.terminate()

=== modified file 'snapcraft.yaml'
--- snapcraft.yaml	2017-01-05 20:20:33 +0000
+++ snapcraft.yaml	2017-01-18 14:37:20 +0000
@@ -1,5 +1,5 @@
 name: libertine
-version: 1.5+17.04.20170105.1-0ubuntu1
+version: "1.5.1"
 summary: Libertine suite
 description: |
     Suite for maintaining deb-based applications in a non-deb environment

=== modified file 'tools/libertine-container-manager'
--- tools/libertine-container-manager	2017-01-05 14:23:21 +0000
+++ tools/libertine-container-manager	2017-01-18 14:37:20 +0000
@@ -34,6 +34,14 @@
         self.containers_config = ContainersConfig()
         self.host_info = HostInfo()
 
+    def _get_updated_locale(self, container_id):
+        host_locale = self.host_info.get_host_locale()
+        
+        if host_locale == self.containers_config.get_container_locale(container_id):
+            return None
+        else:
+            return host_locale
+
     def create(self, args):
         password = None
 
@@ -71,7 +79,7 @@
         if not args.name:
             args.name = "Ubuntu \'" + (self.host_info.get_distro_codename(args.distro) or args.distro) + "\'"
 
-        if container_type == "lxc":
+        if container_type == "lxc" or container_type == "lxd":
             if args.password:
                 password = args.password
             elif sys.stdin.isatty():
@@ -88,6 +96,7 @@
         self.containers_config.update_container_multiarch_support(args.id, multiarch)
 
         try:
+            self.containers_config.update_container_locale(args.id, self.host_info.get_host_locale())
             container = LibertineContainer(args.id)
             self.containers_config.update_container_install_status(args.id, "installing")
             if not container.create_libertine_container(password, args.multiarch):
@@ -96,6 +105,9 @@
                 sys.exit(1)
         except Exception as e:
             libertine.utils.get_logger().error("Failed to create container: '{}'".format(str(e)))
+            if container:
+                container.destroy_libertine_container()
+
             self.containers_config.delete_container(args.id)
             sys.exit(1)
 
@@ -139,7 +151,7 @@
         else:
             self.containers_config.add_new_package(container_id, package)
 
-        container = LibertineContainer(container_id)
+        container = LibertineContainer(container_id, self.containers_config)
 
         self.containers_config.update_package_install_status(container_id, package, "installing")
         if not container.install_package(args.package, args.no_dialog):
@@ -191,14 +203,18 @@
 
     def update(self, args):
         container_id = self.containers_config.check_container_id(args.id)
+        new_locale = self._get_updated_locale(container_id)
 
         container = LibertineContainer(container_id)
 
         self.containers_config.update_container_install_status(container_id, "updating")
-        if not container.update_libertine_container():
+        if not container.update_libertine_container(new_locale):
             self.containers_config.update_container_install_status(container_id, "ready")
             sys.exit(1)
 
+        if new_locale:
+            self.containers_config.update_container_locale(container_id, new_locale)
+
         self.containers_config.update_container_install_status(container_id, "ready")
 
     def list(self, args):
@@ -454,7 +470,8 @@
     # Handle the update command and its options
     parser_update = subparsers.add_parser(
         'update',
-        help=("Update the packages in the Libertine container."))
+        help=("Update the packages in the Libertine container.  Also updates the container's "
+              "locale and installs necessary language packs if the host's locale has changed."))
     parser_update.add_argument(
         '-i', '--id',
         help=("Container identifier.  Default container is used if omitted."))

=== modified file 'tools/libertine-container-manager.1'
--- tools/libertine-container-manager.1	2016-12-07 21:24:16 +0000
+++ tools/libertine-container-manager.1	2017-01-18 14:37:20 +0000
@@ -52,7 +52,7 @@
 Searches the apt cache inside an existing Libertine container for matches based on the given search string.
 .TP
 .B libertine-container-manager update [options]
-Updates the packages inside an existing Libertine container.
+Updates the packages inside an existing Libertine container.  Also updates the container's locale and installs necessary language packs if the host's locale has changed.
 .TP
 .B libertine-container-manager list [options]
 Lists all existing Libertine containers.

=== modified file 'tools/libertine-lxc-manager'
--- tools/libertine-lxc-manager	2017-01-05 19:50:46 +0000
+++ tools/libertine-lxc-manager	2017-01-18 14:37:20 +0000
@@ -55,7 +55,7 @@
 
         return LifecycleResult()
 
-    def stop(self, container_id):
+    def stop(self, container_id, options={}):
         container = libertine.LxcContainer.lxc_container(container_id)
         libertine.LxcContainer.lxc_stop(container)
 

=== modified file 'tools/libertine-lxd-manager'
--- tools/libertine-lxd-manager	2016-12-21 20:37:57 +0000
+++ tools/libertine-lxd-manager	2017-01-18 14:37:20 +0000
@@ -49,8 +49,8 @@
 
         return LifecycleResult()
 
-    def stop(self, container_id):
-        return libertine.LxdContainer.lxd_stop(libertine.LxdContainer.lxd_container(self._client, container_id), False)
+    def stop(self, container_id, options={}):
+        return libertine.LxdContainer.lxd_stop(libertine.LxdContainer.lxd_container(self._client, container_id), options.get('wait', False))
 
 
 if __name__ == '__main__':