Ubuntu Application Launcher

.bzrignore (+1/-0)
CMakeLists.txt (+3/-0)
application-failed.c (+2/-1)
debian/control (+1/-0)
docs/index.rst (+30/-0)
libubuntu-app-launch/CMakeLists.txt (+12/-0)
libubuntu-app-launch/appid.h (+4/-1)
libubuntu-app-launch/application-impl-legacy.cpp (+13/-0)
libubuntu-app-launch/application-impl-snap.cpp (+459/-0)
libubuntu-app-launch/application-impl-snap.h (+98/-0)
libubuntu-app-launch/application.cpp (+14/-0)
libubuntu-app-launch/registry-impl.h (+9/-0)
libubuntu-app-launch/registry.cpp (+8/-0)
libubuntu-app-launch/snapd-info.cpp (+471/-0)
libubuntu-app-launch/snapd-info.h (+76/-0)
libubuntu-app-launch/ubuntu-app-launch.cpp (+3/-0)
tests/CMakeLists.txt (+18/-0)
tests/exec-util-test.cc (+1/-0)
tests/failure-test.cc (+17/-9)
tests/libual-cpp-test.cc (+199/-1)
tests/libual-test.cc (+2/-0)
tests/list-apps.cpp (+79/-0)
tests/snapd-info-test.cpp (+150/-0)
tests/snapd-mock.h (+384/-0)
upstart-jobs/CMakeLists.txt (+8/-0)
upstart-jobs/application-failed.conf.in (+1/-1)
upstart-jobs/application-logrotate.conf (+1/-0)
upstart-jobs/application-snap.conf.in (+38/-0)

To merge this branch:

bzr merge lp:~ted/ubuntu-app-launch/snappy-backend

Related bugs:

Bug #1590445: Backend for snapd

High

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Charles Kerr (community)		2016-08-04	Approve on 2016-09-08
unity-api-1-bot	continuous-integration		Approve on 2016-09-08
Review via email: mp+302027@code.launchpad.net

This proposal supersedes a proposal from 2016-07-25.

Commit Message

Support launching applications installed as snaps

Description of the Change

Adds a new Application Implementation for Snaps. This also includes the snap-info object which is used to connect to snapd. There are also several adjustments to shared classes to make sure they take the new backend into account.

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-05:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/31/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-13:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/52/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-17:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/58/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-23:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/61/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-24:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/67/rebuild

review: Needs Fixing (continuous-integration)

Charles Kerr (charlesk) wrote on 2016-08-24:

eod reached, review comments part 1 inline

Ted Gould (ted) wrote on 2016-08-25:

Download full text (13.0 KiB)

