Merge lp:~bregma/libertine/scan-desktop-files into lp:libertine

[Stephen M. Webb]

added scanning for launchable applications in a container

Adds a function to the libertine-container-manager to scan a container for launchable applications and report them in JSON format, together with icons and MIME types.

[Libertine CI Bot (libertine-ci-bot)]

FAILED: Continuous integration, rev:151
http://libertine-jenkins-be.internal:8080/libertine/job/libertine-ci-build-and-test/947/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/950/console

Click here to trigger a rebuild:
http://libertine-jenkins-be.internal:8080/libertine/job/libertine-ci-build-and-test/947/rebuild

review: Needs Fixing (continuous-integration)

[Libertine CI Bot (libertine-ci-bot)]

FAILED: Continuous integration, rev:152
http://libertine-jenkins-be.internal:8080/libertine/job/libertine-ci-build-and-test/948/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/951/console

Click here to trigger a rebuild:
http://libertine-jenkins-be.internal:8080/libertine/job/libertine-ci-build-and-test/948/rebuild

review: Needs Fixing (continuous-integration)

[Christopher Townsend (townsend)]

As discussed on IRC, mb-panel-manager.desktop has:

Icon=mbpanelmgr.png

but the output of list-apps has this:

        {
            "exec_line": "matchbox-panel-manager",
            "icons": [],
            "mime_types": [],
            "name": "Panel Manager",
            "no_display": false
        }

Nothing in "icons", so this is still not working correctly.

I'm sure there will be other corner cases, but we might as well fix what we know about:)

review: Needs Fixing

[lp:~bregma/libertine/scan-desktop-files]

153. By Stephen M. Webb on 2015-12-20

synched trunk again

154. By Stephen M. Webb on 2015-12-21

added unit tests

[Libertine CI Bot (libertine-ci-bot)]

FAILED: Continuous integration, rev:154
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/74/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/971/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/74/rebuild

review: Needs Fixing (continuous-integration)

[lp:~bregma/libertine/scan-desktop-files]

155. By Stephen M. Webb on 2015-12-21

extended test environment

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:155
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/75/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/972/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/75/rebuild

review: Approve (continuous-integration)

[lp:~bregma/libertine/scan-desktop-files]

156. By Stephen M. Webb on 2015-12-21

fixed some typos

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:156
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/76/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/973/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/76/rebuild

review: Approve (continuous-integration)

[lp:~bregma/libertine/scan-desktop-files]

157. By Stephen M. Webb on 2015-12-22

added a non-JSON default output for list-apps

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:157
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/77/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/974/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/77/rebuild

review: Approve (continuous-integration)

[lp:~bregma/libertine/scan-desktop-files]

158. By Stephen M. Webb on 2015-12-22

used actual container name and root path when discovering app launchers

159. By Stephen M. Webb on 2015-12-22

added some unit tests for LibertineContainer

[Libertine CI Bot (libertine-ci-bot)]

FAILED: Continuous integration, rev:159
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/79/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/976/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/79/rebuild

review: Needs Fixing (continuous-integration)

[lp:~bregma/libertine/scan-desktop-files]

160. By Stephen M. Webb on 2015-12-22

used liblibertine to retrieve the container name

[Libertine CI Bot (libertine-ci-bot)]

FAILED: Continuous integration, rev:160
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/81/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/978/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/81/rebuild

review: Needs Fixing (continuous-integration)

[lp:~bregma/libertine/scan-desktop-files]

161. By Stephen M. Webb on 2015-12-23

allowed the config file to not exist

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:161
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/82/
Executed test runs:
    None: https://jenkins.canonical.com/libertine/job/libertine-ci-update-mp/979/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/libertine-ci-verify-mp/82/rebuild

review: Approve (continuous-integration)

[Christopher Townsend (townsend)]

Ok, looks good now.

review: Approve

=== modified file 'debian/python3-libertine.install'
--- debian/python3-libertine.install	2015-11-30 14:37:36 +0000
+++ debian/python3-libertine.install	2015-12-23 02:34:33 +0000
@@ -1,3 +1,4 @@
-usr/lib/python*/*/libertine/__init__.py
+usr/lib/python*/*/libertine/AppDiscovery.py
 usr/lib/python*/*/libertine/Libertine.py
 usr/lib/python*/*/libertine/utils.py