On Wed, 2016-08-24 at 23:35 +0000, Charles Kerr wrote:
> > gchar * appid = g_strdup(instance);
> > - if (g_strcmp0(job, "application-legacy") == 0) {
> > + if (g_strcmp0(job, "application-legacy") == 0
> > + || g_strcmp0(job, "application-snap") ==
> > 0) {
> > gchar * lasthyphenstanding = g_strrstr(appid, "-
> > ");
> (not-even-part-of-the-MP) why not strrchr()?

The answer is that everything else was g_, so went with g_.

> > +/** Path that snapd puts desktop files, we don't want to read
> > those directly
> > + in the Legacy backend. We want to use the snap backend. */
> > +const std::string snappyDesktopPath{"/var/lib/snapd"};
> This is interesting, I haven't seen this before. Usually when I see a
> file-private variable it's placed inside an unnamed namespace to
> preserve anonymity, eg
>
> namespace
> {
> const std::string snappyDesktopPath{"/var/lib/snapd"};
> }
>
> but this variable here, even though not declared in any header, is
> put here inside an ubuntu::app_launch::app_impls namespace.
>
> Not a blocker, but I'd like to understand this more, what are the
> advantages/disadvantages of placing a private variable in the same
> namespace advertised in application-impl-legacy.h

So I've been trying the other way, trying to get someone to say why
those should be in the anonymous namespace. It seems to me, if it's
related and used by the object it should be in the same namespace as
the object. But I haven't seen any rationale other than "it makes the
symbol name smaller" which seems like a premature optimization at best.

> > + if (std::equal(snappyDesktopPath.begin(),
> > snappyDesktopPath.end(), _basedir.begin()))
> (bikeshed) g_str_has_prefix() would be clearer

Eh, yeah, trying to keep C++ techniques with C++ strings and g_
techniques with gchar strings. I do hate that the C++ string class
doesn't have a "bool prefix(std::string)" on it. And a few other things
that it seems every other string library has. :-/

> > +    /** Return the xMirEnable value based on whether the interface
> > is
> > +        in the list of interfaces using XMir */
> > +    XMirEnable xMirEnable() override
> > +    {
> > +        if (XMIR_INTERFACES.find(interface_) !=
> > XMIR_INTERFACES.end())
> > +        {
> > +            return XMirEnable::from_raw(true);
> I should have called this out in snappy-backend-no-find-discover but
> I don't see what type-tagging a bool accomplishes. How does this
> improve on just using a bool?

Well, I think it is as useful as type-tagging any variable. Just to
keep the type in the code and say when you're using it. But this is
internal, and so that's not as big a reason. I did it here just to make
it feel like the other variables and have the same semantics of usage.

> > +    /** Figures out the exec line for a snappy command. We're not
> > using
> > +        the Exec in the desktop file exactly, but assuming that it
> > is kinda
> > +        what we want to be run. So we're replacing that with the
> > script, which
> > +        we have to use as we can't get the command that is in the
> > snap
> > +        metadata as Snapd won't give it to us. So we're parsing
> > the Exec line
> > +        and replaci...

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-25:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/71/rebuild

review: Needs Fixing (continuous-integration)

Charles Kerr (charlesk) wrote on 2016-08-25:

Some more comments

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-26:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/80/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-26:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/82/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-26:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/85/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-26:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/87/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-26:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/88/rebuild

review: Approve (continuous-integration)

Ted Gould (ted) wrote on 2016-08-26:

On Thu, 2016-08-25 at 21:55 +0000, Charles Kerr wrote:
> > +        /******************************************/
> > +        /* Validation of the object we got        */
> > +        /******************************************/
> > +        for (auto member : {"name", "status", "revision", "type",
> > "version", "apps"})
> auto& :-)

Not sure it helps here since the auto resolves to "const char *" it
would just be copying the pointer. But consistency is good.

r374

> > +        {
> > +            if (!json_object_has_member(snapobject, member))
> > +            {
> > +                throw std::runtime_error("Snap JSON didn't have a
> > '" + std::string(member) + "'");
> > +            }
> > +        }
> > +
> > +        std::string namestr =
> > json_object_get_string_member(snapobject, "name");
> nullptr guard, here and below for 'status', 'type', 'version',
> 'revision', 'name'

r375

> > +static size_t snapd_writefunc(char *ptr, size_t size, size_t
> > nmemb, void *userdata)
> > +{
> > + unsigned int i;
> > + std::vector<char> *data = static_cast<std::vector<char>
> > *>(userdata);
> redundant type info, suggest auto on lhs

r376

> >
> > +    data->reserve(data->size() + (size * nmemb)); /* allocate once
> > */
> > +    for (i = 0; i < size * nmemb; i++)
> > +    {
> > +        data->push_back(ptr[i]);
> > +    }
> I'd replace 1033-1037 with "data->insert(data->end(), ptr,
> ptr+(size*nmemb));"

r377

> > +    if (error != nullptr)
> > +    {
> > +        g_warning("Can not parse! %s", error->message);
> > +        g_error_free(error);
> > +        throw std::runtime_error("Can not parse JSON response");
> marginally better if this contained error->message

r378

> > + std::string statusstr = json_object_get_string_member(rootobj,
> > "status");
> nullptr guard here and "type" below

r379

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-26:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/89/rebuild

review: Approve (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-09-06:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/92/rebuild

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2016-09-08:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/95/rebuild

review: Approve (continuous-integration)

Charles Kerr (charlesk) wrote on 2016-09-08:

Thanks for the fixes!

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Indicator Applet Developers

Ted Gould

 === modified file '.bzrignore'
 --- .bzrignore	2015-12-10 21:01:26 +0000
 +++ .bzrignore	2016-09-13 17:38:18 +0000
@@ -11,3 +11,4 @@
  libubuntu-app-launch/proxy-socket-demangler.c
  libubuntu-app-launch/proxy-socket-demangler.h
  libubuntu-app-launch/ubuntu-app-launch-2.pc
++application-snap.conf
 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2016-08-17 15:24:23 +0000
 +++ CMakeLists.txt	2016-09-13 17:38:18 +0000
@@ -102,6 +102,9 @@
  pkg_check_modules(LIBERTINE libertine)
  include_directories(${LIBERTINE_INCLUDE_DIRS})
++pkg_check_modules(CURL libcurl>=7.47)
++include_directories(${CURL_INCLUDE_DIRS})
++
  include_directories(${CMAKE_CURRENT_SOURCE_DIR})
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
 === modified file 'application-failed.c'
 --- application-failed.c	2014-04-30 19:51:19 +0000
 +++ application-failed.c	2016-09-13 17:38:18 +0000
@@ -35,7 +35,8 @@
+ 	}
  	gchar * appid = g_strdup(instance);
--	if (g_strcmp0(job, "application-legacy") == 0) {
++	if (g_strcmp0(job, "application-legacy") == 0
++			|| g_strcmp0(job, "application-snap") == 0) {
  		gchar * lasthyphenstanding = g_strrstr(appid, "-");
  		if (lasthyphenstanding != NULL) {
  			lasthyphenstanding[0] = '\0';
 === modified file 'debian/control'
 --- debian/control	2016-08-17 15:24:23 +0000
 +++ debian/control	2016-09-13 17:38:18 +0000
@@ -11,6 +11,7 @@
                 debhelper (>= 9),
                 libcgmanager-dev,
                 libclick-0.4-dev,
++               libcurl4-dev | libcurl4-gnutls-dev,
                 libdbus-1-dev,
                 libdbustest1-dev (>= 14.04.0),
                 libgirepository1.0-dev,
 === modified file 'docs/index.rst'
 --- docs/index.rst	2016-09-13 17:38:17 +0000
 +++ docs/index.rst	2016-09-13 17:38:18 +0000
@@ -96,6 +96,16 @@
     :private-members:
     :undoc-members:
++Application Implementation Snappy
++---------------------------------
++
++.. doxygenclass:: ubuntu::app_launch::app_impls::Snap
++   :project: libubuntu-app-launch
++   :members:
++   :protected-members:
++   :private-members:
++   :undoc-members:
++
  Application Info Desktop
  ------------------------
@@ -106,6 +116,16 @@
     :private-members:
     :undoc-members:
++Application Info Snap
++------------------------
++
++.. doxygenclass:: ubuntu::app_launch::app_impls::SnapInfo
++   :project: libubuntu-app-launch
++   :members:
++   :protected-members:
++   :private-members:
++   :undoc-members:
++
  Application Icon Finder
  ------------------------
@@ -136,6 +156,16 @@
     :private-members:
     :undoc-members:
++Snapd Info
++----------
++
++.. doxygenclass:: ubuntu::app_launch::snapd::Info
++   :project: libubuntu-app-launch
++   :members:
++   :protected-members:
++   :private-members:
++   :undoc-members:
++
  Type Tagger
  -----------
 === modified file 'libubuntu-app-launch/CMakeLists.txt'
 --- libubuntu-app-launch/CMakeLists.txt	2016-09-13 17:38:17 +0000
 +++ libubuntu-app-launch/CMakeLists.txt	2016-09-13 17:38:18 +0000
@@ -61,6 +61,16 @@
  app-info.c
+ )
++if(CURL_FOUND)
++add_definitions ( -DENABLE_SNAPPY=1 )
++list(APPEND LAUNCHER_CPP_SOURCES
++application-impl-snap.h
++application-impl-snap.cpp
++snapd-info.h
++snapd-info.cpp
++)
++endif()
++
  add_custom_target(format
  	COMMAND clang-format -i -style=file ${LAUNCHER_CPP_HEADERS} ${LAUNCHER_CPP_SOURCES}
+ )
@@ -83,6 +93,7 @@
  	${ZEITGEIST_LIBRARIES}
  	${MIR_LIBRARIES}
  	${LIBERTINE_LIBRARIES}
++	${CURL_LIBRARIES}
  	-lpthread
  	helpers
  	-Wl,--no-undefined
@@ -109,6 +120,7 @@
  	${ZEITGEIST_LIBRARIES}
  	${MIR_LIBRARIES}
  	${LIBERTINE_LIBRARIES}
++	${CURL_LIBRARIES}
  	-lpthread
  	helpers
  	-Wl,--no-undefined
 === modified file 'libubuntu-app-launch/appid.h'
 --- libubuntu-app-launch/appid.h	2016-09-13 17:38:17 +0000
 +++ libubuntu-app-launch/appid.h	2016-09-13 17:38:18 +0000
@@ -71,7 +71,10 @@
          under the "hooks" key in the JSON manifest. */
      AppName appname;
      /** Version of the package that is installed. This is always resolved when
--        creating the struct. */
++        creating the struct.
++
++        \note For snaps this is actually the 'revision' instead of the version
++              since that is unique where 'version' is not. */
      Version version;
      /** Turn the structure into a string. This is required for many older C based
 === modified file 'libubuntu-app-launch/application-impl-legacy.cpp'
 --- libubuntu-app-launch/application-impl-legacy.cpp	2016-09-13 17:38:17 +0000
 +++ libubuntu-app-launch/application-impl-legacy.cpp	2016-09-13 17:38:18 +0000
@@ -30,8 +30,16 @@
  namespace app_impls
+ {
++/** Path that snapd puts desktop files, we don't want to read those directly
++    in the Legacy backend. We want to use the snap backend. */
++const std::string snappyDesktopPath{"/var/lib/snapd"};
++
++/***********************************
++   Prototypes
++ ***********************************/
  std::tuple<std::string, std::shared_ptr<GKeyFile>, std::string> keyfileForApp(const AppID::AppName& name);
++/** Helper function to put on shared_ptr's for keyfiles */
  void clear_keyfile(GKeyFile* keyfile)
+ {
      if (keyfile != nullptr)
@@ -53,6 +61,11 @@
+     {
          throw std::runtime_error{"Unable to find keyfile for legacy application: " + appname.value()};
+     }
++
++    if (std::equal(snappyDesktopPath.begin(), snappyDesktopPath.end(), _basedir.begin()))
++    {
++        throw std::runtime_error{"Looking like a legacy app, but should be a Snap: " + appname.value()};
++    }
+ }
  std::tuple<std::string, std::shared_ptr<GKeyFile>, std::string> keyfileForApp(const AppID::AppName& name)
 === added file 'libubuntu-app-launch/application-impl-snap.cpp'
 --- libubuntu-app-launch/application-impl-snap.cpp	1970-01-01 00:00:00 +0000
 +++ libubuntu-app-launch/application-impl-snap.cpp	2016-09-13 17:38:18 +0000
@@ -0,0 +1,459 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#include <regex>
++
++#include "application-impl-snap.h"
++#include "application-info-desktop.h"
++#include "registry-impl.h"
++
++namespace ubuntu
++{
++namespace app_launch
++{
++namespace app_impls
++{
++
++/************************
++ ** Interface Lists
++ ************************/
++
++/** All the interfaces that we support running applications with */
++const std::set<std::string> SUPPORTED_INTERFACES{"unity8", "unity7", "x11"};
++/** All the interfaces that we run XMir for by default */
++const std::set<std::string> XMIR_INTERFACES{"unity7", "x11"};
++/** All the interfaces that we tell Unity support lifecycle */
++const std::set<std::string> LIFECYCLE_INTERFACES{"unity8"};
++/** Snappy has more restrictive appnames than everyone else */
++const std::regex appnameRegex{"^[a-zA-Z0-9](?:-?[a-zA-Z0-9])*$"};
++
++/************************
++ ** Info support
++ ************************/
++
++/** Subclassing the desktop info object so that we can override a couple
++    of properties with interface definitions. This may grow as we add more
++    fields to the desktop spec that come from Snappy interfaces. */
++class SnapInfo : public app_info::Desktop
++{
++    /** The core interface for this snap */
++    std::string interface_;
++    /** AppID of snap */
++    AppID appId_;
++
++public:
++    SnapInfo(const AppID& appid,
++             const std::shared_ptr<Registry>& registry,
++             const std::string& interface,
++             const std::string& snapDir)
++        : Desktop(
++              [appid, snapDir]() -> std::shared_ptr<GKeyFile> {
++                  /* This is a function to get the keyfile out of the snap using
++                     the paths that snappy places things inside the dir. */
++                  std::string path = snapDir + "/meta/gui/" + appid.appname.value() + ".desktop";
++                  std::shared_ptr<GKeyFile> keyfile(g_key_file_new(), g_key_file_free);
++                  GError* error = nullptr;
++                  g_key_file_load_from_file(keyfile.get(), path.c_str(), G_KEY_FILE_NONE, &error);
++                  if (error != nullptr)
++                  {
++                      auto perror = std::shared_ptr<GError>(error, g_error_free);
++                      throw std::runtime_error("Unable to find keyfile for '" + std::string(appid) + "' at '" + path +
++                                               "' because: " + perror.get()->message);
++                  }
++
++                  return keyfile;
++              }(),
++              snapDir,
++              app_info::DesktopFlags::NONE,
++              registry)
++        , interface_(interface)
++        , appId_(appid)
++    {
++    }
++
++    /** Return the xMirEnable value based on whether the interface is
++        in the list of interfaces using XMir */
++    XMirEnable xMirEnable() override
++    {
++        if (XMIR_INTERFACES.find(interface_) != XMIR_INTERFACES.end())
++        {
++            return XMirEnable::from_raw(true);
++        }
++        else
++        {
++            return XMirEnable::from_raw(false);
++        }
++    }
++
++    /** Return the xMirEnable value based on whether the interface is
++        in the list of interfaces supporting the lifecycle */
++    UbuntuLifecycle supportsUbuntuLifecycle() override
++    {
++        if (LIFECYCLE_INTERFACES.find(interface_) != LIFECYCLE_INTERFACES.end())
++        {
++            return UbuntuLifecycle::from_raw(true);
++        }
++        else
++        {
++            return UbuntuLifecycle::from_raw(false);
++        }
++    }
++
++    /** Figures out the exec line for a snappy command. We're not using
++        the Exec in the desktop file exactly, but assuming that it is kinda
++        what we want to be run. So we're replacing that with the script, which
++        we have to use as we can't get the command that is in the snap
++        metadata as Snapd won't give it to us. So we're parsing the Exec line
++        and replacing the first entry. Then putting it back together again. */
++    Exec execLine() override
++    {
++        std::string keyfile = _exec.value();
++        gchar** parsed = nullptr;
++        GError* error = nullptr;
++
++        g_shell_parse_argv(keyfile.c_str(), nullptr, &parsed, &error);
++
++        if (error != nullptr)
++        {
++            g_warning("Unable to parse exec line '%s': %s", keyfile.c_str(), error->message);
++            g_error_free(error);
++            return Exec::from_raw({});
++        }
++
++        if (g_strv_length(parsed) == 0)
++        {
++            g_warning("Parse resulted in a blank line");
++            g_strfreev(parsed);
++            return Exec::from_raw({});
++        }
++
++        /* Skip the first entry */
++        gchar** parsedpp = &(parsed[1]);
++
++        gchar* params = g_strjoinv(" ", parsedpp);
++        g_strfreev(parsed);
++
++        std::string binname;
++        if (appId_.package.value() == appId_.appname.value())
++        {
++            binname = appId_.package.value();
++        }
++        else
++        {
++            binname = appId_.package.value() + " " + appId_.appname.value();
++        }
++
++        binname = "/snap/bin/" + binname + " " + params;
++        g_free(params);
++
++        return Exec::from_raw(binname);
++    }
++};
++
++/************************
++ ** Snap implementation
++ ************************/
++
++/** Creates a Snap application object. Will throw exceptions if the AppID
++    doesn't resolve into a valid package or that package doesn't have a desktop
++    file that matches the app name.
++
++    \param appid Application ID of the snap
++    \param registry Registry to use for persistent connections
++    \param interface Primary interface that we found this snap for
++*/
++Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const std::string& interface)
++    : Base(registry)
++    , appid_(appid)
++    , interface_(interface)
++{
++    pkgInfo_ = registry->impl->snapdInfo.pkgInfo(appid.package);
++    if (!pkgInfo_)
++    {
++        throw std::runtime_error("Unable to get snap package info for AppID: " + std::string(appid));
++    }
++
++    if (!checkPkgInfo(pkgInfo_, appid_))
++    {
++        throw std::runtime_error("AppID does not match installed package for: " + std::string(appid));
++    }
++
++    info_ = std::make_shared<SnapInfo>(appid_, _registry, interface_, pkgInfo_->directory);
++}
++
++/** Uses the findInterface() function to find the interface if we don't
++    have one.
++
++    \param appid Application ID of the snap
++    \param registry Registry to use for persistent connections
++*/
++Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry)
++    : Snap(appid, registry, findInterface(appid, registry))
++{
++}
++
++/** Lists all the Snappy apps that are using one of our supported interfaces.
++    Also makes sure they're valid.
++
++    \param registry Registry to use for persistent connections
++*/
++std::list<std::shared_ptr<Application>> Snap::list(const std::shared_ptr<Registry>& registry)
++{
++    std::list<std::shared_ptr<Application>> apps;
++
++    for (const auto& interface : SUPPORTED_INTERFACES)
++    {
++        for (const auto& id : registry->impl->snapdInfo.appsForInterface(interface))
++        {
++            try
++            {
++                auto app = std::make_shared<Snap>(id, registry, interface);
++                apps.emplace_back(app);
++            }
++            catch (std::runtime_error& e)
++            {
++                g_warning("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
++            }
++        }
++    }
++
++    return apps;
++}
++
++/** Returns the stored AppID */
++AppID Snap::appId()
++{
++    return appid_;
++}
++
++/** Asks Snapd for the interfaces to determine which one the application
++    can support.
++
++    \param appid Application ID of the snap
++    \param registry Registry to use for persistent connections
++*/
++std::string Snap::findInterface(const AppID& appid, const std::shared_ptr<Registry>& registry)
++{
++    auto ifaceset = registry->impl->snapdInfo.interfacesForAppId(appid);
++
++    for (const auto& interface : SUPPORTED_INTERFACES)
++    {
++        if (ifaceset.find(interface) != ifaceset.end())
++        {
++            return interface;
++        }
++    }
++
++    throw std::runtime_error("Interface not found for: " + std::string(appid));
++}
++
++/** Checks a PkgInfo structure to ensure that it matches the AppID */
++bool Snap::checkPkgInfo(const std::shared_ptr<snapd::Info::PkgInfo>& pkginfo, const AppID& appid)
++{
++    if (!pkginfo)
++    {
++        return false;
++    }
++
++    return pkginfo->revision == appid.version.value() &&
++           pkginfo->appnames.find(appid.appname) != pkginfo->appnames.end();
++}
++
++/** Checks if an AppID could be a snap. Note it doesn't look for a desktop
++    file just the package, app and version. This is done to make the lookup
++    quickly, as this function can be used to select which backend to use
++    and we want to reject quickly.
++
++    \param appid Application ID of the snap
++    \param registry Registry to use for persistent connections
++*/
++bool Snap::hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry)
++{
++    if (!std::regex_match(appId.appname.value(), appnameRegex))
++    {
++        return false;
++    }
++
++    auto pkginfo = registry->impl->snapdInfo.pkgInfo(appId.package);
++    return checkPkgInfo(pkginfo, appId);
++}
++
++/** Look to see if a package is a valid Snap package name
++
++    \param package Package name
++    \param registry Registry to use for persistent connections
++*/
++bool Snap::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
++{
++    try
++    {
++        auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
++        return pkgInfo != nullptr;
++    }
++    catch (std::runtime_error& e)
++    {
++        return false;
++    }
++}
++
++/** Look to see if an appname is a valid for a Snap package
++
++    \param package Package name
++    \param appname Command name
++    \param registry Registry to use for persistent connections
++*/
++bool Snap::verifyAppname(const AppID::Package& package,
++                         const AppID::AppName& appname,
++                         const std::shared_ptr<Registry>& registry)
++{
++    if (!std::regex_match(appname.value(), appnameRegex))
++    {
++        return false;
++    }
++
++    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
++    return pkgInfo->appnames.find(appname) != pkgInfo->appnames.end();
++}
++
++/** Look for an application name on a Snap package based on a
++    wildcard type.
++
++    \param package Package name
++    \param card Wildcard to use for finding the appname
++    \param registry Registry to use for persistent connections
++*/
++AppID::AppName Snap::findAppname(const AppID::Package& package,
++                                 AppID::ApplicationWildcard card,
++                                 const std::shared_ptr<Registry>& registry)
++{
++    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
++
++    if (pkgInfo->appnames.empty())
++    {
++        throw std::runtime_error("No apps in package '" + package.value() + "' to find");
++    }
++
++    switch (card)
++    {
++        case AppID::ApplicationWildcard::FIRST_LISTED:
++            return AppID::AppName::from_raw(*pkgInfo->appnames.begin());
++        case AppID::ApplicationWildcard::LAST_LISTED:
++            return AppID::AppName::from_raw(*pkgInfo->appnames.rbegin());
++        case AppID::ApplicationWildcard::ONLY_LISTED:
++            if (pkgInfo->appnames.size() != 1)
++            {
++                throw std::runtime_error("More than a single app in package '" + package.value() +
++                                         "' when requested to find only app");
++            }
++            return AppID::AppName::from_raw(*pkgInfo->appnames.begin());
++    }
++
++    throw std::logic_error("Got a value of the app wildcard enum that can't exist");
++}
++
++/** Look for a version of a Snap package
++
++    \param package Package name
++    \param appname Not used for snaps
++    \param registry Registry to use for persistent connections
++*/
++AppID::Version Snap::findVersion(const AppID::Package& package,
++                                 const AppID::AppName& appname,
++                                 const std::shared_ptr<Registry>& registry)
++{
++    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
++    return AppID::Version::from_raw(pkgInfo->revision);
++}
++
++/** Returns a reference to the info for the snap */
++std::shared_ptr<Application::Info> Snap::info()
++{
++    return info_;
++}
++
++/** Get all of the instances of this snap package that are running */
++std::vector<std::shared_ptr<Application::Instance>> Snap::instances()
++{
++    std::vector<std::shared_ptr<Instance>> vect;
++    auto startsWith = std::string(appid_) + "-";
++
++    for (const auto& instance : _registry->impl->upstartInstancesForJob("application-snap"))
++    {
++        if (std::equal(startsWith.begin(), startsWith.end(), instance.begin()))
++        {
++            vect.emplace_back(std::make_shared<UpstartInstance>(appid_, "application-snap", instance,
++                                                                std::vector<Application::URL>{}, _registry));
++        }
++    }
++
++    return vect;
++}
++
++/** Return the launch environment for this snap. That includes whether
++    or not it needs help from XMir (including Libertine helpers)
++*/
++std::list<std::pair<std::string, std::string>> Snap::launchEnv()
++{
++    g_debug("Getting snap specific environment");
++    std::list<std::pair<std::string, std::string>> retval;
++
++    retval.emplace_back(std::make_pair("APP_XMIR_ENABLE", info_->xMirEnable().value() ? "1" : "0"));
++    if (info_->xMirEnable())
++    {
++        /* If we're setting up XMir we also need the other helpers
++           that libertine is helping with */
++        /* retval.emplace_back(std::make_pair("APP_EXEC", "libertine-launch --no-container " +
++         * info_->execLine().value())); */
++        /* Not yet */
++        retval.emplace_back(std::make_pair("APP_EXEC", info_->execLine().value()));
++    }
++    else
++    {
++        retval.emplace_back(std::make_pair("APP_EXEC", info_->execLine().value()));
++    }
++
++    return retval;
++}
++
++/** Create a new instance of this Snap
++
++    \param urls URLs to pass to the command
++*/
++std::shared_ptr<Application::Instance> Snap::launch(const std::vector<Application::URL>& urls)
++{
++    std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
++    return UpstartInstance::launch(appid_, "application-snap", std::string(appid_) + "-", urls, _registry,
++                                   UpstartInstance::launchMode::STANDARD, envfunc);
++}
++
++/** Create a new instance of this Snap with a testing environment
++    setup for it.
++
++    \param urls URLs to pass to the command
++*/
++std::shared_ptr<Application::Instance> Snap::launchTest(const std::vector<Application::URL>& urls)
++{
++    std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
++    return UpstartInstance::launch(appid_, "application-snap", std::string(appid_) + "-", urls, _registry,
++                                   UpstartInstance::launchMode::TEST, envfunc);
++}
++
++}  // namespace app_impls
++}  // namespace app_launch
++}  // namespace ubuntu
 === added file 'libubuntu-app-launch/application-impl-snap.h'
 --- libubuntu-app-launch/application-impl-snap.h	1970-01-01 00:00:00 +0000
 +++ libubuntu-app-launch/application-impl-snap.h	2016-09-13 17:38:18 +0000
@@ -0,0 +1,98 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#include "application-impl-base.h"
++#include "application-info-desktop.h"
++#include "snapd-info.h"
++
++#pragma once
++
++namespace ubuntu
++{
++namespace app_launch
++{
++namespace app_impls
++{
++
++/** Class implementing a Applications that are installed in the
++    system as Snaps. This class connects to snapd to get information
++    on the interfaces of the installed snaps and sees if any of them
++    are applicable to the user session. Currently that means if the
++    command has the unity8, unity7 or x11 interface.
++
++    For Application IDs snaps use a very similar scheme to Click
++    packages. The package field is the name of the snap package, typically
++    this is the overall application name. The appname is the command
++    in the snap package, which needs to be associated with one of our
++    supported interfaces and have a desktop file. Lastly the version
++    field is actually the snap revision, this value changes even on
++    updates between channels of the same version so it provides a
++    greater amount of uniqueness.
++*/
++class Snap : public Base
++{
++public:
++    Snap(const AppID& appid, const std::shared_ptr<Registry>& registry);
++    Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const std::string& interface);
++
++    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry);
++
++    AppID appId() override;
++
++    std::shared_ptr<Info> info() override;
++
++    std::vector<std::shared_ptr<Instance>> instances() override;
++
++    std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override;
++    std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override;
++
++    static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry);
++
++    static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry);
++    static bool verifyAppname(const AppID::Package& package,
++                              const AppID::AppName& appname,
++                              const std::shared_ptr<Registry>& registry);
++    static AppID::AppName findAppname(const AppID::Package& package,
++                                      AppID::ApplicationWildcard card,
++                                      const std::shared_ptr<Registry>& registry);
++    static AppID::Version findVersion(const AppID::Package& package,
++                                      const AppID::AppName& appname,
++                                      const std::shared_ptr<Registry>& registry);
++
++private:
++    /** AppID of the Snap. Should be the name of the snap package.
++        The name of the command. And then the revision. */
++    AppID appid_;
++    /** The app's displayed information. Should be from a desktop
++        file that is put in ${SNAP_DIR}/meta/gui/${command}.desktop */
++    std::shared_ptr<app_info::Desktop> info_;
++    /** Which interface we thing we're coming from. Depends on how
++        we handle setting up the environment for the command. */
++    std::string interface_;
++    /** Information that we get from Snapd on the package */
++    std::shared_ptr<snapd::Info::PkgInfo> pkgInfo_;
++
++    std::list<std::pair<std::string, std::string>> launchEnv();
++    static std::string findInterface(const AppID& appid, const std::shared_ptr<Registry>& registry);
++    static bool checkPkgInfo(const std::shared_ptr<snapd::Info::PkgInfo>& pkginfo, const AppID& appid);
++};
++
++}  // namespace app_impls
++}  // namespace app_launch
++}  // namespace ubuntu
 === modified file 'libubuntu-app-launch/application.cpp'
 --- libubuntu-app-launch/application.cpp	2016-09-13 17:38:17 +0000
 +++ libubuntu-app-launch/application.cpp	2016-09-13 17:38:18 +0000
@@ -24,6 +24,9 @@
  #include "application-impl-click.h"
  #include "application-impl-legacy.h"
  #include "application-impl-libertine.h"
++#ifdef ENABLE_SNAPPY
++#include "application-impl-snap.h"
++#endif
  #include "application.h"
  #include "registry.h"
@@ -47,6 +50,12 @@
+     {
          return std::make_shared<app_impls::Click>(appid, registry);
+     }
++#ifdef ENABLE_SNAPPY
++    else if (app_impls::Snap::hasAppId(appid, registry))
++    {
++        return std::make_shared<app_impls::Snap>(appid, registry);
++    }
++#endif
      else if (app_impls::Libertine::hasAppId(appid, registry))
+     {
          return std::make_shared<app_impls::Libertine>(appid.package, appid.appname, registry);
@@ -197,6 +206,11 @@
      /* Click */
      {app_impls::Click::verifyPackage, app_impls::Click::verifyAppname, app_impls::Click::findAppname,
       app_impls::Click::findVersion, app_impls::Click::hasAppId},
++#ifdef ENABLE_SNAPPY
++    /* Snap */
++    {app_impls::Snap::verifyPackage, app_impls::Snap::verifyAppname, app_impls::Snap::findAppname,
++     app_impls::Snap::findVersion, app_impls::Snap::hasAppId},
++#endif
      /* Libertine */
      {app_impls::Libertine::verifyPackage, app_impls::Libertine::verifyAppname, app_impls::Libertine::findAppname,
       app_impls::Libertine::findVersion, app_impls::Libertine::hasAppId},
 === modified file 'libubuntu-app-launch/registry-impl.h'
 --- libubuntu-app-launch/registry-impl.h	2016-09-13 17:38:17 +0000
 +++ libubuntu-app-launch/registry-impl.h	2016-09-13 17:38:18 +0000
@@ -19,6 +19,7 @@
  #include "glib-thread.h"
  #include "registry.h"
++#include "snapd-info.h"
  #include <click.h>
  #include <gio/gio.h>
  #include <json-glib/json-glib.h>
@@ -57,9 +58,17 @@
      void clearManager ();
  #endif
++    /** Shared context thread for events and background tasks
++        that UAL subtasks are doing */
      GLib::ContextThread thread;
++    /** DBus shared connection for the session bus */
      std::shared_ptr<GDBusConnection> _dbus;
++#ifdef ENABLE_SNAPPY
++    /** Snapd information object */
++    snapd::Info snapdInfo;
++#endif
++
      std::shared_ptr<IconFinder> getIconFinder(std::string basePath);
      void zgSendEvent(AppID appid, const std::string& eventtype);
 === modified file 'libubuntu-app-launch/registry.cpp'
 --- libubuntu-app-launch/registry.cpp	2016-09-13 17:38:17 +0000
 +++ libubuntu-app-launch/registry.cpp	2016-09-13 17:38:18 +0000
@@ -27,6 +27,9 @@
  #include "application-impl-click.h"
  #include "application-impl-legacy.h"
  #include "application-impl-libertine.h"
++#ifdef ENABLE_SNAPPY
++#include "application-impl-snap.h"
++#endif
  #include "helper-impl-click.h"
@@ -50,6 +53,8 @@
      /* Get all the legacy instances */
      instances.splice(instances.begin(), connection->impl->upstartInstancesForJob("application-legacy"));
++    /* Get all the snap instances */
++    instances.splice(instances.begin(), connection->impl->upstartInstancesForJob("application-snap"));
      /* Remove the instance ID */
      std::transform(instances.begin(), instances.end(), instances.begin(), [](std::string &instancename) -> std::string {
@@ -106,6 +111,9 @@
      list.splice(list.begin(), app_impls::Click::list(connection));
      list.splice(list.begin(), app_impls::Legacy::list(connection));
      list.splice(list.begin(), app_impls::Libertine::list(connection));
++#ifdef ENABLE_SNAPPY
++    list.splice(list.begin(), app_impls::Snap::list(connection));
++#endif
      return list;
+ }
 === added file 'libubuntu-app-launch/snapd-info.cpp'
 --- libubuntu-app-launch/snapd-info.cpp	1970-01-01 00:00:00 +0000
 +++ libubuntu-app-launch/snapd-info.cpp	2016-09-13 17:38:18 +0000
@@ -0,0 +1,471 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#include "snapd-info.h"
++
++#include "registry-impl.h"
++
++#include <curl/curl.h>
++#include <vector>
++
++namespace ubuntu
++{
++namespace app_launch
++{
++namespace snapd
++{
++
++/** Initializes the info object which mostly means checking what is overridden
++    by environment variables (mostly for testing) and making sure there is a
++    snapd socket available to us. */
++Info::Info()
++{
++    auto snapdEnv = g_getenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET");
++    if (G_UNLIKELY(snapdEnv != nullptr))
++    {
++        snapdSocket = snapdEnv;
++    }
++    else
++    {
++        snapdSocket = "/run/snapd.socket";
++    }
++
++    auto snapcBasedir = g_getenv("UBUNTU_APP_LAUNCH_SNAP_BASEDIR");
++    if (G_UNLIKELY(snapcBasedir != nullptr))
++    {
++        snapBasedir = snapcBasedir;
++    }
++    else
++    {
++        snapBasedir = "/snap";
++    }
++
++    if (g_file_test(snapdSocket.c_str(), G_FILE_TEST_EXISTS))
++    {
++        snapdExists = true;
++    }
++}
++
++/** Gets package information out of snapd by using the REST
++    interface and turning the JSON object into a C++ Struct
++
++    \param package Name of the package to look for
++*/
++std::shared_ptr<Info::PkgInfo> Info::pkgInfo(const AppID::Package &package) const
++{
++    if (!snapdExists)
++    {
++        return {};
++    }
++
++    try
++    {
++        auto snapnode = snapdJson("/v2/snaps/" + package.value());
++        auto snapobject = json_node_get_object(snapnode.get());
++        if (snapobject == nullptr)
++        {
++            throw std::runtime_error("Results returned by snapd were not a valid JSON object");
++        }
++
++        /******************************************/
++        /* Validation of the object we got        */
++        /******************************************/
++        for (const auto &member : {"apps"})
++        {
++            if (!json_object_has_member(snapobject, member))
++            {
++                throw std::runtime_error("Snap JSON didn't have a '" + std::string(member) + "'");
++            }
++        }
++
++        for (const auto &member : {"name", "status", "revision", "type", "version"})
++        {
++            if (!json_object_has_member(snapobject, member))
++            {
++                throw std::runtime_error("Snap JSON didn't have a '" + std::string(member) + "'");
++            }
++
++            auto node = json_object_get_member(snapobject, member);
++            if (json_node_get_node_type(node) != JSON_NODE_VALUE)
++            {
++                throw std::runtime_error{"Snap JSON had a '" + std::string(member) + "' but it's an object!"};
++            }
++
++            if (json_node_get_value_type(node) != G_TYPE_STRING)
++            {
++                throw std::runtime_error{"Snap JSON had a '" + std::string(member) + "' but it's not a string!"};
++            }
++        }
++
++        std::string namestr = json_object_get_string_member(snapobject, "name");
++        if (namestr != package.value())
++        {
++            throw std::runtime_error("Snapd returned information for snap '" + namestr + "' when we asked for '" +
++                                     package.value() + "'");
++        }
++
++        std::string statusstr = json_object_get_string_member(snapobject, "status");
++        if (statusstr != "active")
++        {
++            throw std::runtime_error("Snap is not in the 'active' state.");
++        }
++
++        std::string typestr = json_object_get_string_member(snapobject, "type");
++        if (typestr != "app")
++        {
++            throw std::runtime_error("Specified snap is not an application, we only support applications");
++        }
++
++        /******************************************/
++        /* Validation complete — build the object */
++        /******************************************/
++
++        auto pkgstruct = std::make_shared<PkgInfo>();
++        pkgstruct->name = namestr;
++        pkgstruct->version = json_object_get_string_member(snapobject, "version");
++        std::string revisionstr = json_object_get_string_member(snapobject, "revision");
++        pkgstruct->revision = revisionstr;
++
++        /* TODO: Seems like snapd should give this to us */
++        auto gdir = g_build_filename(snapBasedir.c_str(), namestr.c_str(), revisionstr.c_str(), nullptr);
++        pkgstruct->directory = gdir;
++        g_free(gdir);
++
++        auto appsarray = json_object_get_array_member(snapobject, "apps");
++        for (unsigned int i = 0; i < json_array_get_length(appsarray); i++)
++        {
++            auto appobj = json_array_get_object_element(appsarray, i);
++            if (json_object_has_member(appobj, "name"))
++            {
++                auto appname = json_object_get_string_member(appobj, "name");
++                if (appname)
++                {
++                    pkgstruct->appnames.insert(appname);
++                }
++            }
++        }
++
++        return pkgstruct;
++    }
++    catch (std::runtime_error &e)
++    {
++        g_warning("Unable to get snap information for '%s': %s", package.value().c_str(), e.what());
++        return {};
++    }
++}
++
++/** Function that acts as the return from cURL to add data to
++    our storage vector.
++
++    \param ptr incoming data
++    \param size block size
++    \param nmemb number of blocks
++    \param userdata our local vector to store things in
++*/
++static size_t snapd_writefunc(char *ptr, size_t size, size_t nmemb, void *userdata)
++{
++    auto data = static_cast<std::vector<char> *>(userdata);
++    data->insert(data->end(), ptr, ptr + (size * nmemb));
++    return size * nmemb;
++}
++
++/** Asks the snapd process for some JSON. This function parses the basic
++    response JSON that snapd returns and will error if a return code error
++    is in the JSON. It then passes on the "result" part of the response
++    to the caller.
++
++    \param endpoint End of the URL to pass to snapd
++*/
++std::shared_ptr<JsonNode> Info::snapdJson(const std::string &endpoint) const
++{
++    /* Setup the CURL connection and suck some data */
++    CURL *curl = curl_easy_init();
++    if (curl == nullptr)
++    {
++        throw std::runtime_error("Unable to create new cURL connection");
++    }
++
++    std::vector<char> data;
++
++    /* Configure the command */
++    // curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
++    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
++    curl_easy_setopt(curl, CURLOPT_URL, ("http://snapd" + endpoint).c_str());
++    curl_easy_setopt(curl, CURLOPT_UNIX_SOCKET_PATH, snapdSocket.c_str());
++    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
++    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, snapd_writefunc);
++
++    /* Overridable timeout */
++    if (g_getenv("UBUNTU_APP_LAUNCH_DISABLE_SNAPD_TIMEOUT") != nullptr)
++    {
++        curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 100L);
++    }
++
++    /* Run the actual request (blocking) */
++    auto res = curl_easy_perform(curl);
++
++    if (res != CURLE_OK)
++    {
++        curl_easy_cleanup(curl);
++        throw std::runtime_error("snapd HTTP server returned an error: " + std::string(curl_easy_strerror(res)));
++    }
++    else
++    {
++        g_debug("Got %d bytes from snapd", int(data.size()));
++    }
++
++    curl_easy_cleanup(curl);
++
++    /* Cool, we have data */
++    auto parser = std::shared_ptr<JsonParser>(json_parser_new(), [](JsonParser *parser) { g_clear_object(&parser); });
++    GError *error = nullptr;
++    json_parser_load_from_data(parser.get(), /* parser */
++                               data.data(),  /* array */
++                               data.size(),  /* size */
++                               &error);      /* error */
++
++    if (error != nullptr)
++    {
++        std::string message{"Can not parse JSON: " + std::string(error->message)};
++        g_error_free(error);
++        throw std::runtime_error{message};
++    }
++
++    auto root = json_parser_get_root(parser.get());
++    auto rootobj = json_node_get_object(root);
++
++    if (rootobj == nullptr)
++    {
++        throw std::runtime_error("Root of JSON result isn't an object");
++    }
++
++    /* Check members */
++    for (const auto &member : {"status-code", "result"})
++    {
++        if (!json_object_has_member(rootobj, member))
++        {
++            throw std::runtime_error("Resulting JSON didn't have a '" + std::string(member) + "'");
++        }
++    }
++
++    for (const auto &member : {"status", "type"})
++    {
++        if (!json_object_has_member(rootobj, member))
++        {
++            throw std::runtime_error("Snap JSON didn't have a '" + std::string(member) + "'");
++        }
++
++        auto node = json_object_get_member(rootobj, member);
++        if (json_node_get_node_type(node) != JSON_NODE_VALUE)
++        {
++            throw std::runtime_error{"Snap JSON had a '" + std::string(member) + "' but it's an object!"};
++        }
++
++        if (json_node_get_value_type(node) != G_TYPE_STRING)
++        {
++            throw std::runtime_error{"Snap JSON had a '" + std::string(member) + "' but it's not a string!"};
++        }
++    }
++
++    auto status = json_object_get_int_member(rootobj, "status-code");
++    if (status != 200)
++    {
++        throw std::runtime_error("Status code is: " + std::to_string(status));
++    }
++
++    std::string statusstr = json_object_get_string_member(rootobj, "status");
++    if (statusstr != "OK")
++    {
++        throw std::runtime_error("Status string is: " + statusstr);
++    }
++
++    std::string typestr = json_object_get_string_member(rootobj, "type");
++    if (typestr != "sync")
++    {
++        throw std::runtime_error("We only support 'sync' results right now, but we got a: " + typestr);
++    }
++
++    auto result = std::shared_ptr<JsonNode>(json_node_ref(json_object_get_member(rootobj, "result")), json_node_unref);
++
++    return result;
++}
++
++/** Looks through all the plugs in the interfaces and runs a function
++    based on them. Avoids pulling objects out of the parsed JSON structure
++    from Snappy and making sure they have the same lifecycle as the parser
++    object which seems to destroy them when it dies.
++
++    \param plugfunc Function to execute on each plug
++*/
++void Info::forAllPlugs(std::function<void(JsonObject *plugobj)> plugfunc) const
++{
++    if (!snapdExists)
++    {
++        return;
++    }
++
++    auto interfacesnode = snapdJson("/v2/interfaces");
++    auto interface = json_node_get_object(interfacesnode.get());
++    if (interface == nullptr)
++    {
++        throw std::runtime_error("Interfaces result isn't an object: " + Registry::Impl::printJson(interfacesnode));
++    }
++
++    for (const auto &member : {"plugs", "slots"})
++    {
++        if (!json_object_has_member(interface, member))
++        {
++            throw std::runtime_error("Interface JSON didn't have a '" + std::string(member) + "'");
++        }
++    }
++
++    auto plugarray = json_object_get_array_member(interface, "plugs");
++    for (unsigned int i = 0; i < json_array_get_length(plugarray); i++)
++    {
++        auto ifaceobj = json_array_get_object_element(plugarray, i);
++        try
++        {
++            for (const auto &member : {"snap", "interface", "apps"})
++            {
++                if (!json_object_has_member(ifaceobj, member))
++                {
++                    throw std::runtime_error("Interface JSON didn't have a '" + std::string(member) + "'");
++                }
++            }
++
++            plugfunc(ifaceobj);
++        }
++        catch (std::runtime_error &e)
++        {
++            /* We'll check the others even if one is bad */
++            // g_debug("Malformed inteface instance: %s", e.what());
++            continue;
++        }
++    }
++}
++
++/** Gets all the apps that are available for a given interface. It asks snapd
++    for the list of interfaces and then finds this one, turning it into a set
++    of AppIDs
++
++    \param in_interface Which interface to get the set of apps for
++*/
++std::set<AppID> Info::appsForInterface(const std::string &in_interface) const
++{
++    bool interfacefound = false;
++    std::set<AppID> appids;
++
++    try
++    {
++        forAllPlugs([this, &interfacefound, &appids, in_interface](JsonObject *ifaceobj) {
++            std::string interfacename = json_object_get_string_member(ifaceobj, "interface");
++            if (interfacename != in_interface)
++            {
++                return;
++            }
++
++            interfacefound = true;
++
++            auto cname = json_object_get_string_member(ifaceobj, "snap");
++            if (cname == nullptr)
++            {
++                return;
++            }
++            std::string snapname(cname);
++
++            auto pkginfo = pkgInfo(AppID::Package::from_raw(snapname));
++            if (!pkginfo)
++            {
++                return;
++            }
++
++            std::string revision = pkginfo->revision;
++
++            auto apps = json_object_get_array_member(ifaceobj, "apps");
++            for (unsigned int k = 0; k < json_array_get_length(apps); k++)
++            {
++                std::string appname = json_array_get_string_element(apps, k);
++
++                appids.emplace(AppID(AppID::Package::from_raw(snapname),   /* package */
++                                     AppID::AppName::from_raw(appname),    /* appname */
++                                     AppID::Version::from_raw(revision))); /* version */
++            }
++        });
++
++        if (!interfacefound)
++        {
++            g_debug("Unable to find information on interface '%s'", in_interface.c_str());
++        }
++    }
++    catch (std::runtime_error &e)
++    {
++        g_warning("Unable to get interface information: %s", e.what());
++    }
++
++    return appids;
++}
++
++/** Finds all the interfaces for a specific appid
++
++    \param appid AppID to search for
++*/
++std::set<std::string> Info::interfacesForAppId(const AppID &appid) const
++{
++
++    std::set<std::string> interfaces;
++
++    try
++    {
++        forAllPlugs([&interfaces, appid](JsonObject *ifaceobj) {
++            auto snapname = json_object_get_string_member(ifaceobj, "snap");
++            if (snapname != appid.package.value())
++            {
++                return;
++            }
++
++            auto cinterfacename = json_object_get_string_member(ifaceobj, "interface");
++            if (cinterfacename == nullptr)
++            {
++                return;
++            }
++
++            std::string interfacename(cinterfacename);
++
++            auto apps = json_object_get_array_member(ifaceobj, "apps");
++            for (unsigned int k = 0; k < json_array_get_length(apps); k++)
++            {
++                std::string appname = json_array_get_string_element(apps, k);
++                if (appname == appid.appname.value())
++                {
++                    interfaces.insert(interfacename);
++                }
++            }
++        });
++    }
++    catch (std::runtime_error &e)
++    {
++        g_warning("Unable to get interface information: %s", e.what());
++    }
++
++    return interfaces;
++}
++
++}  // namespace snapd
++}  // namespace app_launch
++}  // namespace ubuntu
 === added file 'libubuntu-app-launch/snapd-info.h'
 --- libubuntu-app-launch/snapd-info.h	1970-01-01 00:00:00 +0000
 +++ libubuntu-app-launch/snapd-info.h	2016-09-13 17:38:18 +0000
@@ -0,0 +1,76 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#pragma once
++
++#include <list>
++#include <memory>
++#include <set>
++
++#include <json-glib/json-glib.h>
++
++#include "appid.h"
++
++namespace ubuntu
++{
++namespace app_launch
++{
++namespace snapd
++{
++
++/** Class that implements the connection to Snapd allowing us to get info
++    from it in a C++ friendly way. */
++class Info
++{
++public:
++    Info();
++    virtual ~Info() = default;
++
++    /** Information that we can get from snapd about a package */
++    struct PkgInfo
++    {
++        std::string name;               /**< Name of the package */
++        std::string version;            /**< Version string provided by the package */
++        std::string revision;           /**< Numerical always incrementing revision of the package */
++        std::string directory;          /**< Directory that the snap is uncompressed into */
++        std::set<std::string> appnames; /**< List of appnames in the snap */
++    };
++    std::shared_ptr<PkgInfo> pkgInfo(const AppID::Package &package) const;
++
++    std::set<AppID> appsForInterface(const std::string &interface) const;
++
++    std::set<std::string> interfacesForAppId(const AppID &appid) const;
++
++private:
++    /** Path to the socket of snapd */
++    std::string snapdSocket;
++    /** Directory to use as the base for all snap packages when making paths. This
++        can be overridden with UBUNTU_APP_LAUNCH_SNAP_BASEDIR */
++    std::string snapBasedir;
++    /** Result of a check at init to see if the socket is available. If
++        not all functions will return null results. */
++    bool snapdExists = false;
++
++    std::shared_ptr<JsonNode> snapdJson(const std::string &endpoint) const;
++    void forAllPlugs(std::function<void(JsonObject *plugobj)> plugfunc) const;
++};
++
++}  // namespace snapd
++}  // namespace app_launch
++}  // namespace ubuntu
 === modified file 'libubuntu-app-launch/ubuntu-app-launch.cpp'
 --- libubuntu-app-launch/ubuntu-app-launch.cpp	2016-09-13 17:38:17 +0000
 +++ libubuntu-app-launch/ubuntu-app-launch.cpp	2016-09-13 17:38:18 +0000
@@ -316,6 +316,9 @@
  		} else if (g_strcmp0(env, "JOB=application-legacy") == 0) {
  			job_found = TRUE;
  			job_legacy = TRUE;
++		} else if (g_strcmp0(env, "JOB=application-snap") == 0) {
++			job_found = TRUE;
++			job_legacy = TRUE;
  		} else if (g_str_has_prefix(env, "INSTANCE=")) {
  			instance = g_strdup(env + strlen("INSTANCE="));
+ 		}
 === modified file 'tests/CMakeLists.txt'
 --- tests/CMakeLists.txt	2016-09-13 17:38:17 +0000
 +++ tests/CMakeLists.txt	2016-09-13 17:38:18 +0000
@@ -3,6 +3,11 @@
  configure_file ("click-db-dir/test.conf.in" "${CMAKE_CURRENT_BINARY_DIR}/click-db-dir/test.conf" @ONLY)
  set_directory_properties (PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${CMAKE_CURRENT_BINARY_DIR}/click-db-dir/test.conf")
++if(CURL_FOUND)
++add_definitions ( -DENABLE_SNAPPY=1 )
++endif()
++
++
  # Google Test
  include_directories(${GTEST_INCLUDE_DIR})
@@ -35,6 +40,7 @@
  add_definitions ( -DSOCKET_DEMANGLER="${CMAKE_BINARY_DIR}/socket-demangler" )
  add_definitions ( -DSOCKET_DEMANGLER_INSTALL="${pkglibexecdir}/socket-demangler" )
  add_definitions ( -DSOCKET_TOOL="${CMAKE_CURRENT_BINARY_DIR}/socket-tool" )
++add_definitions ( -DSNAP_BASEDIR="${CMAKE_CURRENT_SOURCE_DIR}/snap-basedir" )
  add_executable (libual-test
  	libual-test.cc
@@ -57,6 +63,16 @@
  add_test (NAME libual-test COMMAND libual-test)
  add_test (NAME libual-cpp-test COMMAND libual-cpp-test)
++# Snapd Info Test
++
++if(CURL_FOUND)
++add_definitions ( -DSNAPD_TEST_SOCKET="/tmp/snapd-test-socket" )
++add_executable (snapd-info-test
++	snapd-info-test.cpp)
++target_link_libraries (snapd-info-test gtest ${GTEST_LIBS} launcher-static)
++add_test (NAME snapd-info-test COMMAND snapd-info-test)
++endif()
++
  # List Apps
  add_executable (list-apps
@@ -144,5 +160,7 @@
  	libual-cpp-test.cc
  	list-apps.cpp
  	eventually-fixture.h
++	snapd-info-test.cpp
++	snapd-mock.h
  	zg-test.cc
+ )
 === modified file 'tests/exec-util-test.cc'
 --- tests/exec-util-test.cc	2016-09-13 17:38:17 +0000
 +++ tests/exec-util-test.cc	2016-09-13 17:38:18 +0000
@@ -44,6 +44,7 @@
  			g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
  			g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
  			g_setenv("UBUNTU_APP_LAUNCH_LIBERTINE_LAUNCH", "libertine-launch", TRUE);
++			g_setenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET", "/this/should/not/exist", TRUE);
  			service = dbus_test_service_new(NULL);
 === modified file 'tests/failure-test.cc'
 --- tests/failure-test.cc	2016-08-06 02:57:13 +0000
 +++ tests/failure-test.cc	2016-09-13 17:38:18 +0000
@@ -37,7 +37,6 @@
  		virtual void TearDown() {
  			g_test_dbus_down(testbus);
  			g_clear_object(&testbus);
--			return;
+ 		}
  };
@@ -48,7 +47,6 @@
  		std::string * last = static_cast<std::string *>(user_data);
  		*last = appid;
+ 	}
--	return;
+ }
  TEST_F(FailureTest, CrashTest)
@@ -75,8 +73,6 @@
  	EXPECT_EVENTUALLY_EQ("foo", last_observer);
  	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
--
--	return;
+ }
  TEST_F(FailureTest, LegacyTest)
@@ -94,8 +90,23 @@
  	EXPECT_EVENTUALLY_EQ("foo", last_observer);
  	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
--
--	return;
++}
++
++TEST_F(FailureTest, SnapTest)
++{
++	g_setenv("EXIT_STATUS", "-100", TRUE);
++	g_setenv("JOB", "application-snap", TRUE);
++	g_setenv("INSTANCE", "foo_bar_x123-1234", TRUE);
++
++	std::string last_observer;
++	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_observer, &last_observer));
++
++	/* Status based */
++	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
++
++	EXPECT_EVENTUALLY_EQ("foo_bar_x123", last_observer);
++
++	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
+ }
  static void
@@ -105,7 +116,6 @@
  		std::string * last = static_cast<std::string *>(user_data);
  		*last = appid;
+ 	}
--	return;
+ }
  TEST_F(FailureTest, StartTest)
@@ -123,6 +133,4 @@
  	EXPECT_EVENTUALLY_EQ("foo", last_observer);
  	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_start_observer, &last_observer));
--
--	return;
+ }
 === modified file 'tests/libual-cpp-test.cc'
 --- tests/libual-cpp-test.cc	2016-09-13 17:38:17 +0000
 +++ tests/libual-cpp-test.cc	2016-09-13 17:38:18 +0000