+usr/lib/python*/*/libertine/__init__.py

=== added file 'python/libertine/AppDiscovery.py'
--- python/libertine/AppDiscovery.py	1970-01-01 00:00:00 +0000
+++ python/libertine/AppDiscovery.py	2015-12-23 02:34:33 +0000
@@ -0,0 +1,220 @@
+# 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/>.
+
+from . import utils
+from xdg.BaseDirectory import xdg_data_dirs
+import configparser
+import glob
+import io
+import json
+import os
+import re
+import sys
+
+
+class IconCache(object):
+    """
+    Caches the names of all icon files available in the standard places (possibly
+    in a container) and provides a search function to deliver icon file names
+    matching a given icon name.
+
+    See the `Freedesktop.org icon theme specification
+    <http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html>`_
+    for the detailed specification.
+    """
+
+    def __init__(self, root_path, file_loader=None):
+        """
+        :param root_path: Where to start the file scan.
+        :type root_path: A valid filesystem path string.
+        :param file_loader: A function that builds a cache of filenames.
+        :type file_loader: Function returning a list of filenames.
+        """
+        if file_loader:
+            self._icon_cache = file_loader(root_path)
+        else:
+            self._icon_cache = self._file_loader(root_path)
+
+    def _get_icon_search_paths(self, root_path):
+        """
+        Gets a list of paths on which to search for icons.
+
+        :param root_path: Where to start the file scan.
+        :type root_path: A valid filesystem path string.
+        :rtype: A list of filesystem patch to serarch for qualifying icon files.
+        """
+        icon_search_paths = []
+        icon_search_paths.append(os.path.join(root_path, os.environ['HOME'], ".icons"))
+        for d in reversed(xdg_data_dirs):
+            icon_search_paths.append(os.path.join(root_path, d.lstrip('/'), "icons"))
+        icon_search_paths.append(os.path.join(root_path, "usr/share/pixmaps"))
+        return icon_search_paths
+
+    def _file_loader(self, root_path):
+        """
+        Loads a cache of file names by scanning the filesystem rooted at
+        ``root_path``.
+
+        :param root_path: Where to start the file scan.
+        :type root_path: A valid filesystem path.
+        :rtype: A list of fully-qualified file paths.
+        """
+        file_names = []
+        pattern = re.compile(r".*\.(png|svg|xpm)")
+        for path in self._get_icon_search_paths(root_path):
+            for base, dirs, files in os.walk(path):
+                for file in files:
+                    if pattern.match(file):
+                        file_names.append(os.path.join(base, file))
+        return file_names
+
+    def _find_icon_files(self, icon_name):
+        """
+        Finds a list of file name strings matching the given icon name.
+
+        :param icon_name: An icon name, pobably from a .desktop file.
+        :rtype: A list of filename strings matching the icon name.
+        """
+        icon_file_names = []
+        match_string = r"/" + os.path.splitext(icon_name)[0] + r"\....$"
+        pattern = re.compile(match_string)
+        for icon_file in self._icon_cache:
+            if pattern.search(icon_file):
+                icon_file_names.append(icon_file)
+        return icon_file_names
+
+    def expand_icons(self, desktop_icon_list):
+        """
+        Expands a string containing a list of icon names into a list of matching
+        file names.
+
+        :param desktop_icon_list: A string containing a list of icon names
+        separated by semicolons.
+        :rtype: A list of filename stings matching the icon names passed in.
+
+        See `the Freedesktop.org desktop file specification
+        <http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#recognized-keys>`_
+        for more information.
+        """
+        if desktop_icon_list:
+            icon_list = desktop_icon_list.split(';')
+            if icon_list[0][0] == '/':
+                return icon_list
+            icon_files = []
+            for i in icon_list:
+                icon_files += self._find_icon_files(i)
+            return icon_files
+        return []
+
+
+def expand_mime_types(desktop_mime_types):
+    if desktop_mime_types:
+        return desktop_mime_types.split(';')
+    return []
+
+
+class AppInfo(object):
+
+    def __init__(self, config_entry, icon_cache):
+        self.name = config_entry.get('Name')
+        if not self.name:
+            raise RuntimeError("required Name attribute is missing")
+        d = config_entry.get('NoDisplay')
+        self.no_display = (d != None and d == 'true')
+        self.exec_line = config_entry.get('Exec')
+        if not self.exec_line:
+            raise RuntimeError("required Exec attribute is missing")
+        self.icons = icon_cache.expand_icons(config_entry.get('Icon'))
+        self.mime_types = expand_mime_types(config_entry.get('MimeType'))
+
+    def __str__(self):
+        with io.StringIO() as ostr:
+            print(self.name, file=ostr)
+            print("  no-display={}".format(self.no_display), file=ostr)
+            print("  exec='{}'".format(self.exec_line), file=ostr)
+            for icon in self.icons:
+                print("  icon: {}".format(icon), file=ostr)
+            for mime in self.mime_types:
+                print("  mime: {}".format(mime), file=ostr)
+            return ostr.getvalue()
+
+    def to_json(self):
+        return json.dumps(self.__dict__)
+
+
+def desktop_file_is_showable(desktop_entry):
+    """
+    Determines if a particular application entry should be reported:  the entry
+    can not be hidden and must be showable in Unity.
+    """
+    t = desktop_entry.get('Type')
+    if t != 'Application':
+        return False
+    n = desktop_entry.get('Hidden')
+    if n and n == 'true':
+        return False
+    n = desktop_entry.get('NoShowIn')
+    if n:
+        targets = n.split(';')
+        if 'Unity' in targets:
+            return False
+    n = desktop_entry.get('OnlyShowIn')
+    if n:
+        targets = n.split(';')
+        if 'Unity' not in targets:
+            return False
+    return True
+
+
+def get_app_info(desktop_path, icon_cache):
+    for desktop_file_name in glob.glob(desktop_path):
+        desktop_file = configparser.ConfigParser(strict=False, interpolation=None)
+        try:
+            desktop_file.read(desktop_file_name)
+            desktop_entry = desktop_file['Desktop Entry']
+            if desktop_file_is_showable(desktop_entry):
+                    yield AppInfo(desktop_entry, icon_cache)
+        except Exception as ex:
+            print("error processing {}: {}".format(desktop_file_name, ex), file=sys.stderr)
+
+
+class AppLauncherCache(object):
+    """
+    Caches a list of application launcher information (derived from .desktop
+    files installed in a container.
+    """
+
+    def __init__(self, name, root_path):
+        self.name = name
+        self.app_launchers = []
+        icon_cache = IconCache(root_path)
+        for dir in reversed(xdg_data_dirs):
+            path = os.path.join(root_path, dir.lstrip('/'), "applications")
+            for app_info in get_app_info(os.path.join(path, "*.desktop"), icon_cache):
+                self.app_launchers.append(app_info)
+
+    def __str__(self):
+        with io.StringIO() as ostr:
+            print("{}\n".format(self.name), file=ostr)
+            for app_info in self.app_launchers:
+                print("  {}".format(app_info), file=ostr)
+            return ostr.getvalue()
+
+    def to_json(self):
+        return json.dumps(self,
+                          default=lambda o: o.__dict__,
+                          sort_keys=True,
+                          indent=4)
+
+

=== modified file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	2015-12-14 18:08:13 +0000
+++ python/libertine/ChrootContainer.py	2015-12-23 02:34:33 +0000
@@ -40,36 +40,6 @@
         os.chown(path, uid, gid)
 
 
-def build_proot_command(container_id):
-    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')
-    proot_cmd += " -R " + utils.get_libertine_container_rootfs_path(container_id)
-
-    # Bind-mount the host's locale(s)
-    proot_cmd += " -b /usr/lib/locale"
-
-    # Bind-mount extrausers on the phone
-    if os.path.exists("/var/lib/extrausers"):
-        proot_cmd += " -b /var/lib/extrausers"
-
-    home_path = os.environ['HOME']
-
-    # Bind-mount common XDG direcotries
-    bind_mounts = (
-        " -b %s:%s"
-        % (utils.get_libertine_container_userdata_dir_path(container_id), home_path)
-    )
-
-    xdg_user_dirs = ['Documents', 'Music', 'Pictures', 'Videos']
-    for user_dir in xdg_user_dirs:
-        user_dir_path = os.path.join(home_path, user_dir)
-        bind_mounts += " -b %s:%s" % (user_dir_path, user_dir_path)
-
-    proot_cmd += bind_mounts
-    return proot_cmd
-
-
 class LibertineChroot(BaseContainer):
     """
     A concrete container type implemented using a plain old chroot.
@@ -77,7 +47,7 @@
 
     def __init__(self, container_id):
         super().__init__(container_id)
-        self.chroot_path = utils.get_libertine_container_rootfs_path(container_id)
+        self.container_type = "chroot"
         os.environ['FAKECHROOT_CMD_SUBST'] = '$FAKECHROOT_CMD_SUBST:/usr/bin/chfn=/bin/true'
         os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
 
@@ -87,35 +57,35 @@
             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
+            command_prefix = proot_cmd + " -b /usr/lib/locale -S " + self.root_path
         else:
-            command_prefix = "fakechroot fakeroot chroot " + self.chroot_path
+            command_prefix = "fakechroot fakeroot chroot " + self.root_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)
+        shutil.rmtree(self.root_path)
 
     def create_libertine_container(self, password=None, verbosity=1):
         installed_release = self.get_container_distro(self.container_id)
 
         # Create the actual chroot
         if installed_release == "trusty":
-            command_line = "debootstrap --verbose " + installed_release + " " + self.chroot_path
+            command_line = "debootstrap --verbose " + installed_release + " " + self.root_path
         else:
             command_line = "fakechroot fakeroot debootstrap --verbose --variant=fakechroot {} {}".format(
-                    installed_release, self.chroot_path)
+                    installed_release, self.root_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'))
+            os.remove(os.path.join(self.root_path, 'dev'))
+            os.remove(os.path.join(self.root_path, 'proc'))
 
-            with open(os.path.join(self.chroot_path, 'usr', 'sbin', 'policy-rc.d'), 'w+') as fd:
+            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")
@@ -134,7 +104,7 @@
 
         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:
+        with open(os.path.join(self.root_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")
@@ -147,7 +117,7 @@
             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
+            cmd_line_prefix = proot_cmd + " -b /usr/lib/locale -S " + self.root_path
 
             command_line = cmd_line_prefix + " dpkg-divert --local --rename --add /etc/init.d/systemd-logind"
             args = shlex.split(command_line)
@@ -193,8 +163,38 @@
         # 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))
 
+    def _build_proot_command(self):
+        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')
+
+        proot_cmd += " -R " + self.root_path
+
+        # Bind-mount the host's locale(s)
+        proot_cmd += " -b /usr/lib/locale"
+
+        # Bind-mount extrausers on the phone
+        if os.path.exists("/var/lib/extrausers"):
+            proot_cmd += " -b /var/lib/extrausers"
+
+        home_path = os.environ['HOME']
+
+        # Bind-mount common XDG direcotries
+        bind_mounts = (
+            " -b %s:%s"
+            % (utils.get_libertine_container_userdata_dir_path(self.container_id), home_path)
+        )
+
+        xdg_user_dirs = ['Documents', 'Music', 'Pictures', 'Videos']
+        for user_dir in xdg_user_dirs:
+            user_dir_path = os.path.join(home_path, user_dir)
+            bind_mounts += " -b %s:%s" % (user_dir_path, user_dir_path)
+
+        proot_cmd += bind_mounts
+        return proot_cmd
+
     def launch_application(self, app_exec_line):
-        proot_cmd = build_proot_command(self.container_id)
+        proot_cmd = self._build_proot_command()
 
         args = shlex.split(proot_cmd)
         args.extend(utils.setup_window_manager(self.container_id))

=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2015-12-18 21:40:39 +0000
+++ python/libertine/Libertine.py	2015-12-23 02:34:33 +0000
@@ -12,6 +12,8 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from .AppDiscovery import AppLauncherCache
+from gi.repository import Libertine
 import abc
 import contextlib
 import json
@@ -23,12 +25,16 @@
     Retrieves the type of container 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["type"]
+    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"
@@ -59,7 +65,9 @@
     :param container_id: The machine-readable container name.
     """
     def __init__(self, container_id):
+        self.container_type = 'unknown'
         self.container_id = container_id
+        self.root_path = libertine.utils.get_libertine_container_rootfs_path(self.container_id)
 
     def create_libertine_container(self, password=None, verbosity=1):
         pass
@@ -131,12 +139,24 @@
 
         return ""
 
+    @property
+    def name(self):
+        """
+        The human-readable name of the container.
+        """
+        name = Libertine.container_name(self.container_id)
+        if not name:
+            name = 'Unknown'
+        return name
+
+
 class LibertineMock(BaseContainer):
     """
     A concrete mock container type.  Used for unit testing.
     """
     def __init__(self, container_id):
         super().__init__(container_id)
+        self.container_type = "mock"
 
     def run_in_container(self, command_string):
         return 0
@@ -188,6 +208,22 @@
         else:
             raise RuntimeError("Unsupported container type %s" % container_type)
 
+    @property
+    def container_id(self):
+        return self.container.container_id
+
+    @property
+    def name(self):
+        return self.container.name
+
+    @property
+    def container_type(self):
+        return self.container.container_type
+
+    @property
+    def root_path(self):
+        return self.container.root_path
+
     def destroy_libertine_container(self):
         """
         Destroys the container and releases all its system resources.
@@ -245,3 +281,20 @@
             self.container.launch_application(app_exec_line) 
         else:
             raise RuntimeError("Container with id %s does not exist." % self.container.container_id)
+
+    def list_app_launchers(self, use_json=False):
+        """
+        Enumerates all application launchers (based on .desktop files) available
+        in the container.
+
+        :param use_json: Indicates the returned string should be i JSON format.
+            The default format is some human-readble format.
+        :rtype: A printable string containing a list of application launchers
+            available in the container.
+        """
+        if use_json:
+            return AppLauncherCache(self.container.name,
+                                    self.container.root_path).to_json()
+        else:
+            return str(AppLauncherCache(self.container.name,
+                                        self.container.root_path))

=== modified file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	2015-12-14 18:08:13 +0000
+++ python/libertine/LxcContainer.py	2015-12-23 02:34:33 +0000
@@ -70,6 +70,7 @@
 
     def __init__(self, container_id):
         super().__init__(container_id)
+        self.container_type = "lxc"
         self.container = lxc_container(container_id)
 
     def is_running(self):

=== modified file 'python/libertine/utils.py'
--- python/libertine/utils.py	2015-12-18 16:47:39 +0000
+++ python/libertine/utils.py	2015-12-23 02:34:33 +0000
@@ -52,11 +52,16 @@
 
 
 def get_libertine_containers_dir_path():
-    return basedir.save_cache_path('libertine-container')
+    xdg_cache_home = os.getenv('XDG_CACHE_HOME',
+                                os.path.join(os.getenv('HOME'), '.cache'))
+
+    return os.path.join(xdg_cache_home, 'libertine-container')
 
 
 def get_libertine_database_dir_path():
-    return os.path.join(basedir.xdg_data_home, 'libertine')
+    xdg_data_home = os.getenv('XDG_DATA_HOME',
+                              os.path.join(os.getenv('HOME'), '.local', 'share'))
+    return os.path.join(xdg_data_home, 'libertine')
 
 
 def get_libertine_database_file_path():

=== modified file 'tests/unit/CMakeLists.txt'
--- tests/unit/CMakeLists.txt	2015-12-17 17:34:24 +0000
+++ tests/unit/CMakeLists.txt	2015-12-23 02:34:33 +0000
@@ -30,6 +30,12 @@
                      PROPERTIES
                      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
 
+add_test(test_libertine "/usr/bin/python3" "-m" "testtools.run" "discover" "-s" "${CMAKE_CURRENT_SOURCE_DIR}")
+set_tests_properties(test_libertine
+                     PROPERTIES
+                     ENVIRONMENT
+                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};PYTHONPATH=${CMAKE_SOURCE_DIR}/python")
+
 add_test(test_libertine_container_manager
   "/usr/bin/python3" "-m" "testtools.run" "libertine_container_manager_tests"
 )

=== added file 'tests/unit/test_app_discovery.py'
--- tests/unit/test_app_discovery.py	1970-01-01 00:00:00 +0000
+++ tests/unit/test_app_discovery.py	2015-12-23 02:34:33 +0000
@@ -0,0 +1,52 @@
+"""Unit tests for the AppLauncher module."""
+# 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/>.
+
+from libertine.AppDiscovery import IconCache
+from testtools import TestCase
+from testtools.matchers import Equals
+
+
+class TestIconSearching(TestCase):
+
+    def mock_file_loader(self, root_path):
+        return [
+            "/some/path/128x128/icon.png",
+            "/somepath/icon.png",
+            "/somepath/testme.png"
+            ];
+
+    def test_full_path(self):
+        some_root = "/some_root"
+        icon_cache = IconCache(some_root, file_loader=self.mock_file_loader)
+
+        some_full_path = "/this/is/a/full/path"
+        self.assertThat(icon_cache.expand_icons(some_full_path)[0],
+                        Equals(some_full_path))
+
+    def test_icon_name(self):
+        some_root = "/some_root"
+        icon_cache = IconCache(some_root, file_loader=self.mock_file_loader)
+
+        some_icon_list = "testme"
+        self.assertThat(icon_cache.expand_icons(some_icon_list)[0],
+                        Equals("/somepath/testme.png"))
+
+    def test_edge_case_relative_file_name(self):
+        some_root = "/some_root"
+        icon_cache = IconCache(some_root, file_loader=self.mock_file_loader)
+
+        some_icon_list = "testme.png"
+        self.assertThat(icon_cache.expand_icons(some_icon_list)[0],
+                        Equals("/somepath/testme.png"))

=== added file 'tests/unit/test_libertine_container.py'
--- tests/unit/test_libertine_container.py	1970-01-01 00:00:00 +0000
+++ tests/unit/test_libertine_container.py	2015-12-23 02:34:33 +0000
@@ -0,0 +1,62 @@
+"""Unit tests for the LibertineContainer interface."""
+# 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/>.
+
+from libertine import Libertine
+from testtools import TestCase
+from testtools.matchers import Equals
+import os
+import shutil
+import tempfile
+
+
+class TestLibertineContainer(TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self._working_dir = tempfile.mkdtemp()
+        os.environ['XDG_CACHE_HOME'] = self._working_dir
+        os.environ['XDG_DATA_HOME'] = self._working_dir
+
+    def tearDown(self):
+        shutil.rmtree(self._working_dir)
+        super().tearDown()
+
+    def test_container_id(self):
+        container_id = "test-id-1"
+        container = Libertine.LibertineContainer(container_id)
+
+        self.assertThat(container.container_id, Equals(container_id))
+
+    def test_container_type_default(self):
+        container_id = "test-id-2"
+        container = Libertine.LibertineContainer(container_id)
+
+        self.assertThat(container.container_type, Equals("lxc"))
+
+    def test_container_name_default(self):
+        container_id = "test-id-3"
+        container = Libertine.LibertineContainer(container_id)
+
+        self.assertThat(container.name, Equals("Unknown"))
+
+    def test_container_root_path(self):
+        container_id = "test-id-4"
+        container = Libertine.LibertineContainer(container_id)
+
+        expected_root_path = os.path.join(self._working_dir,
+                                          "libertine-container",
+                                          container_id,
+                                          "rootfs")
+        self.assertThat(container.root_path, Equals(expected_root_path))

=== modified file 'tools/libertine-container-manager'
--- tools/libertine-container-manager	2015-12-17 17:34:24 +0000
+++ tools/libertine-container-manager	2015-12-23 02:34:33 +0000
@@ -322,6 +322,17 @@
         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))
+
+
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description="Legacy X application support for Unity 8")
     parser.add_argument('-q', '--quiet',
@@ -414,6 +425,19 @@
         help=("List all Libertine containers."))
     parser_list.set_defaults(func=list)
 
+    parser_list_apps = subparsers.add_parser(
+        'list-apps',
+        help=("List availsble app launchers in a container."))
+    parser_list_apps.add_argument(
+        '-i', '--id',
+        help=("Container identifier.  Default container is used if omitted."))
+    parser_list_apps.add_argument(
+        '-j', '--json',
+        action='store_true',
+        help=("use JSON output format."))
+    parser_list_apps.set_defaults(func=list_apps)
+
+# Actually parse the args
     args = parser.parse_args()
     if args.verbosity is None:
         args.verbosity = 1