@@ -38,6 +38,10 @@
  #include "eventually-fixture.h"
  #include "mir-mock.h"
++#ifdef ENABLE_SNAPPY
++#include "snapd-mock.h"
++#endif
++
  class LibUAL : public EventuallyFixture
+ {
  protected:
@@ -103,6 +107,13 @@
          g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
          g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
++#ifdef ENABLE_SNAPPY
++        g_setenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET", SNAPD_TEST_SOCKET, TRUE);
++        g_setenv("UBUNTU_APP_LAUNCH_SNAP_BASEDIR", SNAP_BASEDIR, TRUE);
++        g_setenv("UBUNTU_APP_LAUNCH_DISABLE_SNAPD_TIMEOUT", "You betcha!", TRUE);
++        g_unlink(SNAPD_TEST_SOCKET);
++#endif
++
          service = dbus_test_service_new(NULL);
          debugConnection();
@@ -117,6 +128,8 @@
          dbus_test_dbus_mock_object_add_method(mock, obj, "GetJobByName", G_VARIANT_TYPE("s"), G_VARIANT_TYPE("o"),
                                                "if args[0] == 'application-click':\n"
                                                "	ret = dbus.ObjectPath('/com/test/application_click')\n"
++                                              "elif args[0] == 'application-snap':\n"
++                                              "	ret = dbus.ObjectPath('/com/test/application_snap')\n"
                                                "elif args[0] == 'application-legacy':\n"
                                                "	ret = dbus.ObjectPath('/com/test/application_legacy')\n"
                                                "elif args[0] == 'untrusted-helper':\n"
@@ -153,6 +166,36 @@
                                                  g_variant_new_parsed(process_var), NULL);
          g_free(process_var);
++#ifdef ENABLE_SNAPPY
++        /* Snap App */
++        auto snapjobobj =
++            dbus_test_dbus_mock_get_object(mock, "/com/test/application_snap", "com.ubuntu.Upstart0_6.Job", NULL);
++
++        dbus_test_dbus_mock_object_add_method(
++            mock, snapjobobj, "Start", G_VARIANT_TYPE("(asb)"), NULL,
++            "if args[0][0] == 'APP_ID=unity8-package_foo_x123':"
++            "    raise dbus.exceptions.DBusException('Foo running', name='com.ubuntu.Upstart0_6.Error.AlreadyStarted')",
++            NULL);
++
++        dbus_test_dbus_mock_object_add_method(mock, snapjobobj, "Stop", G_VARIANT_TYPE("(asb)"), NULL, "", NULL);
++
++        dbus_test_dbus_mock_object_add_method(mock, snapjobobj, "GetAllInstances", NULL, G_VARIANT_TYPE("ao"),
++                                              "ret = [ dbus.ObjectPath('/com/test/snapp_instance') ]", NULL);
++
++        dbus_test_dbus_mock_object_add_method(mock, snapjobobj, "GetInstanceByName", G_VARIANT_TYPE_STRING,
++                                              G_VARIANT_TYPE("o"), "ret = dbus.ObjectPath('/com/test/snapp_instance')",
++                                              NULL);
++
++        auto snapinstobj =
++            dbus_test_dbus_mock_get_object(mock, "/com/test/snapp_instance", "com.ubuntu.Upstart0_6.Instance", NULL);
++        dbus_test_dbus_mock_object_add_property(mock, snapinstobj, "name", G_VARIANT_TYPE_STRING,
++                                                g_variant_new_string("unity8-package_foo_x123-"), NULL);
++        gchar* snapprocess_var = g_strdup_printf("[('main', %d)]", getpid());
++        dbus_test_dbus_mock_object_add_property(mock, snapinstobj, "processes", G_VARIANT_TYPE("a(si)"),
++                                                g_variant_new_parsed(snapprocess_var), NULL);
++        g_free(snapprocess_var);
++#endif
++
          /*  Legacy App */
          DbusTestDbusMockObject* ljobobj =
              dbus_test_dbus_mock_get_object(mock, "/com/test/application_legacy", "com.ubuntu.Upstart0_6.Job", NULL);
@@ -249,6 +292,10 @@
          g_object_unref(bus);
          ASSERT_EVENTUALLY_EQ(nullptr, bus);
++
++#ifdef ENABLE_SNAPPY
++        g_unlink(SNAPD_TEST_SOCKET);
++#endif
+     }
      GVariant* find_env(GVariant* env_array, const gchar* var)
@@ -412,6 +459,146 @@
      ASSERT_EQ(dbus_test_dbus_mock_object_check_method_call(mock, obj, "Stop", NULL, NULL), 1);
+ }
++#ifdef ENABLE_SNAPPY
++/* Snapd mock data */
++static std::pair<std::string, std::string> interfaces{
++    "GET /v2/interfaces HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++    SnapdMock::httpJsonResponse(
++        SnapdMock::snapdOkay(SnapdMock::interfacesJson({{"unity8", "unity8-package", {"foo", "single"}}})))};
++static std::pair<std::string, std::string> u8Package{
++    "GET /v2/snaps/unity8-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++    SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
++        SnapdMock::packageJson("unity8-package", "active", "app", "1.2.3.4", "x123", {"foo", "single"})))};
++
++TEST_F(LibUAL, ApplicationIdSnap)
++{
++    SnapdMock snapd{SNAPD_TEST_SOCKET,
++                    {u8Package, u8Package, u8Package, u8Package, u8Package, u8Package, u8Package, u8Package, u8Package,
++                     u8Package, u8Package, u8Package, u8Package, u8Package, u8Package, u8Package}};
++    registry = std::make_shared<ubuntu::app_launch::Registry>();
++
++    EXPECT_EQ("unity8-package_foo_x123", (std::string)ubuntu::app_launch::AppID::discover(registry, "unity8-package"));
++    EXPECT_EQ("unity8-package_foo_x123",
++              (std::string)ubuntu::app_launch::AppID::discover(registry, "unity8-package", "foo"));
++    EXPECT_EQ("unity8-package_single_x123",
++              (std::string)ubuntu::app_launch::AppID::discover(registry, "unity8-package", "single"));
++    EXPECT_EQ("unity8-package_single_x123",
++              (std::string)ubuntu::app_launch::AppID::discover(
++                  registry, "unity8-package", ubuntu::app_launch::AppID::ApplicationWildcard::LAST_LISTED));
++    EXPECT_EQ("unity8-package_foo_x123",
++              (std::string)ubuntu::app_launch::AppID::discover(registry, "unity8-package", "foo", "x123"));
++
++    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "unity7-package"));
++}
++
++TEST_F(LibUAL, StartSnapApplication)
++{
++    SnapdMock snapd{SNAPD_TEST_SOCKET, {u8Package, interfaces, u8Package}};
++    registry = std::make_shared<ubuntu::app_launch::Registry>();
++
++    auto obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_snap", "com.ubuntu.Upstart0_6.Job", NULL);
++
++    /* Basic make sure we can send the event */
++    auto appid = ubuntu::app_launch::AppID::parse("unity8-package_single_x123");
++    auto app = ubuntu::app_launch::Application::create(appid, registry);
++    app->launch();
++
++    EXPECT_EQ(1, dbus_test_dbus_mock_object_check_method_call(mock, obj, "Start", NULL, NULL));
++
++    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
++
++    /* Now look at the details of the call */
++    app->launch();
++
++    guint len = 0;
++    const DbusTestDbusMockCall* calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
++    EXPECT_NE(nullptr, calls);
++    EXPECT_EQ(1, len);
++
++    EXPECT_STREQ("Start", calls->name);
++    EXPECT_EQ(2, g_variant_n_children(calls->params));
++
++    GVariant* block = g_variant_get_child_value(calls->params, 1);
++    EXPECT_TRUE(g_variant_get_boolean(block));
++    g_variant_unref(block);
++
++    GVariant* env = g_variant_get_child_value(calls->params, 0);
++    EXPECT_TRUE(check_env(env, "APP_ID", "unity8-package_single_x123"));
++    g_variant_unref(env);
++
++    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
++
++    /* Let's pass some URLs */
++    std::vector<ubuntu::app_launch::Application::URL> urls{
++        ubuntu::app_launch::Application::URL::from_raw("http://ubuntu.com/"),
++        ubuntu::app_launch::Application::URL::from_raw("https://ubuntu.com/"),
++        ubuntu::app_launch::Application::URL::from_raw("file:///home/phablet/test.txt")};
++
++    app->launch(urls);
++
++    len = 0;
++    calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
++    EXPECT_NE(nullptr, calls);
++    EXPECT_EQ(1, len);
++
++    env = g_variant_get_child_value(calls->params, 0);
++    EXPECT_TRUE(check_env(env, "APP_ID", "unity8-package_single_x123"));
++    EXPECT_TRUE(
++        check_env(env, "APP_URIS", "'http://ubuntu.com/' 'https://ubuntu.com/' 'file:///home/phablet/test.txt'"));
++    g_variant_unref(env);
++
++    return;
++}
++
++TEST_F(LibUAL, StartSnapApplicationTest)
++{
++    SnapdMock snapd{SNAPD_TEST_SOCKET, {u8Package, interfaces, u8Package}};
++    registry = std::make_shared<ubuntu::app_launch::Registry>();
++
++    auto obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_snap", "com.ubuntu.Upstart0_6.Job", NULL);
++
++    /* Basic make sure we can send the event */
++    auto appid = ubuntu::app_launch::AppID::parse("unity8-package_single_x123");
++    auto app = ubuntu::app_launch::Application::create(appid, registry);
++    app->launchTest();
++
++    guint len = 0;
++    auto calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
++    EXPECT_NE(nullptr, calls);
++    EXPECT_EQ(1, len);
++
++    EXPECT_STREQ("Start", calls->name);
++    EXPECT_EQ(2, g_variant_n_children(calls->params));
++
++    GVariant* block = g_variant_get_child_value(calls->params, 1);
++    EXPECT_TRUE(g_variant_get_boolean(block));
++    g_variant_unref(block);
++
++    GVariant* env = g_variant_get_child_value(calls->params, 0);
++    EXPECT_TRUE(check_env(env, "APP_ID", "unity8-package_single_x123"));
++    EXPECT_TRUE(check_env(env, "QT_LOAD_TESTABILITY", "1"));
++    g_variant_unref(env);
++}
++
++TEST_F(LibUAL, StopSnapApplication)
++{
++    SnapdMock snapd{SNAPD_TEST_SOCKET, {u8Package, interfaces, u8Package}};
++    registry = std::make_shared<ubuntu::app_launch::Registry>();
++
++    auto obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_snap", "com.ubuntu.Upstart0_6.Job", NULL);
++
++    auto appid = ubuntu::app_launch::AppID::parse("unity8-package_foo_x123");
++    auto app = ubuntu::app_launch::Application::create(appid, registry);
++
++    ASSERT_TRUE(app->hasInstances());
++    EXPECT_EQ(1, app->instances().size());
++
++    app->instances()[0]->stop();
++
++    ASSERT_EQ(dbus_test_dbus_mock_object_check_method_call(mock, obj, "Stop", NULL, NULL), 1);
++}
++#endif
++
  /* NOTE: The fact that there is 'libertine-data' in these strings is because
     we're using one CACHE_HOME for this test suite and the libertine functions
     need to pull things from there, where these are only comparisons. It's just
@@ -579,9 +766,18 @@
  TEST_F(LibUAL, ApplicationList)
+ {
++#ifdef ENABLE_SNAPPY
++    SnapdMock snapd{SNAPD_TEST_SOCKET, {u8Package, u8Package, u8Package, interfaces, u8Package}};
++    registry = std::make_shared<ubuntu::app_launch::Registry>();
++#endif
++
      auto apps = ubuntu::app_launch::Registry::runningApps(registry);
++#ifdef ENABLE_SNAPPY
++    ASSERT_EQ(4, apps.size());
++#else
      ASSERT_EQ(3, apps.size());
++#endif
      apps.sort([](const std::shared_ptr<ubuntu::app_launch::Application>& a,
                   const std::shared_ptr<ubuntu::app_launch::Application>& b) {
@@ -592,7 +788,9 @@
      });
      EXPECT_EQ("com.test.good_application_1.2.3", (std::string)apps.front()->appId());
--    EXPECT_EQ("single", (std::string)apps.back()->appId());
++#ifdef ENABLE_SNAPPY
++    EXPECT_EQ("unity8-package_foo_x123", (std::string)apps.back()->appId());
++#endif
+ }
  typedef struct
 === modified file 'tests/libual-test.cc'
 --- tests/libual-test.cc	2016-09-13 17:38:17 +0000
 +++ tests/libual-test.cc	2016-09-13 17:38:18 +0000
@@ -89,6 +89,8 @@
  			g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
  			g_setenv("XDG_DATA_HOME",  CMAKE_SOURCE_DIR "/libertine-home", TRUE);
++			g_setenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET", "/this/should/not/exist", TRUE);
++
  			service = dbus_test_service_new(NULL);
  			debugConnection();
 === modified file 'tests/list-apps.cpp'
 --- tests/list-apps.cpp	2016-09-13 17:38:17 +0000
 +++ tests/list-apps.cpp	2016-09-13 17:38:18 +0000
@@ -27,9 +27,15 @@
  #include "application-impl-click.h"
  #include "application-impl-legacy.h"
  #include "application-impl-libertine.h"
++#include "application-impl-snap.h"
  #include "application.h"
  #include "registry.h"
++#ifdef ENABLE_SNAPPY
++#include "snapd-mock.h"
++#define SNAPD_LIST_APPS_SOCKET SNAPD_TEST_SOCKET "-list-apps"
++#endif
++
  class ListApps : public EventuallyFixture
+ {
  protected:
@@ -38,6 +44,11 @@
      virtual void SetUp()
+     {
++#ifdef ENABLE_SNAPPY
++        /* Ensure it is cleared */
++        g_unlink(SNAPD_LIST_APPS_SOCKET);
++#endif
++
          /* Click DB test mode */
          g_setenv("TEST_CLICK_DB", CMAKE_BINARY_DIR "/click-db-dir", TRUE);
          g_setenv("TEST_CLICK_USER", "test-user", TRUE);
@@ -50,6 +61,12 @@
          g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
          g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
++#ifdef ENABLE_SNAPPY
++        g_setenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET", SNAPD_LIST_APPS_SOCKET, TRUE);
++        g_setenv("UBUNTU_APP_LAUNCH_SNAP_BASEDIR", SNAP_BASEDIR, TRUE);
++        g_setenv("UBUNTU_APP_LAUNCH_DISABLE_SNAPD_TIMEOUT", "You betcha!", TRUE);
++#endif
++
          testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
          g_test_dbus_up(testbus);
@@ -60,6 +77,10 @@
      virtual void TearDown()
+     {
++#ifdef ENABLE_SNAPPY
++        g_unlink(SNAPD_LIST_APPS_SOCKET);
++#endif
++
          g_object_unref(bus);
          g_test_dbus_down(testbus);
@@ -159,8 +180,62 @@
      EXPECT_TRUE(findApp(apps, "container-name_user-app_0.0"));
+ }
++#ifdef ENABLE_SNAPPY
++static std::pair<std::string, std::string> interfaces{
++    "GET /v2/interfaces HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++    SnapdMock::httpJsonResponse(
++        SnapdMock::snapdOkay(SnapdMock::interfacesJson({{"unity8", "unity8-package", {"foo", "bar"}},
++                                                        {"unity7", "unity7-package", {"single", "multiple"}},
++                                                        {"x11", "x11-package", {"multiple", "hidden"}}
++
++        })))};
++static std::pair<std::string, std::string> u8Package{
++    "GET /v2/snaps/unity8-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++    SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
++        SnapdMock::packageJson("unity8-package", "active", "app", "1.2.3.4", "x123", {"foo", "bar"})))};
++static std::pair<std::string, std::string> u7Package{
++    "GET /v2/snaps/unity7-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++    SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(SnapdMock::packageJson(
++        "unity7-package", "active", "app", "1.2.3.4", "x123", {"scope", "single", "multiple"})))};
++static std::pair<std::string, std::string> x11Package{
++    "GET /v2/snaps/x11-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++    SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
++        SnapdMock::packageJson("x11-package", "active", "app", "1.2.3.4", "x123", {"multiple", "hidden"})))};
++
++TEST_F(ListApps, ListSnap)
++{
++    SnapdMock mock{SNAPD_LIST_APPS_SOCKET,
++                   {interfaces, u7Package, u7Package, u7Package,      /* unity7 check */
++                    interfaces, u8Package, u8Package, u8Package,      /* unity8 check */
++                    interfaces, x11Package, x11Package, x11Package}}; /* x11 check */
++    auto registry = std::make_shared<ubuntu::app_launch::Registry>();
++
++    auto apps = ubuntu::app_launch::app_impls::Snap::list(registry);
++
++    printApps(apps);
++
++    mock.result();
++
++    EXPECT_EQ(4, apps.size());
++    EXPECT_TRUE(findApp(apps, "unity8-package_foo_x123"));
++    EXPECT_TRUE(findApp(apps, "unity7-package_single_x123"));
++    EXPECT_TRUE(findApp(apps, "unity7-package_multiple_x123"));
++    EXPECT_TRUE(findApp(apps, "x11-package_multiple_x123"));
++
++    EXPECT_FALSE(findApp(apps, "unity8-package_bar_x123"));
++    EXPECT_FALSE(findApp(apps, "unity7-package_scope_x123"));
++    EXPECT_FALSE(findApp(apps, "x11-package_hidden_x123"));
++}
++#endif
++
  TEST_F(ListApps, ListAll)
+ {
++#ifdef ENABLE_SNAPPY
++    SnapdMock mock{SNAPD_LIST_APPS_SOCKET,
++                   {interfaces, u7Package, u7Package, u7Package,      /* unity7 check */
++                    interfaces, u8Package, u8Package, u8Package,      /* unity8 check */
++                    interfaces, x11Package, x11Package, x11Package}}; /* x11 check */
++#endif
      auto registry = std::make_shared<ubuntu::app_launch::Registry>();
      /* Get all the apps */
@@ -168,5 +243,9 @@
      printApps(apps);
++#ifdef ENABLE_SNAPPY
++    EXPECT_EQ(18, apps.size());
++#else
      EXPECT_EQ(14, apps.size());
++#endif
+ }
 === added directory 'tests/snap-basedir'
 === added directory 'tests/snap-basedir/unity7-package'
 === added directory 'tests/snap-basedir/unity7-package/x123'
 === added directory 'tests/snap-basedir/unity7-package/x123/meta'
 === added symlink 'tests/snap-basedir/unity7-package/x123/meta/gui'
 === target is u'../../../../applications/'
 === added directory 'tests/snap-basedir/unity8-package'
 === added directory 'tests/snap-basedir/unity8-package/x123'
 === added directory 'tests/snap-basedir/unity8-package/x123/meta'
 === added symlink 'tests/snap-basedir/unity8-package/x123/meta/gui'
 === target is u'../../../../applications/'
 === added directory 'tests/snap-basedir/x11-package'
 === added directory 'tests/snap-basedir/x11-package/x123'
 === added directory 'tests/snap-basedir/x11-package/x123/meta'
 === added symlink 'tests/snap-basedir/x11-package/x123/meta/gui'
 === target is u'../../../../applications/'
 === added file 'tests/snapd-info-test.cpp'
 --- tests/snapd-info-test.cpp	1970-01-01 00:00:00 +0000
 +++ tests/snapd-info-test.cpp	2016-09-13 17:38:18 +0000
@@ -0,0 +1,150 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#include "snapd-info.h"
++#include "snapd-mock.h"
++#include <gio/gio.h>
++#include <glib/gstdio.h>
++#include <gtest/gtest.h>
++
++class SnapdInfo : public ::testing::Test
++{
++protected:
++    virtual void SetUp()
++    {
++        g_setenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET", SNAPD_TEST_SOCKET, TRUE);
++    }
++
++    virtual void TearDown()
++    {
++        g_unlink(SNAPD_TEST_SOCKET);
++    }
++};
++
++TEST_F(SnapdInfo, Init)
++{
++    auto info = std::make_shared<ubuntu::app_launch::snapd::Info>();
++
++    info.reset();
++}
++
++TEST_F(SnapdInfo, PackageInfo)
++{
++    SnapdMock mock{SNAPD_TEST_SOCKET,
++                   {{"GET /v2/snaps/test-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++                     SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(SnapdMock::packageJson(
++                         "test-package", "active", "app", "1.2.3.4", "x123", {"foo", "bar"})))}}};
++    auto info = std::make_shared<ubuntu::app_launch::snapd::Info>();
++
++    auto pkginfo = info->pkgInfo(ubuntu::app_launch::AppID::Package::from_raw("test-package"));
++
++    mock.result();
++
++    ASSERT_NE(nullptr, pkginfo);
++    EXPECT_EQ("test-package", pkginfo->name);
++    EXPECT_EQ("1.2.3.4", pkginfo->version);
++    EXPECT_EQ("x123", pkginfo->revision);
++    EXPECT_EQ("/snap/test-package/x123", pkginfo->directory);
++    EXPECT_NE(pkginfo->appnames.end(), pkginfo->appnames.find("foo"));
++    EXPECT_NE(pkginfo->appnames.end(), pkginfo->appnames.find("bar"));
++}
++
++TEST_F(SnapdInfo, AppsForInterface)
++{
++    SnapdMock mock{SNAPD_TEST_SOCKET,
++                   {{"GET /v2/interfaces HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++                     SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
++                         SnapdMock::interfacesJson({{"unity8", "test-package", {"foo", "bar"}}})))},
++                    {"GET /v2/snaps/test-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++                     SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(SnapdMock::packageJson(
++                         "test-package", "active", "app", "1.2.3.4", "x123", {"foo", "bar"})))}}};
++
++    auto info = std::make_shared<ubuntu::app_launch::snapd::Info>();
++
++    auto apps = info->appsForInterface("unity8");
++
++    mock.result();
++
++    EXPECT_EQ(2, apps.size());
++    EXPECT_NE(apps.end(), apps.find(ubuntu::app_launch::AppID::parse("test-package_foo_x123")));
++    EXPECT_NE(apps.end(), apps.find(ubuntu::app_launch::AppID::parse("test-package_bar_x123")));
++}
++
++TEST_F(SnapdInfo, InterfacesForAppID)
++{
++    SnapdMock mock{SNAPD_TEST_SOCKET,
++                   {{"GET /v2/interfaces HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++                     SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
++                         SnapdMock::interfacesJson({{"unity8", "test-package", {"foo"}},
++                                                    {"noniface", "test-package", {"bar", "bamf", "bunny"}},
++                                                    {"unity7", "test-package", {"bar", "foo"}}})))}
++
++                   }};
++
++    auto info = std::make_shared<ubuntu::app_launch::snapd::Info>();
++    auto appid = ubuntu::app_launch::AppID::parse("test-package_foo_x123");
++
++    auto ifaces = info->interfacesForAppId(appid);
++
++    mock.result();
++
++    EXPECT_EQ(2, ifaces.size());
++    EXPECT_NE(ifaces.end(), ifaces.find("unity7"));
++    EXPECT_NE(ifaces.end(), ifaces.find("unity8"));
++}
++
++TEST_F(SnapdInfo, BadJson)
++{
++    SnapdMock mock{
++        SNAPD_TEST_SOCKET,
++        {
++            {"GET /v2/snaps/test-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++             SnapdMock::httpJsonResponse("«This is not valid JSON»")},
++            {"GET /v2/snaps/test-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++             SnapdMock::httpJsonResponse("{ 'status': 'FAIL', 'status-code': 404, 'type': 'sync', 'result': { } }")},
++            {"GET /v2/snaps/test-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++             SnapdMock::httpJsonResponse(SnapdMock::snapdOkay("'«This is not an object»'"))},
++
++        }};
++    auto info = std::make_shared<ubuntu::app_launch::snapd::Info>();
++
++    auto badjson = info->pkgInfo(ubuntu::app_launch::AppID::Package::from_raw("test-package"));
++
++    EXPECT_EQ(nullptr, badjson);
++
++    auto err404 = info->pkgInfo(ubuntu::app_launch::AppID::Package::from_raw("test-package"));
++
++    EXPECT_EQ(nullptr, err404);
++
++    auto noobj = info->pkgInfo(ubuntu::app_launch::AppID::Package::from_raw("test-package"));
++
++    EXPECT_EQ(nullptr, noobj);
++
++    /* We should still be getting good requests, so let's check them */
++    mock.result();
++}
++
++TEST_F(SnapdInfo, NoSocket)
++{
++    auto info = std::make_shared<ubuntu::app_launch::snapd::Info>();
++
++    auto nosocket = info->pkgInfo(ubuntu::app_launch::AppID::Package::from_raw("test-package"));
++
++    EXPECT_EQ(nullptr, nosocket);
++}
 === added file 'tests/snapd-mock.h'
 --- tests/snapd-mock.h	1970-01-01 00:00:00 +0000
 +++ tests/snapd-mock.h	2016-09-13 17:38:18 +0000
@@ -0,0 +1,384 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *   Ted Gould <ted.gould@canonical.com>
++ */
++
++#include "glib-thread.h"
++#include <future>
++#include <gio/gio.h>
++#include <gio/gunixsocketaddress.h>
++#include <gtest/gtest.h>
++#include <list>
++#include <numeric>
++
++class SnapdMock
++{
++public:
++    /** Initialize the mock with a list of files to use as
++        input and output. Each will be sent in order. */
++    SnapdMock(const std::string &socketPath, std::list<std::pair<std::string, std::string>> interactions)
++        : thread()
++    {
++        for (auto interaction : interactions)
++        {
++            TestCase testcase{interaction.first, interaction.second, {}, {}};
++            testCases.push_back(testcase);
++        }
++
++        /* Build the socket */
++        socketService = thread.executeOnThread<std::shared_ptr<GSocketService>>([this, socketPath]() {
++            auto service = std::shared_ptr<GSocketService>(g_socket_service_new(), [](GSocketService *service) {
++                if (service != nullptr)
++                {
++                    g_socket_service_stop(service);
++                    g_object_unref(service);
++                }
++            });
++
++            GError *error = nullptr;
++            auto socket = g_socket_new(G_SOCKET_FAMILY_UNIX,      /* unix */
++                                       G_SOCKET_TYPE_STREAM,      /* type */
++                                       G_SOCKET_PROTOCOL_DEFAULT, /* protocol */
++                                       &error);
++
++            if (error != nullptr)
++            {
++                std::string message = "Failed to create socket: " + std::string(error->message);
++                g_error_free(error);
++                throw std::runtime_error(message);
++            }
++
++            auto socketaddr = g_unix_socket_address_new(socketPath.c_str());
++            if (socketaddr == nullptr)
++            {
++                throw std::runtime_error("Unable to create a socket address for: " + socketPath);
++            }
++
++            g_socket_bind(socket, socketaddr, TRUE, &error);
++            if (error != nullptr)
++            {
++                std::string message =
++                    "Unable to connect socket to address '" + socketPath + "': " + std::string(error->message);
++                g_error_free(error);
++                throw std::runtime_error(message);
++            }
++
++            g_socket_listener_add_socket(G_SOCKET_LISTENER(service.get()), socket, nullptr, &error);
++            if (error != nullptr)
++            {
++                std::string message = "Unable to listen to socket: " + std::string(error->message);
++                g_error_free(error);
++                throw std::runtime_error(message);
++            }
++
++            g_signal_connect(service.get(), "incoming", G_CALLBACK(serviceConnectedStatic), this);
++
++            g_socket_service_start(service.get());
++
++            g_socket_listen(socket, &error);
++            if (error != nullptr)
++            {
++                std::string message = "Unable to listen to socket: " + std::string(error->message);
++                g_error_free(error);
++                throw std::runtime_error(message);
++            }
++
++            g_debug("Initialized snapd-mock with %d test cases", int(testCases.size()));
++            return service;
++        });
++    }
++
++    ~SnapdMock()
++    {
++        thread.executeOnThread<bool>([this]() {
++            for (auto testcase : testCases)
++            {
++                testcase.connection.reset(); /* ensure these get dropped on teh thread */
++            }
++            socketService.reset();
++
++            return true;
++        });
++        thread.quit();
++    }
++
++    /** Check to see if the mock was used successfully */
++    inline void result()
++    {
++        /* Ensure we get queued events off the mainloop */
++        std::promise<void> promise;
++        thread.timeout(std::chrono::milliseconds{10}, [&promise]() { promise.set_value(); });
++        promise.get_future().wait();
++
++        for (auto testcase : testCases)
++        {
++            EXPECT_EQ(testcase.input, testcase.result);
++        }
++
++        EXPECT_EQ(0, extraCases.size());
++
++        for (auto testcase : extraCases)
++        {
++            EXPECT_EQ(std::string{}, testcase.result);
++        }
++    }
++
++private:
++    GLib::ContextThread thread;
++    std::shared_ptr<GSocketService> socketService;
++
++    struct TestCase
++    {
++        std::string input;
++        std::string output;
++        std::string result;
++        std::shared_ptr<GSocketConnection> connection;
++    };
++
++    std::list<TestCase> testCases;
++    std::list<TestCase> extraCases;
++
++    static gboolean serviceConnectedStatic(GSocketService *service,
++                                           GSocketConnection *connection,
++                                           GObject *source_obj,
++                                           gpointer userdata) noexcept
++    {
++        auto obj = reinterpret_cast<SnapdMock *>(userdata);
++        auto cppconn = std::shared_ptr<GSocketConnection>(G_SOCKET_CONNECTION(g_object_ref(connection)),
++                                                          [](GSocketConnection *con) { g_clear_object(&con); });
++        return obj->serviceConnected(cppconn) ? TRUE : FALSE;
++    }
++
++    bool serviceConnected(std::shared_ptr<GSocketConnection> connection)
++    {
++        for (auto &testcase : testCases)
++        {
++            if (testcase.connection)
++            {
++                /* We don't want ones that already have a connection */
++                continue;
++            }
++
++            testcase.connection = connection;
++
++            auto input = g_io_stream_get_input_stream(G_IO_STREAM(connection.get()));  // transfer: none
++            g_input_stream_read_bytes_async(input,                                     /* stream */
++                                            1024,                                      /* 1K at a time */
++                                            G_PRIORITY_DEFAULT,                        /* default priority */
++                                            thread.getCancellable().get(),             /* cancel */
++                                            caseInputStatic,                           /* callback */
++                                            &testcase);
++
++            auto output = g_io_stream_get_output_stream(G_IO_STREAM(connection.get()));  // transfer: none
++            if (output == nullptr)
++            {
++                g_warning("No output stream avilable with connection!");
++            }
++
++            g_output_stream_write_all_async(
++                output,                        /* output stream */
++                testcase.output.c_str(),       /* data */
++                testcase.output.size(),        /* size */
++                G_PRIORITY_DEFAULT,            /* priority */
++                thread.getCancellable().get(), /* cancel */
++                [](GObject *obj, GAsyncResult *res, gpointer userdata) -> void {
++                    auto testcase = reinterpret_cast<TestCase *>(userdata);
++                    gsize bytesout = 0;
++                    GError *error = nullptr;
++
++                    g_output_stream_write_all_finish(G_OUTPUT_STREAM(obj), res, &bytesout, &error);
++
++                    if (error != nullptr)
++                    {
++                        g_warning("Unable to write out snapd connection: %s", error->message);
++                        g_error_free(error);
++                        return;
++                    }
++
++                    if (bytesout != testcase->output.size())
++                    {
++                        g_warning("Wrote out %d bytes in snapd socket but expected to write out %d", int(bytesout),
++                                  int(testcase->output.size()));
++                    }
++
++                    g_output_stream_close(G_OUTPUT_STREAM(obj), nullptr, nullptr);
++                    checkConnection(testcase);
++                },          /* callback */
++                &testcase); /* expected size */
++
++            /* We got this one */
++            return true;
++        }
++
++        g_warning("Couldn't find a test case to use for the connection");
++        return false;
++    }
++
++    static void caseInputStatic(GObject *obj, GAsyncResult *res, gpointer userdata) noexcept
++    {
++        auto testcase = reinterpret_cast<TestCase *>(userdata);
++        GError *error = nullptr;
++        auto bytes = g_input_stream_read_bytes_finish(G_INPUT_STREAM(obj), res, &error);
++
++        if (error != nullptr)
++        {
++            g_warning("Error reading input socket: %s", error->message);
++            g_error_free(error);
++            return;
++        }
++
++        auto bytessize = g_bytes_get_size(bytes);
++        if (bytessize > 0)  // zero means closed
++        {
++            auto data = reinterpret_cast<const char *>(g_bytes_get_data(bytes, nullptr));
++
++            for (unsigned int i = 0; i < bytessize; i++)
++            {
++                testcase->result.push_back(data[i]);
++            }
++
++            g_input_stream_read_bytes_async(G_INPUT_STREAM(obj), /* stream */
++                                            1024,                /* 1K at a time */
++                                            G_PRIORITY_DEFAULT,  /* default priority */
++                                            nullptr,             /* TODO? cancel */
++                                            caseInputStatic,     /* callback */
++                                            userdata);
++        }
++        else
++        {
++            // g_debug("Request: %s", testcase->result.c_str());
++            g_input_stream_close(G_INPUT_STREAM(obj), nullptr, nullptr);
++            checkConnection(testcase);
++        }
++
++        g_bytes_unref(bytes);
++    }
++
++    static void checkConnection(TestCase *testcase)
++    {
++        auto input = g_io_stream_get_input_stream(G_IO_STREAM(testcase->connection.get()));    // transfer: none
++        auto output = g_io_stream_get_output_stream(G_IO_STREAM(testcase->connection.get()));  // transfer: none
++
++        if (g_input_stream_is_closed(input) && g_output_stream_is_closed(output))
++        {
++            g_io_stream_close(G_IO_STREAM(testcase->connection.get()), nullptr, nullptr);
++        }
++    }
++
++public:
++    static std::string httpJsonResponse(const std::string &json)
++    {
++        return "HTTP/1.1 200 OK\r\n"                /* okay */
++               "Content-Type: application/json\r\n" /* json stuff */
++               "Content-Length: " +
++               std::to_string(json.size()) + "\r\n\r\n" + /* size of data */
++               json;
++    }
++
++    static std::string snapdOkay(const std::string &result)
++    {
++        return "{ 'status': 'OK', 'status-code': 200, " /* all okay */
++               "  'type': 'sync', "                     /* This lib is only sync */
++               "  'result': " +
++               result + /* here is what we were given */
++               "}";
++    }
++
++    static std::string packageJson(const std::string &name,
++                                   const std::string &status,
++                                   const std::string &type,
++                                   const std::string &version,
++                                   const std::string &revision,
++                                   std::list<std::string> apps)
++    {
++        std::string response = "{\n";
++
++        response += "'name': '" + name + "',\n";
++        response += "'status': '" + status + "',\n";
++        response += "'type': '" + type + "',\n";
++        response += "'version': '" + version + "',\n";
++        response += "'revision': '" + revision + "',\n";
++
++        response += "'apps': [ " + std::accumulate(apps.begin(), apps.end(), std::string{},
++                                                   [](const std::string &builder, std::string entry) {
++                                                       std::string json = "\n  { 'name': '" + entry + "' }";
++                                                       if (builder.empty())
++                                                       {
++                                                           return json;
++                                                       }
++                                                       else
++                                                       {
++                                                           return builder + "," + json;
++                                                       }
++                                                   }) +
++                    "\n]\n";
++
++        return response + "}";
++    }
++
++    struct SnapdPlug
++    {
++        std::string interface;
++        std::string snap;
++        std::list<std::string> apps;
++    };
++
++    static std::string interfacesJson(const std::list<SnapdPlug> &plugs)
++    {
++        std::string response = "{\n";
++
++        response += "'plugs': [ " +
++                    std::accumulate(plugs.begin(), plugs.end(), std::string{},
++                                    [](const std::string &builder, SnapdPlug plug) {
++                                        std::string json = "\n{\n";
++
++                                        json += "'interface': '" + plug.interface + "',\n";
++                                        json += "'snap': '" + plug.snap + "',\n";
++
++                                        json += "'apps': [ " +
++                                                std::accumulate(plug.apps.begin(), plug.apps.end(), std::string{},
++                                                                [](const std::string &builder, std::string entry) {
++                                                                    std::string json = "'" + entry + "'";
++                                                                    if (builder.empty())
++                                                                    {
++                                                                        return json;
++                                                                    }
++                                                                    else
++                                                                    {
++                                                                        return builder + ", " + json;
++                                                                    }
++                                                                }) +
++                                                " ]\n";
++
++                                        json += "}";
++
++                                        if (builder.empty())
++                                        {
++                                            return json;
++                                        }
++                                        else
++                                        {
++                                            return builder + "," + json;
++                                        }
++                                    }) +
++                    "\n],\n";
++
++        response += "'slots': [ { 'foo': 'bar' } ]\n"; /* TODO: For future use */
++
++        return response + "}";
++    }
++};
 === modified file 'upstart-jobs/CMakeLists.txt'
 --- upstart-jobs/CMakeLists.txt	2014-08-30 02:31:30 +0000
 +++ upstart-jobs/CMakeLists.txt	2016-09-13 17:38:18 +0000
@@ -24,6 +24,14 @@
  add_test(application-click.conf.test "${CMAKE_CURRENT_SOURCE_DIR}/test-conffile.sh" "${CMAKE_CURRENT_BINARY_DIR}/application-click.conf")
  ####################
++# application-snap.conf
++####################
++
++configure_file("application-snap.conf.in" "${CMAKE_CURRENT_BINARY_DIR}/application-snap.conf" @ONLY)
++install(FILES "${CMAKE_CURRENT_BINARY_DIR}/application-snap.conf" DESTINATION "${CMAKE_INSTALL_DATADIR}/upstart/sessions")
++add_test(application-snap.conf.test "${CMAKE_CURRENT_SOURCE_DIR}/test-conffile.sh" "${CMAKE_CURRENT_BINARY_DIR}/application-snap.conf")
++
++####################
  # application-failed.conf
  ####################
 === modified file 'upstart-jobs/application-failed.conf.in'
 --- upstart-jobs/application-failed.conf.in	2014-01-22 16:28:06 +0000
 +++ upstart-jobs/application-failed.conf.in	2016-09-13 17:38:18 +0000
@@ -1,6 +1,6 @@
  description "Application Failing"
--start on stopped application-legacy RESULT=failed or stopped application-click RESULT=failed
++start on stopped application-legacy RESULT=failed or stopped application-click RESULT=failed or stopped application-snap RESULT=failed
  task
  exec @pkglibexecdir@/application-failed
 === modified file 'upstart-jobs/application-logrotate.conf'
 --- upstart-jobs/application-logrotate.conf	2014-08-30 02:23:36 +0000
 +++ upstart-jobs/application-logrotate.conf	2016-09-13 17:38:18 +0000
@@ -11,4 +11,5 @@
+ 	#
  	find ${logdir} -mtime +2 -name "application-click-*.log.[1-9].gz" -delete
  	find ${logdir} -mtime +2 -name "application-legacy-*.log.[1-9].gz" -delete
++	find ${logdir} -mtime +2 -name "application-snap-*.log.[1-9].gz" -delete
  end script
 === added file 'upstart-jobs/application-snap.conf.in'
 --- upstart-jobs/application-snap.conf.in	1970-01-01 00:00:00 +0000
 +++ upstart-jobs/application-snap.conf.in	2016-09-13 17:38:18 +0000
@@ -0,0 +1,38 @@
++description "Application Launching for Snap Applications"
++author "Ted Gould <ted@canonical.com>"
++
++instance ${APP_ID}-${INSTANCE_ID}
++
++start on application-snap-start
++stop on application-end or desktop-end
++
++env APP_ID
++env APP_EXEC
++env APP_URIS
++env APP_DIR
++env APP_DESKTOP_FILE_PATH
++env APP_XMIR_ENABLE
++env INSTANCE_ID=""
++
++env UBUNTU_APP_LAUNCH_ARCH="@ubuntu_app_launch_arch@"
++export UBUNTU_APP_LAUNCH_ARCH
++
++# apparmor is taken care of by confine
++cgroup freezer
++
++# Initial OOM Score
++oom score 100
++
++# Remember, this is confined
++exec @pkglibexecdir@/exec-line-exec
++
++post-start exec @pkglibexecdir@/zg-report-app open
++post-stop script
++	@pkglibexecdir@/zg-report-app close
++	@pkglibexecdir@/cgroup-reap-all
++
++	DEVELOPER_MODE=`gdbus call --system --dest com.canonical.PropertyService --object-path /com/canonical/PropertyService --method com.canonical.PropertyService.GetProperty adb`
++	if [ "$DEVELOPER_MODE" != "(true,)" ] ; then
++		rm -f ${HOME}/.cache/upstart/application-snap-${APP_ID}-${INSTANCE_ID}.log*
++	fi
++end script