Merge lp:~ted/ubuntu-app-launch/install-root into lp:ubuntu-app-launch/16.10

[Ted Gould]

Make UAL relocatable for Snappy installs

For things that it makes sense to override we have an envvar to override it. For the Upstart jobs we're just relying on ${SNAP} to be set.

Also added docs for all the envvars that we use.

[unity-api-1-bot (unity-api-1-bot)]

PASSED: Continuous integration, rev:256
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/99/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/647
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/653
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=vivid+overlay/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=vivid+overlay/469/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/469/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/469/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=vivid+overlay/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=vivid+overlay/469/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/469/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/469/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=vivid+overlay/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=vivid+overlay/469/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/469/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/469
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/469/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Marcus Tomlinson (marcustomlinson)]

Comforting to see that all code paths are covered in the tests. Also, your bug, your fix (extra comfort) :)

LGTM

review: Approve

[Ted Gould (ted)]

So further testing on real systems revealed an interesting flaw. Basically by including $SNAP in the exec line it doesn't work. Why? Because to resolve the environment variable Upstart switches from doing an exec directly, to instead using a shell which then does the exec. Not a big deal, except that there seems to be a bug in the way it works with AppArmor. So Upstart switches profiles on exec, but that is after the binary is read, so the exec-line-exec binary doesn't need to be in the Application's apparmor profile. But when the shell goes first the shell itself is exec'ing under the application's profile, and thus needs permission.

This is, at some level, a bug in Upstart. Not sure how it should be fixed. Will have to have conversations with security taking into account the maintenance level of the various packages involved.

review: Needs Fixing

[lp:~ted/ubuntu-app-launch/install-root]

257. By Ted Gould on 2016-11-01

Merging the jobs-systemd branch

258. By Ted Gould on 2016-11-10

Update to latest systemd branch

259. By Ted Gould on 2016-11-14

Pulling through updates

260. By Ted Gould on 2016-11-17

Adding an environment variable for XMir Helper

261. By Ted Gould on 2016-11-17

Pulling through trunk

262. By Ted Gould on 2016-11-17

Restructure exec line building so we can add more

263. By Ted Gould on 2016-11-17

Adding extra environment in the snap world

264. By Ted Gould on 2016-11-17

Make sure we get the other snap environment variables

265. By Ted Gould on 2016-11-18

Switch to calling legacy-exec

266. By Ted Gould on 2016-11-21

Starting utilities to put together an environment setup

267. By Ted Gould on 2016-11-21

Better exit codes

268. By Ted Gould on 2016-11-21

Fleshing out our utilities

269. By Ted Gould on 2016-11-21

Get the binaries into a deb

270. By Ted Gould on 2016-11-21

Make the command line reference the outside util

271. By Ted Gould on 2016-11-21

Call the snappy-xmir util unconfined

272. By Ted Gould on 2016-11-21

Handle write() returns

273. By Ted Gould on 2016-11-21

Disable for a moment

274. By Ted Gould on 2016-11-22

Remove the snap setting libertine launch

275. By Ted Gould on 2016-11-30

Fix command name

276. By Ted Gould on 2016-12-01

Make sure we sleep forever

277. By Ted Gould on 2016-12-01

Get negative errors as well

278. By Ted Gould on 2016-12-01

Make sure the FD stays open

279. By Ted Gould on 2016-12-01

Provide a way to test and put the fd number on the command line

280. By Ted Gould on 2016-12-01

Some basic test scripts

281. By Ted Gould on 2016-12-01

Switch to an abstract socket

282. By Ted Gould on 2016-12-02

Make sure we don't overrun sun_path

283. By Ted Gould on 2016-12-12

Clear out the MIR_* variables

284. By Ted Gould on 2016-12-12

Getting the snappy-xmir tests into the test suite

285. By Ted Gould on 2016-12-12

Check for MIR_ variables

286. By Ted Gould on 2016-12-12

Making sure we clean up the envvars utils

287. By Ted Gould on 2016-12-12

Increase output and debugging info in tests

288. By Ted Gould on 2016-12-12

Read everything in, and then start processing it into individual variables

289. By Ted Gould on 2016-12-12

Cleanup magic numbers

290. By Ted Gould on 2016-12-12

Explicitly set the DBus address as well

291. By Ted Gould on 2016-12-12

Make sure to pad with zeros

292. By Ted Gould on 2016-12-12

Test for long AppIDs

293. By Ted Gould on 2016-12-12

Removing snap variables from the Upstart jobs. If we're under a SNAP we'll be using systemd

294. By Ted Gould on 2016-12-12

Use the path in the current snap as the place to find the helper

295. By Ted Gould on 2016-12-12

Fix formatting

296. By Ted Gould on 2016-12-12

We don't need to care about the SNAP_ variables because they'll be reinserted when we come through the snap commands

297. By Ted Gould on 2016-12-12

Use a build variable to get the path

298. By Ted Gould on 2016-12-12

Switching back to setting the libertine-launch path in non-snap cases

299. By Ted Gould on 2016-12-12

Allow the legacy-exec util to be overridden

300. By Ted Gould on 2016-12-13

Merge error

301. By Ted Gould on 2016-12-13

More magic numbers brought down to Earth

302. By Ted Gould on 2016-12-13

Bigger libs warning. Like really people, read this.

303. By Ted Gould on 2016-12-13

Fix the libertine-launch case for non-snaps

304. By Ted Gould on 2017-01-03

Removing QT and XDG variables, don't think we need them

305. By Ted Gould on 2017-01-06

Removing more variables

306. By Ted Gould on 2017-01-06

Upstream changes

307. By Ted Gould on 2017-01-06

Make sure we don't have a Mir socket before checking that we don't

308. By Ted Gould on 2017-01-11

Merge upstream updates

309. By Ted Gould on 2017-01-19

Update to trunk

310. By Ted Gould on 2017-01-24

Update to current jobs-systemd

311. By Ted Gould on 2017-01-24

Grab QT_ and XDG_ for legacy apps on deb installs

312. By Ted Gould on 2017-01-24

Switching functions

313. By Ted Gould on 2017-01-26

Merge Trunk

314. By Ted Gould on 2017-01-27

Merge changes to jobs-systemd

315. By Ted Gould on 2017-01-30

Put the wrong environment var into the documentation

316. By Ted Gould on 2017-01-30

Getting these variables figured out

317. By Ted Gould on 2017-01-31

Fix docs to include default path for LEGACY_EXEC

318. By Ted Gould on 2017-01-31

Cache snap env var

319. By Ted Gould on 2017-01-31

Make sure we only use references in loops

320. By Ted Gould on 2017-01-31

Don't store if we have the variable

321. By Ted Gould on 2017-01-31

Return const pointer

322. By Ted Gould on 2017-01-31

Handle larger possible pids

323. By Ted Gould on 2017-01-31

Make sure we're gettin' data

324. By Ted Gould on 2017-01-31

Move debug outside of the print loop

325. By Ted Gould on 2017-02-01

A read failure is a helper failure

326. By Ted Gould on 2017-02-02

If we don't have a MIR_SOCKET use the default one

327. By Ted Gould on 2017-02-02

Special case legacy apps on Unity8 from debs

328. By Ted Gould on 2017-02-02

Put on the dunce cap and sit in the corner

Unmerged revisions

328. By Ted Gould on 2017-02-02

Put on the dunce cap and sit in the corner

327. By Ted Gould on 2017-02-02

Special case legacy apps on Unity8 from debs

326. By Ted Gould on 2017-02-02

If we don't have a MIR_SOCKET use the default one

325. By Ted Gould on 2017-02-01

A read failure is a helper failure

324. By Ted Gould on 2017-01-31

Move debug outside of the print loop

323. By Ted Gould on 2017-01-31

Make sure we're gettin' data

322. By Ted Gould on 2017-01-31

Handle larger possible pids

321. By Ted Gould on 2017-01-31

Return const pointer

320. By Ted Gould on 2017-01-31

Don't store if we have the variable

319. By Ted Gould on 2017-01-31

Make sure we only use references in loops

=== modified file 'docs/index.rst'
--- docs/index.rst	2016-08-04 14:04:40 +0000
+++ docs/index.rst	2016-11-01 14:53:56 +0000
@@ -18,6 +18,47 @@
 
 .. _Upstart: http://upstart.ubuntu.com/
 
+
+Environment Variables
+=====================
+
+There are a few environment variables that can effect the behavior of UAL while
+it is running.
+
+UBUNTU_APP_LAUNCH_CG_MANAGER_NAME
+  The DBus name that CG Manager registers under if it is on the session bus.
+
+UBUNTU_APP_LAUNCH_CG_MANAGER_SESSION_BUS
+  Tell UAL to look on the session bus for CG Manager.
+
+UBUNTU_APP_LAUNCH_DEMANGLER
+  Path to the UAL demangler tool that will get the Mir FD for trusted prompt session.
+
+UBUNTU_APP_LAUNCH_DISABLE_SNAPD_TIMEOUT
+  Wait as long as Snapd wants to return data instead of erroring after 100ms.
+
+UBUNTU_APP_LAUNCH_LEGACY_ROOT
+  Set the path that represents the root for legacy applications.
+
+UBUNTU_APP_LAUNCH_LIBERTINE_LAUNCH
+  Path to the libertine launch utility for setting up libertine containers and XMir based legacy apps.
+
+UBUNTU_APP_LAUNCH_LINK_FARM
+  Path to the link farm that is created by Click of all the installed Click applications.
+
+UBUNTU_APP_LAUNCH_OOM_HELPER
+  Path to the setuid helper that configures OOM values on application processes that we otherwise couldn't, mostly this is for Oxide.
+
+UBUNTU_APP_LAUNCH_OOM_PROC_PATH
+  Path to look for the files to set OOM values, defaults to /proc.
+
+UBUNTU_APP_LAUNCH_SNAP_BASEDIR
+  The place where snaps are installed in the system, /snap is the default.
+
+UBUNTU_APP_LAUNCH_SNAPD_SOCKET
+  Path to the snapd socket.
+
+
 API Documentation
 =================
 
@@ -146,6 +187,46 @@
    :private-members:
    :undoc-members:
 
+Jobs Manager Base
+-----------------
+
+.. doxygenclass:: ubuntu::app_launch::jobs::manager::Base
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Jobs Instance Base
+------------------
+
+.. doxygenclass:: ubuntu::app_launch::jobs::instance::Base
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Jobs Manager Upstart
+--------------------
+
+.. doxygenclass:: ubuntu::app_launch::jobs::manager::Upstart
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Jobs Instance Upstart
+---------------------
+
+.. doxygenclass:: ubuntu::app_launch::jobs::instance::Upstart
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
 Registry Implementation
 -----------------------
 
@@ -176,16 +257,6 @@
    :private-members:
    :undoc-members:
 
-Upstart Instance
-----------------
-
-.. doxygenclass:: ubuntu::app_launch::app_impls::UpstartInstance
-   :project: libubuntu-app-launch
-   :members:
-   :protected-members:
-   :private-members:
-   :undoc-members:
-
 Quality
 =======
 
 
=== modified file 'libubuntu-app-launch/CMakeLists.txt'
--- libubuntu-app-launch/CMakeLists.txt	2016-08-26 17:33:34 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2016-11-01 14:53:56 +0000
@@ -17,6 +17,8 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wpedantic")
 add_definitions ( -DOOM_HELPER="${pkglibexecdir}/oom-adjust-setuid-helper" -DDEMANGLER_PATH="${pkglibexecdir}/socket-demangler" )
 add_definitions ( -DLIBERTINE_LAUNCH="${CMAKE_INSTALL_FULL_BINDIR}/libertine-launch" )
+add_definitions ( -DG_LOG_DOMAIN="ubuntu-app-launch" )
+add_definitions ( -DUBUNTU_APP_LAUNCH_ARCH="${UBUNTU_APP_LAUNCH_ARCH}" )
 
 set(LAUNCHER_HEADERS
 ubuntu-app-launch.h
@@ -52,6 +54,12 @@
 helper-impl-click.cpp
 glib-thread.h
 glib-thread.cpp
+jobs-base.h
+jobs-base.cpp
+jobs-systemd.h
+jobs-systemd.cpp
+jobs-upstart.h
+jobs-upstart.cpp
 )
 
 set(LAUNCHER_SOURCES
 
=== modified file 'libubuntu-app-launch/application-impl-base.cpp'
--- libubuntu-app-launch/application-impl-base.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-base.cpp	2016-11-01 14:53:56 +0000
@@ -23,8 +23,6 @@
 #include <map>
 #include <numeric>
 
-#include <upstart.h>
-
 #include "application-impl-base.h"
 #include "helpers.h"
 #include "registry-impl.h"
@@ -97,768 +95,24 @@
     return retval;
 }
 
-/** Checks to see if we have a primary PID for the instance */
-bool UpstartInstance::isRunning()
-{
-    return primaryPid() != 0;
-}
-
-/** Uses Upstart to get the primary PID of the instance using Upstart's
-    DBus interface */
-pid_t UpstartInstance::primaryPid()
-{
-    auto jobpath = registry_->impl->upstartJobPath(job_);
-    if (jobpath.empty())
-    {
-        g_debug("Unable to get a valid job path");
-        return 0;
-    }
-
-    return registry_->impl->thread.executeOnThread<pid_t>([this, &jobpath]() -> pid_t {
-        GError* error = nullptr;
-
-        std::string instancename = std::string(appId_);
-        if (job_ != "application-click")
-        {
-            instancename += "-" + instance_;
-        }
-
-        g_debug("Getting instance by name: %s", instance_.c_str());
-        GVariant* vinstance_path =
-            g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                   /* connection */
-                                        DBUS_SERVICE_UPSTART,                           /* service */
-                                        jobpath.c_str(),                                /* object path */
-                                        DBUS_INTERFACE_UPSTART_JOB,                     /* iface */
-                                        "GetInstanceByName",                            /* method */
-                                        g_variant_new("(s)", instancename.c_str()),     /* params */
-                                        G_VARIANT_TYPE("(o)"),                          /* return type */
-                                        G_DBUS_CALL_FLAGS_NONE,                         /* flags */
-                                        -1,                                             /* timeout: default */
-                                        registry_->impl->thread.getCancellable().get(), /* cancellable */
-                                        &error);
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to get instance '%s' of job '%s': %s", instance_.c_str(), job_.c_str(), error->message);
-            g_error_free(error);
-            return 0;
-        }
-
-        /* Jump rope to make this into a C++ type */
-        std::string instance_path;
-        gchar* cinstance_path = nullptr;
-        g_variant_get(vinstance_path, "(o)", &cinstance_path);
-        g_variant_unref(vinstance_path);
-        if (cinstance_path != nullptr)
-        {
-            instance_path = cinstance_path;
-            g_free(cinstance_path);
-        }
-
-        if (instance_path.empty())
-        {
-            g_debug("No instance object for instance name: %s", instance_.c_str());
-            return 0;
-        }
-
-        GVariant* props_tuple =
-            g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                          /* connection */
-                                        DBUS_SERVICE_UPSTART,                                  /* service */
-                                        instance_path.c_str(),                                 /* object path */
-                                        "org.freedesktop.DBus.Properties",                     /* interface */
-                                        "GetAll",                                              /* method */
-                                        g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE), /* params */
-                                        G_VARIANT_TYPE("(a{sv})"),                             /* return type */
-                                        G_DBUS_CALL_FLAGS_NONE,                                /* flags */
-                                        -1,                                                    /* timeout: default */
-                                        registry_->impl->thread.getCancellable().get(),        /* cancellable */
-                                        &error);
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to name of properties '%s': %s", instance_path.c_str(), error->message);
-            g_error_free(error);
-            error = nullptr;
-            return 0;
-        }
-
-        GVariant* props_dict = g_variant_get_child_value(props_tuple, 0);
-
-        pid_t retval = 0;
-        GVariant* processes = g_variant_lookup_value(props_dict, "processes", G_VARIANT_TYPE("a(si)"));
-        if (processes != nullptr && g_variant_n_children(processes) > 0)
-        {
-
-            GVariant* first_entry = g_variant_get_child_value(processes, 0);
-            GVariant* pidv = g_variant_get_child_value(first_entry, 1);
-
-            retval = g_variant_get_int32(pidv);
-
-            g_variant_unref(pidv);
-            g_variant_unref(first_entry);
-        }
-        else
-        {
-            g_debug("Unable to get 'processes' from properties of instance at path: %s", instance_path.c_str());
-        }
-
-        g_variant_unref(props_dict);
-
-        return retval;
-    });
-}
-
-/** Generate the full name of the Upstart job for the job, the
-    instance and how all those fit together.
-
-    Handles the special case of application-click which isn't designed
-    to have multi-instance apps.
-*/
-std::string UpstartInstance::upstartJobPath()
-{
-    std::string path = job_ + "-" + std::string(appId_);
-    if (job_ != "application-click")
-    {
-        path += "-";
-    }
-    if (!instance_.empty())
-    {
-        path += instance_;
-    }
-
-    return path;
-}
-
-/** Looks at the PIDs in the instance cgroup and checks to see if @pid
-    is in the set.
-
-    @param pid PID to look for
-*/
-bool UpstartInstance::hasPid(pid_t pid)
-{
-    for (auto testpid : registry_->impl->pidsFromCgroup(upstartJobPath()))
-        if (pid == testpid)
-            return true;
-    return false;
-}
-
-/** Gets the path to the log file for this instance */
-std::string UpstartInstance::logPath()
-{
-    std::string logfile = upstartJobPath() + ".log";
-
-    gchar* cpath = g_build_filename(g_get_user_cache_dir(), "upstart", logfile.c_str(), nullptr);
-    std::string path(cpath);
-    g_free(cpath);
-
-    return path;
-}
-
-/** Returns all the PIDs that are in the cgroup for this application */
-std::vector<pid_t> UpstartInstance::pids()
-{
-    auto pids = registry_->impl->pidsFromCgroup(upstartJobPath());
-    g_debug("Got %d PIDs for AppID '%s'", int(pids.size()), std::string(appId_).c_str());
-    return pids;
-}
-
-/** Pauses this application by sending SIGSTOP to all the PIDs in the
-    cgroup and tells Zeitgeist that we've left the application. */
-void UpstartInstance::pause()
-{
-    g_debug("Pausing application: %s", std::string(appId_).c_str());
-    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_LEAVE_EVENT);
-
-    auto pids = forAllPids([this](pid_t pid) {
-        auto oomval = oom::paused();
-        g_debug("Pausing PID: %d (%d)", pid, int(oomval));
-        signalToPid(pid, SIGSTOP);
-        oomValueToPid(pid, oomval);
-    });
-
-    pidListToDbus(pids, "ApplicationPaused");
-}
-
-/** Resumes this application by sending SIGCONT to all the PIDs in the
-    cgroup and tells Zeitgeist that we're accessing the application. */
-void UpstartInstance::resume()
-{
-    g_debug("Resuming application: %s", std::string(appId_).c_str());
-    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_ACCESS_EVENT);
-
-    auto pids = forAllPids([this](pid_t pid) {
-        auto oomval = oom::focused();
-        g_debug("Resuming PID: %d (%d)", pid, int(oomval));
-        signalToPid(pid, SIGCONT);
-        oomValueToPid(pid, oomval);
-    });
-
-    pidListToDbus(pids, "ApplicationResumed");
-}
-
-/** Stops this instance by asking Upstart to stop it. Upstart will then
-    send a SIGTERM and five seconds later start killing things. */
-void UpstartInstance::stop()
-{
-    if (!registry_->impl->thread.executeOnThread<bool>([this]() {
-
-            g_debug("Stopping job %s app_id %s instance_id %s", job_.c_str(), std::string(appId_).c_str(),
-                    instance_.c_str());
-
-            auto jobpath = registry_->impl->upstartJobPath(job_);
-            if (jobpath.empty())
-            {
-                throw new std::runtime_error("Unable to get job path for Upstart job '" + job_ + "'");
-            }
-
-            GVariantBuilder builder;
-            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
-            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
-
-            g_variant_builder_add_value(
-                &builder, g_variant_new_take_string(g_strdup_printf("APP_ID=%s", std::string(appId_).c_str())));
-
-            if (!instance_.empty())
-            {
-                g_variant_builder_add_value(
-                    &builder, g_variant_new_take_string(g_strdup_printf("INSTANCE_ID=%s", instance_.c_str())));
-            }
-
-            g_variant_builder_close(&builder);
-            g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE)); /* wait */
-
-            GError* error = nullptr;
-            GVariant* stop_variant =
-                g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                   /* Dbus */
-                                            DBUS_SERVICE_UPSTART,                           /* Upstart name */
-                                            jobpath.c_str(),                                /* path */
-                                            DBUS_INTERFACE_UPSTART_JOB,                     /* interface */
-                                            "Stop",                                         /* method */
-                                            g_variant_builder_end(&builder),                /* params */
-                                            nullptr,                                        /* return */
-                                            G_DBUS_CALL_FLAGS_NONE,                         /* flags */
-                                            -1,                                             /* timeout: default */
-                                            registry_->impl->thread.getCancellable().get(), /* cancellable */
-                                            &error);                                        /* error (hopefully not) */
-
-            g_clear_pointer(&stop_variant, g_variant_unref);
-
-            if (error != nullptr)
-            {
-                g_warning("Unable to stop job %s app_id %s instance_id %s: %s", job_.c_str(),
-                          std::string(appId_).c_str(), instance_.c_str(), error->message);
-                g_error_free(error);
-                return false;
-            }
-
-            return true;
-        }))
-    {
-        g_warning("Unable to stop Upstart instance");
-    }
-}
-
-/** Sets the OOM adjustment by getting the list of PIDs and writing
-    the value to each of their files in proc
-
-    \param score OOM Score to set
-*/
-void UpstartInstance::setOomAdjustment(const oom::Score score)
-{
-    forAllPids([this, &score](pid_t pid) { oomValueToPid(pid, score); });
-}
-
-/** Figures out the path to the primary PID of the application and
-    then reads its OOM adjustment file. */
-const oom::Score UpstartInstance::getOomAdjustment()
-{
-    auto pid = primaryPid();
-    if (pid == 0)
-    {
-        throw std::runtime_error("No PID for application: " + std::string(appId_));
-    }
-
-    auto path = pidToOomPath(pid);
-    GError* error = nullptr;
-    gchar* content = nullptr;
-
-    g_file_get_contents(path.c_str(), /* path */
-                        &content,     /* data */
-                        nullptr,      /* size */
-                        &error);      /* error */
-
-    if (error != nullptr)
-    {
-        auto serror = std::shared_ptr<GError>(error, g_error_free);
-        throw std::runtime_error("Unable to access OOM value for '" + std::string(appId_) + "' primary PID '" +
-                                 std::to_string(pid) + "' because: " + serror->message);
-    }
-
-    auto score = static_cast<oom::Score>(std::atoi(content));
-    g_free(content);
-    return score;
-}
-
-/** Go through the list of PIDs calling a function and handling
-    the issue with getting PIDs being a racey condition.
-
-    \param eachPid Function to run on each PID
-*/
-std::vector<pid_t> UpstartInstance::forAllPids(std::function<void(pid_t)> eachPid)
-{
-    std::set<pid_t> seenPids;
-    bool added = true;
-
-    while (added)
-    {
-        added = false;
-        auto pidlist = pids();
-        for (auto pid : pidlist)
-        {
-            if (seenPids.insert(pid).second)
-            {
-                eachPid(pid);
-                added = true;
-            }
-        }
-    }
-
-    return std::vector<pid_t>(seenPids.begin(), seenPids.end());
-}
-
-/** Sends a signal to a PID with a warning if we can't send it.
-    We could throw an exception, but we can't handle it usefully anyway
-
-    \param pid PID to send the signal to
-    \param signal signal to send
-*/
-void UpstartInstance::signalToPid(pid_t pid, int signal)
-{
-    if (-1 == kill(pid, signal))
-    {
-        /* While that didn't work, we still want to try as many as we can */
-        g_warning("Unable to send signal %d to pid %d", signal, pid);
-    }
-}
-
-/** Get the path to the PID's OOM adjust path, with allowing for an
-    override for testing using the environment variable
-    UBUNTU_APP_LAUNCH_OOM_PROC_PATH
-
-    \param pid PID to build path for
-*/
-std::string UpstartInstance::pidToOomPath(pid_t pid)
-{
-    static std::string procpath;
-    if (G_UNLIKELY(procpath.empty()))
-    {
-        /* Set by the test suite, probably not anyone else */
-        auto envvar = g_getenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH");
-        if (G_LIKELY(envvar == nullptr))
-            procpath = "/proc";
-        else
-            procpath = envvar;
-    }
-
-    gchar* gpath = g_build_filename(procpath.c_str(), std::to_string(pid).c_str(), "oom_score_adj", nullptr);
-    std::string path = gpath;
-    g_free(gpath);
-    return path;
-}
-
-/** Writes an OOM value to proc, assuming we have a string
-    in the outer loop
-
-    \param pid PID to change the OOM value of
-    \param oomvalue OOM value to set
-*/
-void UpstartInstance::oomValueToPid(pid_t pid, const oom::Score oomvalue)
-{
-    auto oomstr = std::to_string(static_cast<std::int32_t>(oomvalue));
-    auto path = pidToOomPath(pid);
-    FILE* adj = fopen(path.c_str(), "w");
-    int openerr = errno;
-
-    if (adj == nullptr)
-    {
-        switch (openerr)
-        {
-            case ENOENT:
-                /* ENOENT happens a fair amount because of races, so it's not
-                   worth printing a warning about */
-                return;
-            case EACCES:
-            {
-                /* We can get this error when trying to set the OOM value on
-                   Oxide renderers because they're started by the sandbox and
-                   don't have their adjustment value available for us to write.
-                   We have a helper to deal with this, but it's kinda expensive
-                   so we only use it when we have to. */
-                oomValueToPidHelper(pid, oomvalue);
-                return;
-            }
-            default:
-                g_warning("Unable to set OOM value for '%d' to '%s': %s", int(pid), oomstr.c_str(),
-                          std::strerror(openerr));
-                return;
-        }
-    }
-
-    size_t writesize = fwrite(oomstr.c_str(), 1, oomstr.size(), adj);
-    int writeerr = errno;
-    fclose(adj);
-
-    if (writesize == oomstr.size())
-        return;
-
-    if (writeerr != 0)
-        g_warning("Unable to set OOM value for '%d' to '%s': %s", int(pid), oomstr.c_str(), strerror(writeerr));
+/** Generates an instance string based on the clock if we're a multi-instance
+    application. */
+std::string Base::getInstance(const std::shared_ptr<app_info::Desktop>& desktop)
+{
+    if (!desktop)
+    {
+        g_warning("Invalid desktop file passed to getInstance");
+        return {};
+    }
+
+    if (desktop->singleInstance())
+    {
+        return {};
+    }
     else
-        /* No error, but yet, wrong size. Not sure, what could cause this. */
-        g_debug("Unable to set OOM value for '%d' to '%s': Wrote %d bytes", int(pid), oomstr.c_str(), int(writesize));
-}
-
-/** Use a setuid root helper for setting the oom value of
-    Chromium instances
-
-    \param pid PID to change the OOM value of
-    \param oomvalue OOM value to set
-*/
-void UpstartInstance::oomValueToPidHelper(pid_t pid, const oom::Score oomvalue)
-{
-    GError* error = nullptr;
-    std::string oomstr = std::to_string(static_cast<std::int32_t>(oomvalue));
-    std::string pidstr = std::to_string(pid);
-    std::array<const char*, 4> args = {OOM_HELPER, pidstr.c_str(), oomstr.c_str(), nullptr};
-
-    g_debug("Excuting OOM Helper (pid: %d, score: %d): %s", int(pid), int(oomvalue),
-            std::accumulate(args.begin(), args.end(), std::string{},
-                            [](const std::string& instr, const char* output) -> std::string {
-                                if (instr.empty())
-                                {
-                                    return output;
-                                }
-                                else if (output != nullptr)
-                                {
-                                    return instr + " " + std::string(output);
-                                }
-                                else
-                                {
-                                    return instr;
-                                }
-                            })
-                .c_str());
-
-    g_spawn_async(nullptr,               /* working dir */
-                  (char**)(args.data()), /* args */
-                  nullptr,               /* env */
-                  G_SPAWN_DEFAULT,       /* flags */
-                  nullptr,               /* child setup */
-                  nullptr,               /* child setup userdata*/
-                  nullptr,               /* pid */
-                  &error);               /* error */
-
-    if (error != nullptr)
-    {
-        g_warning("Unable to launch OOM helper '" OOM_HELPER "' on PID '%d': %s", pid, error->message);
-        g_error_free(error);
-        return;
-    }
-}
-
-/** Send a signal that we've change the application. Do this on the
-    registry thread in an idle so that we don't block anyone.
-
-    \param pids List of PIDs to turn into variants to send
-    \param signal Name of the DBus signal to send
-*/
-void UpstartInstance::pidListToDbus(const std::vector<pid_t>& pids, const std::string& signal)
-{
-    auto registry = registry_;
-    auto lappid = appId_;
-
-    registry_->impl->thread.executeOnThread([registry, lappid, pids, signal] {
-        auto vpids = std::shared_ptr<GVariant>(
-            [pids]() {
-                GVariant* pidarray = nullptr;
-
-                if (pids.empty())
-                {
-                    pidarray = g_variant_new_array(G_VARIANT_TYPE_UINT64, nullptr, 0);
-                    g_variant_ref_sink(pidarray);
-                    return pidarray;
-                }
-
-                GVariantBuilder builder;
-                g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
-                for (auto pid : pids)
-                {
-                    g_variant_builder_add_value(&builder, g_variant_new_uint64(pid));
-                }
-
-                pidarray = g_variant_builder_end(&builder);
-                g_variant_ref_sink(pidarray);
-                return pidarray;
-            }(),
-            [](GVariant* var) { g_variant_unref(var); });
-
-        GVariantBuilder params;
-        g_variant_builder_init(&params, G_VARIANT_TYPE_TUPLE);
-        g_variant_builder_add_value(&params, g_variant_new_string(std::string(lappid).c_str()));
-        g_variant_builder_add_value(&params, vpids.get());
-
-        GError* error = nullptr;
-        g_dbus_connection_emit_signal(registry->impl->_dbus.get(),     /* bus */
-                                      nullptr,                         /* destination */
-                                      "/",                             /* path */
-                                      "com.canonical.UbuntuAppLaunch", /* interface */
-                                      signal.c_str(),                  /* signal */
-                                      g_variant_builder_end(&params),  /* params, the same */
-                                      &error);                         /* error */
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to emit signal '%s' for appid '%s': %s", signal.c_str(), std::string(lappid).c_str(),
-                      error->message);
-            g_error_free(error);
-        }
-        else
-        {
-            g_debug("Emmitted '%s' to DBus", signal.c_str());
-        }
-    });
-}
-
-/** Create a new Upstart Instance object that can track the job and
-    get information about it.
-
-    \param appId Application ID
-    \param job Upstart job name
-    \param instance Upstart instance name
-    \param urls URLs sent to the application (only on launch today)
-    \param registry Registry of persistent connections to use
-*/
-UpstartInstance::UpstartInstance(const AppID& appId,
-                                 const std::string& job,
-                                 const std::string& instance,
-                                 const std::vector<Application::URL>& urls,
-                                 const std::shared_ptr<Registry>& registry)
-    : appId_(appId)
-    , job_(job)
-    , instance_(instance)
-    , urls_(urls)
-    , registry_(registry)
-{
-    g_debug("Creating a new UpstartInstance for '%s' instance '%s'", std::string(appId_).c_str(), instance.c_str());
-}
-
-/** Reformat a C++ vector of URLs into a C GStrv of strings
-
-    \param urls Vector of URLs to make into C strings
-*/
-std::shared_ptr<gchar*> UpstartInstance::urlsToStrv(const std::vector<Application::URL>& urls)
-{
-    if (urls.empty())
-    {
-        return {};
-    }
-
-    auto array = g_array_new(TRUE, FALSE, sizeof(gchar*));
-
-    for (auto url : urls)
-    {
-        auto str = g_strdup(url.value().c_str());
-        g_debug("Converting URL: %s", str);
-        g_array_append_val(array, str);
-    }
-
-    return std::shared_ptr<gchar*>((gchar**)g_array_free(array, FALSE), g_strfreev);
-}
-
-/** Small helper that we can new/delete to work better with C stuff */
-struct StartCHelper
-{
-    std::shared_ptr<UpstartInstance> ptr;
-};
-
-/** Callback from starting an application. It checks to see whether the
-    app is already running. If it is already running then we need to send
-    the URLs to it via DBus.
-
-    \param obj The GDBusConnection object
-    \param res Async result object
-    \param user_data A pointer to a StartCHelper structure
-*/
-void UpstartInstance::application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data)
-{
-    auto data = static_cast<StartCHelper*>(user_data);
-    GError* error{nullptr};
-    GVariant* result{nullptr};
-
-    tracepoint(ubuntu_app_launch, libual_start_message_callback, std::string(data->ptr->appId_).c_str());
-
-    g_debug("Started Message Callback: %s", std::string(data->ptr->appId_).c_str());
-
-    result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(obj), res, &error);
-
-    g_clear_pointer(&result, g_variant_unref);
-
-    if (error != nullptr)
-    {
-        if (g_dbus_error_is_remote_error(error))
-        {
-            gchar* remote_error = g_dbus_error_get_remote_error(error);
-            g_debug("Remote error: %s", remote_error);
-            if (g_strcmp0(remote_error, "com.ubuntu.Upstart0_6.Error.AlreadyStarted") == 0)
-            {
-                auto urls = urlsToStrv(data->ptr->urls_);
-                second_exec(data->ptr->registry_->impl->_dbus.get(),                   /* DBus */
-                            data->ptr->registry_->impl->thread.getCancellable().get(), /* cancellable */
-                            data->ptr->primaryPid(),                                   /* primary pid */
-                            std::string(data->ptr->appId_).c_str(),                    /* appid */
-                            urls.get());                                               /* urls */
-            }
-
-            g_free(remote_error);
-        }
-        else
-        {
-            g_warning("Unable to emit event to start application: %s", error->message);
-        }
-        g_error_free(error);
-    }
-
-    delete data;
-}
-
-/** Launch an application and create a new UpstartInstance object to track
-    its progress.
-
-    \param appId Application ID
-    \param job Upstart job name
-    \param instance Upstart instance name
-    \param urls URLs sent to the application (only on launch today)
-    \param registry Registry of persistent connections to use
-    \param mode Whether or not to setup the environment for testing
-    \param getenv A function to get additional environment variable when appropriate
-*/
-std::shared_ptr<UpstartInstance> UpstartInstance::launch(
-    const AppID& appId,
-    const std::string& job,
-    const std::string& instance,
-    const std::vector<Application::URL>& urls,
-    const std::shared_ptr<Registry>& registry,
-    launchMode mode,
-    std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv)
-{
-    if (appId.empty())
-        return {};
-
-    return registry->impl->thread.executeOnThread<std::shared_ptr<UpstartInstance>>(
-        [&]() -> std::shared_ptr<UpstartInstance> {
-            std::string appIdStr{appId};
-            g_debug("Initializing params for an new UpstartInstance for: %s", appIdStr.c_str());
-
-            tracepoint(ubuntu_app_launch, libual_start, appIdStr.c_str());
-
-            int timeout = 1;
-            if (ubuntu::app_launch::Registry::Impl::isWatchingAppStarting())
-            {
-                timeout = 0;
-            }
-
-            auto handshake = starting_handshake_start(appIdStr.c_str(), timeout);
-            if (handshake == nullptr)
-            {
-                g_warning("Unable to setup starting handshake");
-            }
-
-            /* Figure out the DBus path for the job */
-            auto jobpath = registry->impl->upstartJobPath(job);
-
-            /* Build up our environment */
-            auto env = getenv();
-
-            env.emplace_back(std::make_pair("APP_ID", appIdStr));                           /* Application ID */
-            env.emplace_back(std::make_pair("APP_LAUNCHER_PID", std::to_string(getpid()))); /* Who we are, for bugs */
-
-            if (!urls.empty())
-            {
-                auto accumfunc = [](const std::string& prev, Application::URL thisurl) -> std::string {
-                    gchar* gescaped = g_shell_quote(thisurl.value().c_str());
-                    std::string escaped;
-                    if (gescaped != nullptr)
-                    {
-                        escaped = gescaped;
-                        g_free(gescaped);
-                    }
-                    else
-                    {
-                        g_warning("Unable to escape URL: %s", thisurl.value().c_str());
-                        return prev;
-                    }
-
-                    if (prev.empty())
-                    {
-                        return escaped;
-                    }
-                    else
-                    {
-                        return prev + " " + escaped;
-                    }
-                };
-                auto urlstring = std::accumulate(urls.begin(), urls.end(), std::string{}, accumfunc);
-                env.emplace_back(std::make_pair("APP_URIS", urlstring));
-            }
-
-            if (mode == launchMode::TEST)
-            {
-                env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
-            }
-
-            /* Convert to GVariant */
-            GVariantBuilder builder;
-            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
-
-            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
-
-            for (const auto& envvar : env)
-            {
-                g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf(
-                                                          "%s=%s", envvar.first.c_str(), envvar.second.c_str())));
-            }
-
-            g_variant_builder_close(&builder);
-            g_variant_builder_add_value(&builder, g_variant_new_boolean(TRUE));
-
-            auto retval = std::make_shared<UpstartInstance>(appId, job, instance, urls, registry);
-            auto chelper = new StartCHelper{};
-            chelper->ptr = retval;
-
-            tracepoint(ubuntu_app_launch, handshake_wait, appIdStr.c_str());
-            starting_handshake_wait(handshake);
-            tracepoint(ubuntu_app_launch, handshake_complete, appIdStr.c_str());
-
-            /* Call the job start function */
-            g_debug("Asking Upstart to start task for: %s", appIdStr.c_str());
-            g_dbus_connection_call(registry->impl->_dbus.get(),                   /* bus */
-                                   DBUS_SERVICE_UPSTART,                          /* service name */
-                                   jobpath.c_str(),                               /* Path */
-                                   DBUS_INTERFACE_UPSTART_JOB,                    /* interface */
-                                   "Start",                                       /* method */
-                                   g_variant_builder_end(&builder),               /* params */
-                                   nullptr,                                       /* return */
-                                   G_DBUS_CALL_FLAGS_NONE,                        /* flags */
-                                   -1,                                            /* default timeout */
-                                   registry->impl->thread.getCancellable().get(), /* cancellable */
-                                   application_start_cb,                          /* callback */
-                                   chelper                                        /* object */
-                                   );
-
-            tracepoint(ubuntu_app_launch, libual_start_message_sent, appIdStr.c_str());
-
-            return retval;
-        });
+    {
+        return std::to_string(g_get_real_time());
+    }
 }
 
 }  // namespace app_impls
 
=== modified file 'libubuntu-app-launch/application-impl-base.h'
--- libubuntu-app-launch/application-impl-base.h	2016-09-23 22:30:51 +0000
+++ libubuntu-app-launch/application-impl-base.h	2016-11-01 14:53:56 +0000
@@ -17,6 +17,7 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "application-info-desktop.h"
 #include "application.h"
 
 extern "C" {
@@ -43,6 +44,8 @@
 
     bool hasInstances() override;
 
+    std::string getInstance(const std::shared_ptr<app_info::Desktop>& desktop);
+
 protected:
     /** Pointer to the registry so we can ask it for things */
     std::shared_ptr<Registry> _registry;
@@ -51,75 +54,6 @@
                                                                       const std::string& pkgdir);
 };
 
-/** An object that represents an instance of a job on Upstart. This
-    then implements everything needed by the instance interface. Most
-    applications tie into this today and use it as the backend for
-    their instances. */
-class UpstartInstance : public Application::Instance
-{
-public:
-    explicit UpstartInstance(const AppID& appId,
-                             const std::string& job,
-                             const std::string& instance,
-                             const std::vector<Application::URL>& urls,
-                             const std::shared_ptr<Registry>& registry);
-
-    /* Query lifecycle */
-    bool isRunning() override;
-    pid_t primaryPid() override;
-    bool hasPid(pid_t pid) override;
-    std::string logPath() override;
-    std::vector<pid_t> pids() override;
-
-    /* Manage lifecycle */
-    void pause() override;
-    void resume() override;
-    void stop() override;
-
-    /* OOM Functions */
-    void setOomAdjustment(const oom::Score score) override;
-    const oom::Score getOomAdjustment() override;
-
-    /** Flag for whether we should include the testing environment variables */
-    enum class launchMode
-    {
-        STANDARD, /**< Standard variable set */
-        TEST      /**< Include testing environment vars */
-    };
-    static std::shared_ptr<UpstartInstance> launch(
-        const AppID& appId,
-        const std::string& job,
-        const std::string& instance,
-        const std::vector<Application::URL>& urls,
-        const std::shared_ptr<Registry>& registry,
-        launchMode mode,
-        std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv);
-
-private:
-    /** Application ID */
-    const AppID appId_;
-    /** Upstart job name */
-    const std::string job_;
-    /** Instance ID environment value, empty if none */
-    const std::string instance_;
-    /** The URLs that this was launched for. Only valid on launched jobs, we
-        should look at perhaps changing that. */
-    std::vector<Application::URL> urls_;
-    /** A link to the registry we're using for connections */
-    std::shared_ptr<Registry> registry_;
-
-    std::vector<pid_t> forAllPids(std::function<void(pid_t)> eachPid);
-    void signalToPid(pid_t pid, int signal);
-    std::string pidToOomPath(pid_t pid);
-    void oomValueToPid(pid_t pid, const oom::Score oomvalue);
-    void oomValueToPidHelper(pid_t pid, const oom::Score oomvalue);
-    void pidListToDbus(const std::vector<pid_t>& pids, const std::string& signal);
-    std::string upstartJobPath();
-
-    static std::shared_ptr<gchar*> urlsToStrv(const std::vector<Application::URL>& urls);
-    static void application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data);
-};
-
 }  // namespace app_impls
 }  // namespace app_launch
 }  // namespace ubuntu
 
=== modified file 'libubuntu-app-launch/application-impl-click.cpp'
--- libubuntu-app-launch/application-impl-click.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-click.cpp	2016-11-01 14:53:56 +0000
@@ -51,6 +51,8 @@
     std::tie(_keyfile, desktopPath_) = manifestAppDesktop(_manifest, appid.package, appid.appname, _clickDir);
     if (!_keyfile)
         throw std::runtime_error{"No keyfile found for click application: " + std::string(appid)};
+
+    g_debug("Application Click object for appid '%s'", std::string(appid).c_str());
 }
 
 AppID Click::appId()
@@ -323,21 +325,8 @@
 
 std::vector<std::shared_ptr<Application::Instance>> Click::instances()
 {
-    std::vector<std::shared_ptr<Instance>> vect;
-    std::string sappid = appId();
-
-    for (auto instancename : _registry->impl->upstartInstancesForJob("application-click"))
-    {
-        /* There an be only one, but we want to make sure it is
-           there or return an empty vector */
-        if (sappid == instancename)
-        {
-            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-click", std::string{},
-                                                                std::vector<Application::URL>{}, _registry));
-            break;
-        }
-    }
-    return vect;
+    auto vbase = _registry->impl->jobs->instances(appId(), "application-click");
+    return std::vector<std::shared_ptr<Application::Instance>>(vbase.begin(), vbase.end());
 }
 
 /** Grabs all the environment variables for the application to
@@ -350,26 +339,30 @@
     retval.emplace_back(std::make_pair("APP_DIR", _clickDir));
     retval.emplace_back(std::make_pair("APP_DESKTOP_FILE_PATH", desktopPath_));
 
+    retval.emplace_back(std::make_pair("QML2_IMPORT_PATH", _clickDir + "/lib/" + UBUNTU_APP_LAUNCH_ARCH + "/qml"));
+
     info();
 
     retval.emplace_back(std::make_pair("APP_XMIR_ENABLE", _info->xMirEnable().value() ? "1" : "0"));
     retval.emplace_back(std::make_pair("APP_EXEC", _info->execLine().value()));
 
+    retval.emplace_back(std::make_pair("APP_EXEC_POLICY", std::string(appId())));
+
     return retval;
 }
 
 std::shared_ptr<Application::Instance> Click::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-click", {}, urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-click", {}, urls, jobs::manager::launchMode::STANDARD,
+                                         envfunc);
 }
 
 std::shared_ptr<Application::Instance> Click::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-click", {}, urls, _registry, UpstartInstance::launchMode::TEST,
-                                   envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-click", {}, urls, jobs::manager::launchMode::TEST,
+                                         envfunc);
 }
 
 }  // namespace app_impls
 
=== modified file 'libubuntu-app-launch/application-impl-legacy.cpp'
--- libubuntu-app-launch/application-impl-legacy.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-legacy.cpp	2016-11-01 14:53:56 +0000
@@ -33,9 +33,6 @@
 /** 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"};
-/** Special characters that could be an application name that
-    would activate in a regex */
-const static std::regex regexCharacters("([\\.\\-])");
 
 /***********************************
    Prototypes
@@ -78,13 +75,7 @@
         throw std::runtime_error{"Looking like a legacy app, but should be a Snap: " + appname.value()};
     }
 
-    /* Build a regex that'll match instances of the applications which
-       roughly looks like: $(appid)-2345345
-
-       It is important to filter out the special characters that are in
-       the appid.
-    */
-    instanceRegex_ = std::regex("^(?:" + std::regex_replace(_appname.value(), regexCharacters, "\\$&") + ")\\-(\\d*)$");
+    g_debug("Application Legacy object for app '%s'", appname.value().c_str());
 }
 
 std::tuple<std::string, std::shared_ptr<GKeyFile>, std::string> keyfileForApp(const AppID::AppName& name)
@@ -291,23 +282,8 @@
 
 std::vector<std::shared_ptr<Application::Instance>> Legacy::instances()
 {
-    std::vector<std::shared_ptr<Instance>> vect;
-    auto startsWith = std::string(appId()) + "-";
-
-    for (auto instance : _registry->impl->upstartInstancesForJob("application-legacy"))
-    {
-        std::smatch instanceMatch;
-        g_debug("Looking at legacy instance: %s", instance.c_str());
-        if (std::regex_match(instance, instanceMatch, instanceRegex_))
-        {
-            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-legacy", instanceMatch[1].str(),
-                                                                std::vector<Application::URL>{}, _registry));
-        }
-    }
-
-    g_debug("Legacy app '%s' has %d instances", std::string(appId()).c_str(), int(vect.size()));
-
-    return vect;
+    auto vbase = _registry->impl->jobs->instances(appId(), "application-legacy");
+    return std::vector<std::shared_ptr<Application::Instance>>(vbase.begin(), vbase.end());
 }
 
 /** Grabs all the environment for a legacy app. Mostly this consists of
@@ -368,21 +344,6 @@
     return retval;
 }
 
-/** Generates an instance string based on the clock if we're a multi-instance
-    application. */
-std::string Legacy::getInstance()
-{
-    auto single = g_key_file_get_boolean(_keyfile.get(), "Desktop Entry", "X-Ubuntu-Single-Instance", nullptr);
-    if (single)
-    {
-        return {};
-    }
-    else
-    {
-        return std::to_string(g_get_real_time());
-    }
-}
-
 /** Create an UpstartInstance for this AppID using the UpstartInstance launch
     function.
 
@@ -390,12 +351,12 @@
 */
 std::shared_ptr<Application::Instance> Legacy::launch(const std::vector<Application::URL>& urls)
 {
-    std::string instance = getInstance();
+    auto instance = getInstance(appinfo_);
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this, instance]() {
         return launchEnv(instance);
     };
-    return UpstartInstance::launch(appId(), "application-legacy", instance, urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-legacy", instance, urls,
+                                         jobs::manager::launchMode::STANDARD, envfunc);
 }
 
 /** Create an UpstartInstance for this AppID using the UpstartInstance launch
@@ -405,12 +366,12 @@
 */
 std::shared_ptr<Application::Instance> Legacy::launchTest(const std::vector<Application::URL>& urls)
 {
-    std::string instance = getInstance();
+    auto instance = getInstance(appinfo_);
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this, instance]() {
         return launchEnv(instance);
     };
-    return UpstartInstance::launch(appId(), "application-legacy", instance, urls, _registry,
-                                   UpstartInstance::launchMode::TEST, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-legacy", instance, urls, jobs::manager::launchMode::TEST,
+                                         envfunc);
 }
 
 }  // namespace app_impls
 
=== modified file 'libubuntu-app-launch/application-impl-legacy.h'
--- libubuntu-app-launch/application-impl-legacy.h	2016-09-23 21:54:33 +0000
+++ libubuntu-app-launch/application-impl-legacy.h	2016-11-01 14:53:56 +0000
@@ -86,7 +86,6 @@
     std::regex instanceRegex_;
 
     std::list<std::pair<std::string, std::string>> launchEnv(const std::string& instance);
-    std::string getInstance();
 };
 
 }  // namespace app_impls
 
=== modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
--- libubuntu-app-launch/application-impl-libertine.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2016-11-01 14:53:56 +0000
@@ -65,6 +65,12 @@
     if (!_keyfile)
         throw std::runtime_error{"Unable to find a keyfile for application '" + appname.value() + "' in container '" +
                                  container.value() + "'"};
+
+    appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, _container_path,
+                                                   app_info::DesktopFlags::XMIR_DEFAULT, _registry);
+
+    g_debug("Application Libertine object for container '%s' app '%s'", container.value().c_str(),
+            appname.value().c_str());
 }
 
 std::shared_ptr<GKeyFile> Libertine::keyfileFromPath(const std::string& pathname)
@@ -255,8 +261,7 @@
             }
             catch (std::runtime_error& e)
             {
-                g_debug("Unable to create application for libertine appname '%s': %s",
-                        apps.get()[j], e.what());
+                g_debug("Unable to create application for libertine appname '%s': %s", apps.get()[j], e.what());
             }
         }
     }
@@ -266,27 +271,13 @@
 
 std::shared_ptr<Application::Info> Libertine::info()
 {
-    if (!appinfo_)
-    {
-        appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, _container_path,
-                                                       app_info::DesktopFlags::XMIR_DEFAULT, _registry);
-    }
     return appinfo_;
 }
 
 std::vector<std::shared_ptr<Application::Instance>> Libertine::instances()
 {
-    std::vector<std::shared_ptr<Instance>> vect;
-    std::string sappid = appId();
-
-    for (auto instancename : _registry->impl->upstartInstancesForJob("application-legacy"))
-    {
-        if (std::equal(sappid.begin(), sappid.end(), instancename.begin()))
-            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-legacy", std::string{},
-                                                                std::vector<Application::URL>{}, _registry));
-    }
-
-    return vect;
+    auto vbase = _registry->impl->jobs->instances(appId(), "application-legacy");
+    return std::vector<std::shared_ptr<Application::Instance>>(vbase.begin(), vbase.end());
 }
 
 /** Grabs all the environment variables for the application to
@@ -327,16 +318,18 @@
 
 std::shared_ptr<Application::Instance> Libertine::launch(const std::vector<Application::URL>& urls)
 {
+    auto instance = getInstance(appinfo_);
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appId(), "application-legacy", {}, urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-legacy", instance, urls,
+                                         jobs::manager::launchMode::STANDARD, envfunc);
 }
 
 std::shared_ptr<Application::Instance> Libertine::launchTest(const std::vector<Application::URL>& urls)
 {
+    auto instance = getInstance(appinfo_);
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appId(), "application-legacy", {}, urls, _registry,
-                                   UpstartInstance::launchMode::TEST, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-legacy", instance, urls, jobs::manager::launchMode::TEST,
+                                         envfunc);
 }
 
 }  // namespace app_impls
 
=== modified file 'libubuntu-app-launch/application-impl-snap.cpp'
--- libubuntu-app-launch/application-impl-snap.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-snap.cpp	2016-11-01 14:53:56 +0000
@@ -196,6 +196,8 @@
     }
 
     info_ = std::make_shared<SnapInfo>(appid_, _registry, interface_, pkgInfo_->directory);
+
+    g_debug("Application Snap object for AppID '%s'", std::string(appid).c_str());
 }
 
 /** Uses the findInterface() function to find the interface if we don't
@@ -229,7 +231,7 @@
             }
             catch (std::runtime_error& e)
             {
-                g_warning("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
+                g_debug("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
             }
         }
     }
@@ -396,19 +398,8 @@
 /** 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", std::string{},
-                                                                std::vector<Application::URL>{}, _registry));
-        }
-    }
-
-    return vect;
+    auto vbase = _registry->impl->jobs->instances(appId(), "application-snap");
+    return std::vector<std::shared_ptr<Application::Instance>>(vbase.begin(), vbase.end());
 }
 
 /** Return the launch environment for this snap. That includes whether
@@ -447,9 +438,10 @@
 */
 std::shared_ptr<Application::Instance> Snap::launch(const std::vector<Application::URL>& urls)
 {
+    auto instance = getInstance(info_);
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appid_, "application-snap", {}, urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD, envfunc);
+    return _registry->impl->jobs->launch(appid_, "application-snap", instance, urls,
+                                         jobs::manager::launchMode::STANDARD, envfunc);
 }
 
 /** Create a new instance of this Snap with a testing environment
@@ -459,9 +451,10 @@
 */
 std::shared_ptr<Application::Instance> Snap::launchTest(const std::vector<Application::URL>& urls)
 {
+    auto instance = getInstance(info_);
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appid_, "application-snap", {}, urls, _registry, UpstartInstance::launchMode::TEST,
-                                   envfunc);
+    return _registry->impl->jobs->launch(appid_, "application-snap", instance, urls, jobs::manager::launchMode::TEST,
+                                         envfunc);
 }
 
 }  // namespace app_impls
 
=== modified file 'libubuntu-app-launch/application-info-desktop.cpp'
--- libubuntu-app-launch/application-info-desktop.cpp	2016-09-14 16:42:20 +0000
+++ libubuntu-app-launch/application-info-desktop.cpp	2016-11-01 14:53:56 +0000
@@ -253,7 +253,7 @@
             if (stringlistFromKeyfileContains(keyfile, "NotShowIn", xdg_current_desktop, false) ||
                 !stringlistFromKeyfileContains(keyfile, "OnlyShowIn", xdg_current_desktop, true))
             {
-                g_warning("Application is not shown in Unity");
+                g_debug("Application is not shown in current desktop: %s", xdg_current_desktop);
                 // Exception removed for OTA11 as a temporary fix
                 // throw std::runtime_error("Application is not shown in Unity");
             }
@@ -352,6 +352,7 @@
     , _xMirEnable(
           boolFromKeyfile<XMirEnable>(keyfile, "X-Ubuntu-XMir-Enable", (flags & DesktopFlags::XMIR_DEFAULT).any()))
     , _exec(stringFromKeyfile<Exec>(keyfile, "Exec"))
+    , _singleInstance(boolFromKeyfile<SingleInstance>(keyfile, "X-Ubuntu-Single-Instance", false))
 {
 }
 
 
=== modified file 'libubuntu-app-launch/application-info-desktop.h'
--- libubuntu-app-launch/application-info-desktop.h	2016-09-14 16:38:42 +0000
+++ libubuntu-app-launch/application-info-desktop.h	2016-11-01 14:53:56 +0000
@@ -106,6 +106,13 @@
         return _exec;
     }
 
+    struct SingleInstanceTag;
+    typedef TypeTagger<SingleInstanceTag, bool> SingleInstance;
+    virtual SingleInstance singleInstance()
+    {
+        return _singleInstance;
+    }
+
 protected:
     std::shared_ptr<GKeyFile> _keyfile;
     std::string _basePath;
@@ -125,6 +132,7 @@
 
     XMirEnable _xMirEnable;
     Exec _exec;
+    SingleInstance _singleInstance;
 };
 
 }  // namespace AppInfo
 
=== modified file 'libubuntu-app-launch/application.cpp'
--- libubuntu-app-launch/application.cpp	2016-08-26 17:33:34 +0000
+++ libubuntu-app-launch/application.cpp	2016-11-01 14:53:56 +0000
@@ -28,6 +28,8 @@
 #include "application-impl-snap.h"
 #endif
 #include "application.h"
+#include "jobs-base.h"
+#include "registry-impl.h"
 #include "registry.h"
 
 #include <functional>
@@ -46,6 +48,11 @@
         throw std::runtime_error("AppID is empty");
     }
 
+    if (!registry->impl->jobs)
+    {
+        registry->impl->jobs = jobs::manager::Base::determineFactory(registry);
+    }
+
     if (app_impls::Click::hasAppId(appid, registry))
     {
         return std::make_shared<app_impls::Click>(appid, registry);
 
=== added file 'libubuntu-app-launch/jobs-base.cpp'
--- libubuntu-app-launch/jobs-base.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-base.cpp	2016-11-01 14:53:56 +0000
@@ -0,0 +1,434 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#include <algorithm>
+#include <cerrno>
+#include <cstring>
+
+#include "jobs-base.h"
+#include "jobs-systemd.h"
+#include "jobs-upstart.h"
+#include "registry-impl.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace manager
+{
+
+Base::Base(const std::shared_ptr<Registry>& registry)
+    : registry_(registry)
+    , allJobs_{"application-click", "application-legacy", "application-snap"}
+{
+}
+
+std::shared_ptr<Base> Base::determineFactory(std::shared_ptr<Registry> registry)
+{
+    /* Checking to see if we have a user bus, that is only started
+       by systemd so we're in good shape if we have one. We're using
+       the path instead of the RUNTIME variable because we want to work
+       around the case of being relocated by the snappy environment */
+    if (g_file_test(SystemD::userBusPath().c_str(), G_FILE_TEST_EXISTS))
+    {
+        return std::make_shared<jobs::manager::SystemD>(registry);
+    }
+    else
+    {
+        return std::make_shared<jobs::manager::Upstart>(registry);
+    }
+}
+
+const std::set<std::string>& Base::getAllJobs()
+{
+    return allJobs_;
+}
+
+}  // namespace manager
+
+namespace instance
+{
+
+Base::Base(const AppID& appId,
+           const std::string& job,
+           const std::string& instance,
+           const std::vector<Application::URL>& urls,
+           const std::shared_ptr<Registry>& registry)
+    : appId_(appId)
+    , job_(job)
+    , instance_(instance)
+    , urls_(urls)
+    , registry_(registry)
+{
+}
+
+/** Checks to see if we have a primary PID for the instance */
+bool Base::isRunning()
+{
+    return primaryPid() != 0;
+}
+
+/** Looks at the PIDs in the instance cgroup and checks to see if @pid
+    is in the set.
+
+    @param pid PID to look for
+*/
+bool Base::hasPid(pid_t pid)
+{
+    auto vpids = pids();
+    bool hasit = std::find(vpids.begin(), vpids.end(), pid) != vpids.end();
+    g_debug("Checking for PID %d on AppID '%s' result: %s", pid, std::string(appId_).c_str(), hasit ? "YES" : "NO");
+    return hasit;
+}
+
+/** Pauses this application by sending SIGSTOP to all the PIDs in the
+    cgroup and tells Zeitgeist that we've left the application. */
+void Base::pause()
+{
+    g_debug("Pausing application: %s", std::string(appId_).c_str());
+    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_LEAVE_EVENT);
+
+    auto pids = forAllPids([this](pid_t pid) {
+        auto oomval = oom::paused();
+        g_debug("Pausing PID: %d (%d)", pid, int(oomval));
+        signalToPid(pid, SIGSTOP);
+        oomValueToPid(pid, oomval);
+    });
+
+    pidListToDbus(pids, "ApplicationPaused");
+}
+
+/** Resumes this application by sending SIGCONT to all the PIDs in the
+    cgroup and tells Zeitgeist that we're accessing the application. */
+void Base::resume()
+{
+    g_debug("Resuming application: %s", std::string(appId_).c_str());
+    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_ACCESS_EVENT);
+
+    auto pids = forAllPids([this](pid_t pid) {
+        auto oomval = oom::focused();
+        g_debug("Resuming PID: %d (%d)", pid, int(oomval));
+        signalToPid(pid, SIGCONT);
+        oomValueToPid(pid, oomval);
+    });
+
+    pidListToDbus(pids, "ApplicationResumed");
+}
+
+/** Go through the list of PIDs calling a function and handling
+    the issue with getting PIDs being a racey condition.
+
+    \param eachPid Function to run on each PID
+*/
+std::vector<pid_t> Base::forAllPids(std::function<void(pid_t)> eachPid)
+{
+    std::set<pid_t> seenPids;
+    bool added = true;
+
+    while (added)
+    {
+        added = false;
+        auto pidlist = pids();
+        for (auto pid : pidlist)
+        {
+            if (seenPids.insert(pid).second)
+            {
+                eachPid(pid);
+                added = true;
+            }
+        }
+    }
+
+    return std::vector<pid_t>(seenPids.begin(), seenPids.end());
+}
+
+/** Send a signal that we've change the application. Do this on the
+    registry thread in an idle so that we don't block anyone.
+
+    \param pids List of PIDs to turn into variants to send
+    \param signal Name of the DBus signal to send
+*/
+void Base::pidListToDbus(const std::vector<pid_t>& pids, const std::string& signal)
+{
+    auto registry = registry_;
+    auto lappid = appId_;
+
+    registry_->impl->thread.executeOnThread([registry, lappid, pids, signal] {
+        auto vpids = std::shared_ptr<GVariant>(
+            [pids]() {
+                GVariant* pidarray = nullptr;
+
+                if (pids.empty())
+                {
+                    pidarray = g_variant_new_array(G_VARIANT_TYPE_UINT64, nullptr, 0);
+                    g_variant_ref_sink(pidarray);
+                    return pidarray;
+                }
+
+                GVariantBuilder builder;
+                g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
+                for (auto pid : pids)
+                {
+                    g_variant_builder_add_value(&builder, g_variant_new_uint64(pid));
+                }
+
+                pidarray = g_variant_builder_end(&builder);
+                g_variant_ref_sink(pidarray);
+                return pidarray;
+            }(),
+            [](GVariant* var) { g_variant_unref(var); });
+
+        GVariantBuilder params;
+        g_variant_builder_init(&params, G_VARIANT_TYPE_TUPLE);
+        g_variant_builder_add_value(&params, g_variant_new_string(std::string(lappid).c_str()));
+        g_variant_builder_add_value(&params, vpids.get());
+
+        GError* error = nullptr;
+        g_dbus_connection_emit_signal(registry->impl->_dbus.get(),     /* bus */
+                                      nullptr,                         /* destination */
+                                      "/",                             /* path */
+                                      "com.canonical.UbuntuAppLaunch", /* interface */
+                                      signal.c_str(),                  /* signal */
+                                      g_variant_builder_end(&params),  /* params, the same */
+                                      &error);                         /* error */
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to emit signal '%s' for appid '%s': %s", signal.c_str(), std::string(lappid).c_str(),
+                      error->message);
+            g_error_free(error);
+        }
+        else
+        {
+            g_debug("Emmitted '%s' to DBus", signal.c_str());
+        }
+    });
+}
+
+/** Sets the OOM adjustment by getting the list of PIDs and writing
+    the value to each of their files in proc
+
+    \param score OOM Score to set
+*/
+void Base::setOomAdjustment(const oom::Score score)
+{
+    forAllPids([this, &score](pid_t pid) { oomValueToPid(pid, score); });
+}
+
+/** Figures out the path to the primary PID of the application and
+    then reads its OOM adjustment file. */
+const oom::Score Base::getOomAdjustment()
+{
+    auto pid = primaryPid();
+    if (pid == 0)
+    {
+        throw std::runtime_error("No PID for application: " + std::string(appId_));
+    }
+
+    auto path = pidToOomPath(pid);
+    GError* error = nullptr;
+    gchar* content = nullptr;
+
+    g_file_get_contents(path.c_str(), /* path */
+                        &content,     /* data */
+                        nullptr,      /* size */
+                        &error);      /* error */
+
+    if (error != nullptr)
+    {
+        auto serror = std::shared_ptr<GError>(error, g_error_free);
+        throw std::runtime_error("Unable to access OOM value for '" + std::string(appId_) + "' primary PID '" +
+                                 std::to_string(pid) + "' because: " + serror->message);
+    }
+
+    auto score = static_cast<oom::Score>(std::atoi(content));
+    g_free(content);
+    return score;
+}
+
+/** Sends a signal to a PID with a warning if we can't send it.
+    We could throw an exception, but we can't handle it usefully anyway
+
+    \param pid PID to send the signal to
+    \param signal signal to send
+*/
+void Base::signalToPid(pid_t pid, int signal)
+{
+    if (-1 == kill(pid, signal))
+    {
+        /* While that didn't work, we still want to try as many as we can */
+        g_warning("Unable to send signal %d to pid %d", signal, pid);
+    }
+}
+
+/** Get the path to the PID's OOM adjust path, with allowing for an
+    override for testing using the environment variable
+    UBUNTU_APP_LAUNCH_OOM_PROC_PATH
+
+    \param pid PID to build path for
+*/
+std::string Base::pidToOomPath(pid_t pid)
+{
+    static std::string procpath;
+    if (G_UNLIKELY(procpath.empty()))
+    {
+        /* Set by the test suite, probably not anyone else */
+        auto envvar = g_getenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH");
+        if (G_LIKELY(envvar == nullptr))
+            procpath = "/proc";
+        else
+            procpath = envvar;
+    }
+
+    gchar* gpath = g_build_filename(procpath.c_str(), std::to_string(pid).c_str(), "oom_score_adj", nullptr);
+    std::string path = gpath;
+    g_free(gpath);
+    return path;
+}
+
+/** Writes an OOM value to proc, assuming we have a string
+    in the outer loop
+
+    \param pid PID to change the OOM value of
+    \param oomvalue OOM value to set
+*/
+void Base::oomValueToPid(pid_t pid, const oom::Score oomvalue)
+{
+    auto oomstr = std::to_string(static_cast<std::int32_t>(oomvalue));
+    auto path = pidToOomPath(pid);
+    FILE* adj = fopen(path.c_str(), "w");
+    int openerr = errno;
+
+    if (adj == nullptr)
+    {
+        switch (openerr)
+        {
+            case ENOENT:
+                /* ENOENT happens a fair amount because of races, so it's not
+                   worth printing a warning about */
+                return;
+            case EACCES:
+            {
+                /* We can get this error when trying to set the OOM value on
+                   Oxide renderers because they're started by the sandbox and
+                   don't have their adjustment value available for us to write.
+                   We have a helper to deal with this, but it's kinda expensive
+                   so we only use it when we have to. */
+                oomValueToPidHelper(pid, oomvalue);
+                return;
+            }
+            default:
+                g_warning("Unable to set OOM value for '%d' to '%s': %s", int(pid), oomstr.c_str(),
+                          std::strerror(openerr));
+                return;
+        }
+    }
+
+    size_t writesize = fwrite(oomstr.c_str(), 1, oomstr.size(), adj);
+    int writeerr = errno;
+    fclose(adj);
+
+    if (writesize == oomstr.size())
+        return;
+
+    if (writeerr != 0)
+        g_warning("Unable to set OOM value for '%d' to '%s': %s", int(pid), oomstr.c_str(), strerror(writeerr));
+    else
+        /* No error, but yet, wrong size. Not sure, what could cause this. */
+        g_debug("Unable to set OOM value for '%d' to '%s': Wrote %d bytes", int(pid), oomstr.c_str(), int(writesize));
+}
+
+/** Use a setuid root helper for setting the oom value of
+    Chromium instances
+
+    \param pid PID to change the OOM value of
+    \param oomvalue OOM value to set
+*/
+void Base::oomValueToPidHelper(pid_t pid, const oom::Score oomvalue)
+{
+    GError* error = nullptr;
+    std::string oomstr = std::to_string(static_cast<std::int32_t>(oomvalue));
+    std::string pidstr = std::to_string(pid);
+    std::array<const char*, 4> args = {OOM_HELPER, pidstr.c_str(), oomstr.c_str(), nullptr};
+
+    g_debug("Excuting OOM Helper (pid: %d, score: %d): %s", int(pid), int(oomvalue),
+            std::accumulate(args.begin(), args.end(), std::string{},
+                            [](const std::string& instr, const char* output) -> std::string {
+                                if (instr.empty())
+                                {
+                                    return output;
+                                }
+                                else if (output != nullptr)
+                                {
+                                    return instr + " " + std::string(output);
+                                }
+                                else
+                                {
+                                    return instr;
+                                }
+                            })
+                .c_str());
+
+    g_spawn_async(nullptr,               /* working dir */
+                  (char**)(args.data()), /* args */
+                  nullptr,               /* env */
+                  G_SPAWN_DEFAULT,       /* flags */
+                  nullptr,               /* child setup */
+                  nullptr,               /* child setup userdata*/
+                  nullptr,               /* pid */
+                  &error);               /* error */
+
+    if (error != nullptr)
+    {
+        g_warning("Unable to launch OOM helper '" OOM_HELPER "' on PID '%d': %s", pid, error->message);
+        g_error_free(error);
+        return;
+    }
+}
+
+/** Reformat a C++ vector of URLs into a C GStrv of strings
+
+    \param urls Vector of URLs to make into C strings
+*/
+std::shared_ptr<gchar*> Base::urlsToStrv(const std::vector<Application::URL>& urls)
+{
+    if (urls.empty())
+    {
+        return {};
+    }
+
+    auto array = g_array_new(TRUE, FALSE, sizeof(gchar*));
+
+    for (auto url : urls)
+    {
+        auto str = g_strdup(url.value().c_str());
+        g_debug("Converting URL: %s", str);
+        g_array_append_val(array, str);
+    }
+
+    return std::shared_ptr<gchar*>((gchar**)g_array_free(array, FALSE), g_strfreev);
+}
+
+}  // namespace instance
+
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu
 
=== added file 'libubuntu-app-launch/jobs-base.h'
--- libubuntu-app-launch/jobs-base.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-base.h	2016-11-01 14:53:56 +0000
@@ -0,0 +1,124 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#pragma once
+#include "application.h"
+#include <glib.h>
+#include <set>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace instance
+{
+
+class Base : public Application::Instance
+{
+public:
+    Base(const AppID& appId,
+         const std::string& job,
+         const std::string& instance,
+         const std::vector<Application::URL>& urls,
+         const std::shared_ptr<Registry>& registry);
+    virtual ~Base() = default;
+
+    bool isRunning() override;
+    bool hasPid(pid_t pid) override;
+    void pause() override;
+    void resume() override;
+
+    /* OOM Functions */
+    void setOomAdjustment(const oom::Score score) override;
+    const oom::Score getOomAdjustment() override;
+
+protected:
+    /** Application ID */
+    const AppID appId_;
+    /** Upstart job name */
+    const std::string job_;
+    /** Instance ID environment value, empty if none */
+    const std::string instance_;
+    /** The URLs that this was launched for. Only valid on launched jobs, we
+        should look at perhaps changing that. */
+    std::vector<Application::URL> urls_;
+    /** A link to the registry we're using for connections */
+    std::shared_ptr<Registry> registry_;
+
+    static std::shared_ptr<gchar*> urlsToStrv(const std::vector<Application::URL>& urls);
+
+private:
+    std::vector<pid_t> forAllPids(std::function<void(pid_t)> eachPid);
+    void signalToPid(pid_t pid, int signal);
+    std::string pidToOomPath(pid_t pid);
+    void oomValueToPid(pid_t pid, const oom::Score oomvalue);
+    void oomValueToPidHelper(pid_t pid, const oom::Score oomvalue);
+    void pidListToDbus(const std::vector<pid_t>& pids, const std::string& signal);
+};
+
+}  // namespace instance
+
+namespace manager
+{
+
+/** Flag for whether we should include the testing environment variables */
+enum class launchMode
+{
+    STANDARD, /**< Standard variable set */
+    TEST      /**< Include testing environment vars */
+};
+
+class Base
+{
+public:
+    Base(const std::shared_ptr<Registry>& registry);
+    virtual ~Base() = default;
+
+    virtual std::shared_ptr<Application::Instance> launch(
+        const AppID& appId,
+        const std::string& job,
+        const std::string& instance,
+        const std::vector<Application::URL>& urls,
+        launchMode mode,
+        std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv) = 0;
+
+    virtual std::shared_ptr<Application::Instance> existing(const AppID& appId,
+                                                            const std::string& job,
+                                                            const std::string& instance,
+                                                            const std::vector<Application::URL>& urls) = 0;
+
+    virtual std::list<std::shared_ptr<Application>> runningApps() = 0;
+
+    virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) = 0;
+
+    const std::set<std::string>& getAllJobs();
+
+    static std::shared_ptr<Base> determineFactory(std::shared_ptr<Registry> registry);
+
+protected:
+    std::weak_ptr<Registry> registry_;
+    std::set<std::string> allJobs_;
+};
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu
 
=== added file 'libubuntu-app-launch/jobs-systemd.cpp'
--- libubuntu-app-launch/jobs-systemd.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-systemd.cpp	2016-11-01 14:53:56 +0000
@@ -0,0 +1,917 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#include <algorithm>
+#include <gio/gio.h>
+#include <numeric>
+#include <regex>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "helpers.h"
+#include "jobs-systemd.h"
+#include "registry-impl.h"
+#include "second-exec-core.h"
+
+extern "C" {
+#include "ubuntu-app-launch-trace.h"
+}
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace instance
+{
+
+class SystemD : public Base
+{
+    friend class manager::SystemD;
+
+public:
+    explicit SystemD(const AppID& appId,
+                     const std::string& job,
+                     const std::string& instance,
+                     const std::vector<Application::URL>& urls,
+                     const std::shared_ptr<Registry>& registry);
+
+    /* Query lifecycle */
+    pid_t primaryPid() override;
+    std::string logPath() override;
+    std::vector<pid_t> pids() override;
+
+    /* Manage lifecycle */
+    void stop() override;
+
+};  // class SystemD
+
+SystemD::SystemD(const AppID& appId,
+                 const std::string& job,
+                 const std::string& instance,
+                 const std::vector<Application::URL>& urls,
+                 const std::shared_ptr<Registry>& registry)
+    : Base(appId, job, instance, urls, registry)
+{
+    g_debug("Creating a new SystemD for '%s' instance '%s'", std::string(appId).c_str(), instance.c_str());
+}
+
+pid_t SystemD::primaryPid()
+{
+    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
+    return manager->unitPrimaryPid(appId_, job_, instance_);
+}
+
+std::string SystemD::logPath()
+{
+    /* NOTE: We can never get this for systemd */
+    return {};
+}
+
+std::vector<pid_t> SystemD::pids()
+{
+    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
+    return manager->unitPids(appId_, job_, instance_);
+}
+
+void SystemD::stop()
+{
+    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
+    return manager->stopUnit(appId_, job_, instance_);
+}
+
+}  // namespace instance
+
+namespace manager
+{
+
+static const std::string SYSTEMD_DBUS_ADDRESS{"org.freedesktop.systemd1"};
+static const std::string SYSTEMD_DBUS_IFACE_MANAGER{"org.freedesktop.systemd1.Manager"};
+static const std::string SYSTEMD_DBUS_PATH_MANAGER{"/org/freedesktop/systemd1"};
+static const std::string SYSTEMD_DBUS_IFACE_UNIT{"org.freedesktop.systemd1.Unit"};
+static const std::string SYSTEMD_DBUS_IFACE_SERVICE{"org.freedesktop.systemd1.Service"};
+
+SystemD::SystemD(std::shared_ptr<Registry> registry)
+    : Base(registry)
+{
+    auto cancel = registry->impl->thread.getCancellable();
+    userbus_ = registry->impl->thread.executeOnThread<std::shared_ptr<GDBusConnection>>([cancel]() {
+        GError* error = nullptr;
+        auto bus = std::shared_ptr<GDBusConnection>(
+            g_dbus_connection_new_for_address_sync(
+                ("unix:path=" + userBusPath()).c_str(), /* path to the user bus */
+                (GDBusConnectionFlags)(G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
+                                       G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION), /* It is a message bus */
+                nullptr,                                                                /* observer */
+                cancel.get(), /* cancellable from the thread */
+                &error),      /* error */
+            [](GDBusConnection* bus) { g_clear_object(&bus); });
+
+        if (error != nullptr)
+        {
+            std::string message = std::string("Unable to connect to user bus: ") + error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        return bus;
+    });
+}
+
+SystemD::~SystemD()
+{
+}
+
+std::string SystemD::findEnv(const std::string& value, std::list<std::pair<std::string, std::string>>& env)
+{
+    std::string retval;
+    auto entry = std::find_if(env.begin(), env.end(),
+                              [&value](std::pair<std::string, std::string>& entry) { return entry.first == value; });
+
+    if (entry != env.end())
+    {
+        retval = entry->second;
+    }
+
+    return retval;
+}
+
+std::vector<std::string> SystemD::parseExec(std::list<std::pair<std::string, std::string>>& env)
+{
+    auto exec = findEnv("APP_EXEC", env);
+    if (exec.empty())
+    {
+        g_debug("Application exec line is empty?!?!?");
+        return {};
+    }
+    auto uris = findEnv("APP_URIS", env);
+
+    auto execarray = desktop_exec_parse(exec.c_str(), uris.c_str());
+
+    std::vector<std::string> retval;
+    retval.reserve(execarray->len);
+    for (unsigned int i = 0; i < execarray->len; i++)
+    {
+        retval.emplace_back(g_array_index(execarray, gchar*, i));
+    }
+
+    g_array_set_clear_func(execarray, g_free);
+    g_array_free(execarray, FALSE); /* TODO: Not TRUE? */
+
+    /* See if we need the xmir helper */
+    if (findEnv("APP_XMIR_ENABLE", env) == "1" && getenv("DISPLAY") == nullptr)
+    {
+        retval.emplace(retval.begin(), findEnv("APP_ID", env));
+        retval.emplace(retval.begin(), XMIR_HELPER);
+    }
+
+    /* See if we're doing apparmor by hand */
+    auto appexecpolicy = findEnv("APP_EXEC_POLICY", env);
+    if (!appexecpolicy.empty() && appexecpolicy != "unconfined")
+    {
+        retval.emplace(retval.begin(), appexecpolicy);
+        retval.emplace(retval.begin(), "-p");
+        retval.emplace(retval.begin(), "aa-exec");
+    }
+
+    return retval;
+}
+
+/** Small helper that we can new/delete to work better with C stuff */
+struct StartCHelper
+{
+    std::shared_ptr<instance::SystemD> ptr;
+    std::shared_ptr<GDBusConnection> bus;
+};
+
+void SystemD::application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data)
+{
+    auto data = static_cast<StartCHelper*>(user_data);
+    GError* error{nullptr};
+    GVariant* result{nullptr};
+
+    tracepoint(ubuntu_app_launch, libual_start_message_callback, std::string(data->ptr->appId_).c_str());
+
+    g_debug("Started Message Callback: %s", std::string(data->ptr->appId_).c_str());
+
+    result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(obj), res, &error);
+
+    g_clear_pointer(&result, g_variant_unref);
+
+    if (error != nullptr)
+    {
+        if (g_dbus_error_is_remote_error(error))
+        {
+            gchar* remote_error = g_dbus_error_get_remote_error(error);
+            g_debug("Remote error: %s", remote_error);
+            if (g_strcmp0(remote_error, "org.freedesktop.systemd1.UnitExists") == 0)
+            {
+                auto urls = instance::SystemD::urlsToStrv(data->ptr->urls_);
+                second_exec(data->bus.get(),                                           /* DBus */
+                            data->ptr->registry_->impl->thread.getCancellable().get(), /* cancellable */
+                            data->ptr->primaryPid(),                                   /* primary pid */
+                            std::string(data->ptr->appId_).c_str(),                    /* appid */
+                            urls.get());                                               /* urls */
+            }
+
+            g_free(remote_error);
+        }
+        else
+        {
+            g_warning("Unable to emit event to start application: %s", error->message);
+        }
+        g_error_free(error);
+    }
+
+    delete data;
+}
+
+void SystemD::copyEnv(const std::string& envname, std::list<std::pair<std::string, std::string>>& env)
+{
+    if (!findEnv(envname, env).empty())
+    {
+        g_debug("Already a value set for '%s' ignoring", envname.c_str());
+        return;
+    }
+
+    auto cvalue = getenv(envname.c_str());
+    g_debug("Copying Environment: %s", envname.c_str());
+    if (cvalue != nullptr)
+    {
+        std::string value = getenv(envname.c_str());
+        env.emplace_back(std::make_pair(envname, value));
+    }
+    else
+    {
+        g_debug("Unable to copy environment '%s'", envname.c_str());
+    }
+}
+
+void SystemD::copyEnvByPrefix(const std::string& prefix, std::list<std::pair<std::string, std::string>>& env)
+{
+    for (unsigned int i = 0; environ[i] != nullptr; i++)
+    {
+        if (g_str_has_prefix(environ[i], prefix.c_str()))
+        {
+            std::string envfull = environ[i];
+            std::string envname;
+            bool seenequal = false;
+            std::remove_copy_if(envfull.begin(), envfull.end(), std::back_inserter(envname),
+                                [&seenequal](const char c) {
+                                    if (c == '=')
+                                    {
+                                        seenequal = true;
+                                    }
+                                    return seenequal;
+                                });
+            copyEnv(envname, env);
+        }
+    }
+}
+
+std::shared_ptr<Application::Instance> SystemD::launch(
+    const AppID& appId,
+    const std::string& job,
+    const std::string& instance,
+    const std::vector<Application::URL>& urls,
+    launchMode mode,
+    std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv)
+{
+    if (appId.empty())
+        return {};
+
+    auto registry = registry_.lock();
+    return registry->impl->thread.executeOnThread<std::shared_ptr<instance::SystemD>>(
+        [&]() -> std::shared_ptr<instance::SystemD> {
+            auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry->impl->jobs);
+            std::string appIdStr{appId};
+            g_debug("Initializing params for an new instance::SystemD for: %s", appIdStr.c_str());
+
+            tracepoint(ubuntu_app_launch, libual_start, appIdStr.c_str());
+
+            int timeout = 1;
+            if (ubuntu::app_launch::Registry::Impl::isWatchingAppStarting())
+            {
+                timeout = 0;
+            }
+
+            auto handshake = starting_handshake_start(appIdStr.c_str(), timeout);
+            if (handshake == nullptr)
+            {
+                g_warning("Unable to setup starting handshake");
+            }
+
+            /* Figure out the unit name for the job */
+            auto unitname = unitName(SystemD::UnitInfo{appIdStr, job, instance});
+
+            /* Build up our environment */
+            auto env = getenv();
+
+            env.emplace_back(std::make_pair("APP_ID", appIdStr));                           /* Application ID */
+            env.emplace_back(std::make_pair("APP_LAUNCHER_PID", std::to_string(getpid()))); /* Who we are, for bugs */
+
+            copyEnv("DISPLAY", env);
+            copyEnvByPrefix("DBUS_", env);
+            copyEnvByPrefix("MIR_", env);
+            copyEnvByPrefix("QT_", env);
+            copyEnvByPrefix("UBUNTU_", env);
+            copyEnvByPrefix("UNITY_", env);
+            copyEnvByPrefix("XDG_", env);
+
+            if (!urls.empty())
+            {
+                auto accumfunc = [](const std::string& prev, Application::URL thisurl) -> std::string {
+                    gchar* gescaped = g_shell_quote(thisurl.value().c_str());
+                    std::string escaped;
+                    if (gescaped != nullptr)
+                    {
+                        escaped = gescaped;
+                        g_free(gescaped);
+                    }
+                    else
+                    {
+                        g_warning("Unable to escape URL: %s", thisurl.value().c_str());
+                        return prev;
+                    }
+
+                    if (prev.empty())
+                    {
+                        return escaped;
+                    }
+                    else
+                    {
+                        return prev + " " + escaped;
+                    }
+                };
+                auto urlstring = std::accumulate(urls.begin(), urls.end(), std::string{}, accumfunc);
+                env.emplace_back(std::make_pair("APP_URIS", urlstring));
+            }
+
+            if (mode == launchMode::TEST)
+            {
+                env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
+            }
+
+            /* Convert to GVariant */
+            GVariantBuilder builder;
+            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+
+            g_variant_builder_add_value(&builder, g_variant_new_string(unitname.c_str()));
+            g_variant_builder_add_value(&builder, g_variant_new_string("replace"));  // Job mode
+
+            /* Parameter Array */
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+            /* Environment */
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+            g_variant_builder_add_value(&builder, g_variant_new_string("Environment"));
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+            for (const auto& envvar : env)
+            {
+                if (!envvar.first.empty() && !envvar.second.empty())
+                {
+                    g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf(
+                                                              "%s=%s", envvar.first.c_str(), envvar.second.c_str())));
+                    // g_debug("Setting environment: %s=%s", envvar.first.c_str(), envvar.second.c_str());
+                }
+            }
+
+            g_variant_builder_close(&builder);
+            g_variant_builder_close(&builder);
+            g_variant_builder_close(&builder);
+
+            /* ExecStart */
+            auto commands = parseExec(env);
+            gchar* pathexec{nullptr};
+            if (!commands.empty() && ((pathexec = g_find_program_in_path(commands[0].c_str())) != nullptr))
+            {
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+                g_variant_builder_add_value(&builder, g_variant_new_string("ExecStart"));
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+                g_variant_builder_add_value(&builder, g_variant_new_take_string(pathexec));
+
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+                for (auto param : commands)
+                {
+                    g_variant_builder_add_value(&builder, g_variant_new_string(param.c_str()));
+                }
+                g_variant_builder_close(&builder);
+
+                g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE));
+
+                g_variant_builder_close(&builder);
+                g_variant_builder_close(&builder);
+                g_variant_builder_close(&builder);
+                g_variant_builder_close(&builder);
+            }
+
+            /* RemainAfterExit */
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+            g_variant_builder_add_value(&builder, g_variant_new_string("RemainAfterExit"));
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+            g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE));
+            g_variant_builder_close(&builder);
+            g_variant_builder_close(&builder);
+
+            /* Type */
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+            g_variant_builder_add_value(&builder, g_variant_new_string("Type"));
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+            g_variant_builder_add_value(&builder, g_variant_new_string("oneshot"));
+            g_variant_builder_close(&builder);
+            g_variant_builder_close(&builder);
+
+            /* Working Directory */
+            if (!findEnv("APP_DIR", env).empty())
+            {
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+                g_variant_builder_add_value(&builder, g_variant_new_string("WorkingDirectory"));
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+                g_variant_builder_add_value(&builder, g_variant_new_string(findEnv("APP_DIR", env).c_str()));
+                g_variant_builder_close(&builder);
+                g_variant_builder_close(&builder);
+            }
+
+            /* Parameter Array */
+            g_variant_builder_close(&builder);
+
+            /* Dependent Units (none) */
+            g_variant_builder_add_value(&builder, g_variant_new_array(G_VARIANT_TYPE("(sa(sv))"), nullptr, 0));
+
+            auto retval = std::make_shared<instance::SystemD>(appId, job, instance, urls, registry);
+            auto chelper = new StartCHelper{};
+            chelper->ptr = retval;
+            chelper->bus = manager->userbus_;
+
+            tracepoint(ubuntu_app_launch, handshake_wait, appIdStr.c_str());
+            starting_handshake_wait(handshake);
+            tracepoint(ubuntu_app_launch, handshake_complete, appIdStr.c_str());
+
+            /* Call the job start function */
+            g_debug("Asking systemd to start task for: %s", appIdStr.c_str());
+            g_dbus_connection_call(manager->userbus_.get(),                       /* bus */
+                                   SYSTEMD_DBUS_ADDRESS.c_str(),                  /* service name */
+                                   SYSTEMD_DBUS_PATH_MANAGER.c_str(),             /* Path */
+                                   SYSTEMD_DBUS_IFACE_MANAGER.c_str(),            /* interface */
+                                   "StartTransientUnit",                          /* method */
+                                   g_variant_builder_end(&builder),               /* params */
+                                   G_VARIANT_TYPE("(o)"),                         /* return */
+                                   G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                   -1,                                            /* default timeout */
+                                   registry->impl->thread.getCancellable().get(), /* cancellable */
+                                   application_start_cb,                          /* callback */
+                                   chelper                                        /* object */
+                                   );
+
+            tracepoint(ubuntu_app_launch, libual_start_message_sent, appIdStr.c_str());
+
+            return retval;
+        });
+}
+
+std::shared_ptr<Application::Instance> SystemD::existing(const AppID& appId,
+                                                         const std::string& job,
+                                                         const std::string& instance,
+                                                         const std::vector<Application::URL>& urls)
+{
+    return std::make_shared<instance::SystemD>(appId, job, instance, urls, registry_.lock());
+}
+
+std::vector<std::shared_ptr<instance::Base>> SystemD::instances(const AppID& appID, const std::string& job)
+{
+    std::vector<std::shared_ptr<instance::Base>> instances;
+    auto registry = registry_.lock();
+    std::vector<Application::URL> urls;
+
+    for (const auto& unit : listUnits())
+    {
+        SystemD::UnitInfo unitinfo;
+
+        try
+        {
+            unitinfo = parseUnit(unit.id);
+        }
+        catch (std::runtime_error& e)
+        {
+            continue;
+        }
+
+        if (job != unitinfo.job)
+        {
+            continue;
+        }
+
+        if (std::string(appID) != unitinfo.appid)
+        {
+            continue;
+        }
+
+        instances.emplace_back(std::make_shared<instance::SystemD>(appID, job, unitinfo.inst, urls, registry));
+    }
+
+    g_debug("Found %d instances for AppID '%s'", int(instances.size()), std::string(appID).c_str());
+
+    return instances;
+}
+
+std::list<std::shared_ptr<Application>> SystemD::runningApps()
+{
+    auto allJobs = getAllJobs();
+    auto registry = registry_.lock();
+    std::set<std::string> appids;
+
+    for (const auto& unit : listUnits())
+    {
+        SystemD::UnitInfo unitinfo;
+
+        try
+        {
+            unitinfo = parseUnit(unit.id);
+        }
+        catch (std::runtime_error& e)
+        {
+            continue;
+        }
+
+        if (allJobs.find(unitinfo.job) == allJobs.end())
+        {
+            continue;
+        }
+
+        appids.insert(unitinfo.appid);
+    }
+
+    std::list<std::shared_ptr<Application>> apps;
+    for (const auto& appid : appids)
+    {
+        auto id = AppID::find(appid);
+        if (id.empty())
+        {
+            g_debug("Unable to handle AppID: %s", appid.c_str());
+            continue;
+        }
+
+        apps.emplace_back(Application::create(id, registry));
+    }
+
+    return apps;
+}
+
+std::string SystemD::userBusPath()
+{
+    auto cpath = getenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH");
+    if (cpath != nullptr)
+    {
+        return cpath;
+    }
+    return std::string{"/run/user/"} + std::to_string(getuid()) + std::string{"/bus"};
+}
+
+std::list<SystemD::UnitEntry> SystemD::listUnits()
+{
+    auto registry = registry_.lock();
+    return registry->impl->thread.executeOnThread<std::list<SystemD::UnitEntry>>([this, registry]() {
+        GError* error{nullptr};
+        std::list<SystemD::UnitEntry> ret;
+
+        GVariant* callt = g_dbus_connection_call_sync(userbus_.get(),                                /* user bus */
+                                                      SYSTEMD_DBUS_ADDRESS.c_str(),                  /* bus name */
+                                                      SYSTEMD_DBUS_PATH_MANAGER.c_str(),             /* path */
+                                                      SYSTEMD_DBUS_IFACE_MANAGER.c_str(),            /* interface */
+                                                      "ListUnits",                                   /* method */
+                                                      nullptr,                                       /* params */
+                                                      G_VARIANT_TYPE("(a(ssssssouso))"),             /* ret type */
+                                                      G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                                      -1,                                            /* timeout */
+                                                      registry->impl->thread.getCancellable().get(), /* cancellable */
+                                                      &error);
+
+        if (error != nullptr)
+        {
+            auto message = std::string{"Unable to list SystemD units: "} + error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        GVariant* call = g_variant_get_child_value(callt, 0);
+        g_variant_unref(callt);
+
+        const gchar* id;
+        const gchar* description;
+        const gchar* loadState;
+        const gchar* activeState;
+        const gchar* subState;
+        const gchar* following;
+        const gchar* path;
+        guint32 jobId;
+        const gchar* jobType;
+        const gchar* jobPath;
+        auto iter = g_variant_iter_new(call);
+        while (g_variant_iter_loop(iter, "(&s&s&s&s&s&s&ou&s&o)", &id, &description, &loadState, &activeState,
+                                   &subState, &following, &path, &jobId, &jobType, &jobPath))
+        {
+            ret.emplace_back(SystemD::UnitEntry{id, description, loadState, activeState, subState, following, path,
+                                                jobId, jobType, jobPath});
+        }
+
+        g_variant_iter_free(iter);
+        g_variant_unref(call);
+
+        return ret;
+    });
+}
+
+/* TODO: Application job names */
+const std::regex unitNaming{
+    "^ubuntu\\-app\\-launch\\-(application\\-(?:click|legacy|snap))\\-(.*)\\-([0-9]*)\\.service$"};
+
+SystemD::UnitInfo SystemD::parseUnit(const std::string& unit)
+{
+    std::smatch match;
+    if (!std::regex_match(unit, match, unitNaming))
+    {
+        throw std::runtime_error{"Unable to parse unit name: " + unit};
+    }
+
+    return {match[2].str(), match[1].str(), match[3].str()};
+}
+
+std::string SystemD::unitName(const SystemD::UnitInfo& info)
+{
+    return std::string{"ubuntu-app-launch-"} + info.job + "-" + info.appid + "-" + info.inst + ".service";
+}
+
+/** Function that uses and maintains the cache of the paths for units
+    on the systemd dbus connection. If we already have the entry in the
+    cache we just return the path and this function is fast. If not we have
+    to ask systemd for it and that can take a bit longer.
+
+    After getting the data we throw a small background task in to clean
+    up the cache if it has more than 50 entries. We delete those who
+    haven't be used for an hour.
+*/
+std::string SystemD::unitPath(const std::string& unitName)
+{
+    auto registry = registry_.lock();
+    std::string retval;
+
+    if (true)
+    {
+        /* Create a context for the gaurd */
+        std::lock_guard<std::mutex> guard(unitPathsMutex_);
+        auto iter = std::find_if(unitPaths_.begin(), unitPaths_.end(),
+                                 [&unitName](const SystemD::UnitPath& entry) { return entry.unitName == unitName; });
+
+        if (iter != unitPaths_.end())
+        {
+            retval = iter->unitPath;
+            iter->timeStamp = std::chrono::system_clock::now();
+        }
+    }
+
+    if (retval.empty())
+    {
+        retval = registry->impl->thread.executeOnThread<std::string>([this, registry, unitName]() {
+            std::string path;
+            GError* error{nullptr};
+            GVariant* call =
+                g_dbus_connection_call_sync(userbus_.get(),                                /* user bus */
+                                            SYSTEMD_DBUS_ADDRESS.c_str(),                  /* bus name */
+                                            SYSTEMD_DBUS_PATH_MANAGER.c_str(),             /* path */
+                                            SYSTEMD_DBUS_IFACE_MANAGER.c_str(),            /* interface */
+                                            "GetUnit",                                     /* method */
+                                            g_variant_new("(s)", unitName.c_str()),        /* params */
+                                            G_VARIANT_TYPE("(o)"),                         /* ret type */
+                                            G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                            -1,                                            /* timeout */
+                                            registry->impl->thread.getCancellable().get(), /* cancellable */
+                                            &error);
+
+            if (error != nullptr)
+            {
+                auto message = std::string{"Unable to get SystemD unit path for '"} + unitName + std::string{"': "} +
+                               error->message;
+                g_error_free(error);
+                throw std::runtime_error(message);
+            }
+
+            /* Parse variant */
+            gchar* gpath = nullptr;
+            g_variant_get(call, "(o)", &gpath);
+            if (gpath != nullptr)
+            {
+                std::lock_guard<std::mutex> guard(unitPathsMutex_);
+                path = gpath;
+                unitPaths_.emplace_back(SystemD::UnitPath{unitName, path, std::chrono::system_clock::now()});
+            }
+
+            g_variant_unref(call);
+
+            return path;
+        });
+    }
+
+    /* Queue a possible cleanup */
+    if (unitPaths_.size() > 50)
+    {
+        /* TODO: We should look at UnitRemoved as well */
+        /* TODO: Add to cache on UnitNew */
+        registry->impl->thread.executeOnThread([this] {
+            std::lock_guard<std::mutex> guard(unitPathsMutex_);
+            std::remove_if(unitPaths_.begin(), unitPaths_.end(), [](const SystemD::UnitPath& entry) -> bool {
+                auto age = std::chrono::system_clock::now() - entry.timeStamp;
+                return age > std::chrono::hours{1};
+            });
+        });
+    }
+
+    return retval;
+}
+
+pid_t SystemD::unitPrimaryPid(const AppID& appId, const std::string& job, const std::string& instance)
+{
+    auto registry = registry_.lock();
+    auto unitname = unitName(SystemD::UnitInfo{appId, job, instance});
+    auto unitpath = unitPath(unitname);
+
+    return registry->impl->thread.executeOnThread<pid_t>([this, registry, unitname, unitpath]() {
+        GError* error{nullptr};
+        GVariant* call = g_dbus_connection_call_sync(
+            userbus_.get(),                                                       /* user bus */
+            SYSTEMD_DBUS_ADDRESS.c_str(),                                         /* bus name */
+            unitpath.c_str(),                                                     /* path */
+            "org.freedesktop.DBus.Properties",                                    /* interface */
+            "Get",                                                                /* method */
+            g_variant_new("(ss)", SYSTEMD_DBUS_IFACE_SERVICE.c_str(), "MainPID"), /* params */
+            G_VARIANT_TYPE("(v)"),                                                /* ret type */
+            G_DBUS_CALL_FLAGS_NONE,                                               /* flags */
+            -1,                                                                   /* timeout */
+            registry->impl->thread.getCancellable().get(),                        /* cancellable */
+            &error);
+
+        if (error != nullptr)
+        {
+            auto message =
+                std::string{"Unable to get SystemD PID for '"} + unitname + std::string{"': "} + error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        /* Parse variant */
+        GVariant* vpid{nullptr};
+        g_variant_get(call, "(v)", &vpid);
+        g_variant_unref(call);
+
+        pid_t pid;
+        pid = g_variant_get_uint32(vpid);
+        g_variant_unref(vpid);
+
+        return pid;
+    });
+}
+
+std::vector<pid_t> SystemD::unitPids(const AppID& appId, const std::string& job, const std::string& instance)
+{
+    auto registry = registry_.lock();
+    auto unitname = unitName(SystemD::UnitInfo{appId, job, instance});
+    auto unitpath = unitPath(unitname);
+
+    auto cgrouppath = registry->impl->thread.executeOnThread<std::string>([this, registry, unitname, unitpath]() {
+        GError* error{nullptr};
+        GVariant* call = g_dbus_connection_call_sync(
+            userbus_.get(),                                                            /* user bus */
+            SYSTEMD_DBUS_ADDRESS.c_str(),                                              /* bus name */
+            unitpath.c_str(),                                                          /* path */
+            "org.freedesktop.DBus.Properties",                                         /* interface */
+            "Get",                                                                     /* method */
+            g_variant_new("(ss)", SYSTEMD_DBUS_IFACE_SERVICE.c_str(), "ControlGroup"), /* params */
+            G_VARIANT_TYPE("(v)"),                                                     /* ret type */
+            G_DBUS_CALL_FLAGS_NONE,                                                    /* flags */
+            -1,                                                                        /* timeout */
+            registry->impl->thread.getCancellable().get(),                             /* cancellable */
+            &error);
+
+        if (error != nullptr)
+        {
+            auto message = std::string{"Unable to get SystemD Control Group for '"} + unitname + std::string{"': "} +
+                           error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        /* Parse variant */
+        GVariant* vstring = nullptr;
+        g_variant_get(call, "(v)", &vstring);
+        g_variant_unref(call);
+
+        if (vstring == nullptr)
+        {
+            return std::string{};
+        }
+
+        std::string group;
+        auto ggroup = g_variant_get_string(vstring, nullptr);
+        if (ggroup != nullptr)
+        {
+            group = ggroup;
+        }
+        g_variant_unref(vstring);
+
+        return group;
+    });
+
+    gchar* fullpath = g_build_filename("/sys", "fs", "cgroup", "systemd", cgrouppath.c_str(), "tasks", nullptr);
+    gchar* pidstr = nullptr;
+    GError* error = nullptr;
+
+    g_debug("Getting PIDs from %s", fullpath);
+    g_file_get_contents(fullpath, &pidstr, nullptr, &error);
+    g_free(fullpath);
+
+    if (error != nullptr)
+    {
+        auto message = std::string{"Unable to read cgroup PID list: "} + error->message;
+        g_error_free(error);
+        throw std::runtime_error(message);
+    }
+
+    gchar** pidlines = g_strsplit(pidstr, "\n", -1);
+    g_free(pidstr);
+    std::vector<pid_t> pids;
+
+    for (auto i = 0; pidlines[i] != nullptr; i++)
+    {
+        const gchar* pidline = pidlines[i];
+        if (pidline[0] != '\n')
+        {
+            auto pid = std::atoi(pidline);
+            if (pid != 0)
+            {
+                pids.emplace_back(pid);
+            }
+        }
+    }
+
+    g_strfreev(pidlines);
+
+    return pids;
+}
+
+void SystemD::stopUnit(const AppID& appId, const std::string& job, const std::string& instance)
+{
+    auto registry = registry_.lock();
+    auto unitname = unitName(SystemD::UnitInfo{appId, job, instance});
+
+    registry->impl->thread.executeOnThread<bool>([this, registry, unitname] {
+        GError* error{nullptr};
+        GVariant* call = g_dbus_connection_call_sync(userbus_.get(),                                  /* user bus */
+                                                     SYSTEMD_DBUS_ADDRESS.c_str(),                    /* bus name */
+                                                     SYSTEMD_DBUS_PATH_MANAGER.c_str(),               /* path */
+                                                     SYSTEMD_DBUS_IFACE_MANAGER.c_str(),              /* interface */
+                                                     "StopUnit",                                      /* method */
+                                                     g_variant_new("(ss)", unitname.c_str(), "fail"), /* params */
+                                                     G_VARIANT_TYPE("(o)"),                           /* ret type */
+                                                     G_DBUS_CALL_FLAGS_NONE,                          /* flags */
+                                                     -1,                                              /* timeout */
+                                                     registry->impl->thread.getCancellable().get(),   /* cancellable */
+                                                     &error);
+
+        if (error != nullptr)
+        {
+            auto message =
+                std::string{"Unable to get SystemD to stop '"} + unitname + std::string{"': "} + error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        g_variant_unref(call);
+
+        return true;
+    });
+}
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu
 
=== added file 'libubuntu-app-launch/jobs-systemd.h'
--- libubuntu-app-launch/jobs-systemd.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-systemd.h	2016-11-01 14:53:56 +0000
@@ -0,0 +1,114 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#pragma once
+
+#include "jobs-base.h"
+#include <chrono>
+#include <gio/gio.h>
+#include <map>
+#include <mutex>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace manager
+{
+
+class SystemD : public Base
+{
+public:
+    SystemD(std::shared_ptr<Registry> registry);
+    virtual ~SystemD();
+
+    virtual std::shared_ptr<Application::Instance> launch(
+        const AppID& appId,
+        const std::string& job,
+        const std::string& instance,
+        const std::vector<Application::URL>& urls,
+        launchMode mode,
+        std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv) override;
+    virtual std::shared_ptr<Application::Instance> existing(const AppID& appId,
+                                                            const std::string& job,
+                                                            const std::string& instance,
+                                                            const std::vector<Application::URL>& urls) override;
+
+    virtual std::list<std::shared_ptr<Application>> runningApps() override;
+
+    virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) override;
+
+    static std::string userBusPath();
+
+    pid_t unitPrimaryPid(const AppID& appId, const std::string& job, const std::string& instance);
+    std::vector<pid_t> unitPids(const AppID& appId, const std::string& job, const std::string& instance);
+    void stopUnit(const AppID& appId, const std::string& job, const std::string& instance);
+
+private:
+    std::shared_ptr<GDBusConnection> userbus_;
+
+    /* ssssssouso */
+    struct UnitEntry
+    {
+        std::string id;
+        std::string description;
+        std::string loadState;
+        std::string activeState;
+        std::string subState;
+        std::string following;
+        std::string path;
+        std::uint32_t jobId;
+        std::string jobType;
+        std::string jobPath;
+    };
+    std::list<UnitEntry> listUnits();
+
+    struct UnitInfo
+    {
+        std::string appid;
+        std::string job;
+        std::string inst;
+    };
+    UnitInfo parseUnit(const std::string& unit);
+    std::string unitName(const UnitInfo& info);
+
+    struct UnitPath
+    {
+        std::string unitName;
+        std::string unitPath;
+        std::chrono::time_point<std::chrono::system_clock> timeStamp;
+    };
+    std::list<UnitPath> unitPaths_;
+    std::mutex unitPathsMutex_;
+    std::string unitPath(const std::string& unitName);
+
+    static std::string findEnv(const std::string& value, std::list<std::pair<std::string, std::string>>& env);
+    static void copyEnv(const std::string& envname, std::list<std::pair<std::string, std::string>>& env);
+    static void copyEnvByPrefix(const std::string& prefix, std::list<std::pair<std::string, std::string>>& env);
+
+    static std::vector<std::string> parseExec(std::list<std::pair<std::string, std::string>>& env);
+    static void application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data);
+};
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu
 
=== added file 'libubuntu-app-launch/jobs-upstart.cpp'
--- libubuntu-app-launch/jobs-upstart.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-upstart.cpp	2016-11-01 14:53:56 +0000
@@ -0,0 +1,874 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#include <algorithm>
+#include <cerrno>
+#include <cstring>
+#include <map>
+#include <numeric>
+#include <regex>
+
+#include <cgmanager/cgmanager.h>
+#include <upstart.h>
+
+#include "helpers.h"
+#include "registry-impl.h"
+#include "second-exec-core.h"
+
+extern "C" {
+#include "ubuntu-app-launch-trace.h"
+}
+
+#include "jobs-upstart.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace instance
+{
+
+/** An object that represents an instance of a job on Upstart. This
+    then implements everything needed by the instance interface. Most
+    applications tie into this today and use it as the backend for
+    their instances. */
+class Upstart : public Base
+{
+public:
+    explicit Upstart(const AppID& appId,
+                     const std::string& job,
+                     const std::string& instance,
+                     const std::vector<Application::URL>& urls,
+                     const std::shared_ptr<Registry>& registry);
+
+    /* Query lifecycle */
+    pid_t primaryPid() override;
+    std::string logPath() override;
+    std::vector<pid_t> pids() override;
+
+    /* Manage lifecycle */
+    void stop() override;
+
+    /* C Callback */
+    static void application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data);
+
+private:
+    std::string upstartJobPath(const std::string& job);
+    std::string upstartName();
+};
+
+/** Uses Upstart to get the primary PID of the instance using Upstart's
+    DBus interface */
+pid_t Upstart::primaryPid()
+{
+    auto jobpath = upstartJobPath(job_);
+    if (jobpath.empty())
+    {
+        g_debug("Unable to get a valid job path");
+        return 0;
+    }
+
+    return registry_->impl->thread.executeOnThread<pid_t>([this, &jobpath]() -> pid_t {
+        GError* error = nullptr;
+
+        std::string instancename = std::string(appId_);
+        if (job_ != "application-click")
+        {
+            instancename += "-" + instance_;
+        }
+
+        g_debug("Getting instance by name: %s", instance_.c_str());
+        GVariant* vinstance_path =
+            g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                   /* connection */
+                                        DBUS_SERVICE_UPSTART,                           /* service */
+                                        jobpath.c_str(),                                /* object path */
+                                        DBUS_INTERFACE_UPSTART_JOB,                     /* iface */
+                                        "GetInstanceByName",                            /* method */
+                                        g_variant_new("(s)", instancename.c_str()),     /* params */
+                                        G_VARIANT_TYPE("(o)"),                          /* return type */
+                                        G_DBUS_CALL_FLAGS_NONE,                         /* flags */
+                                        -1,                                             /* timeout: default */
+                                        registry_->impl->thread.getCancellable().get(), /* cancellable */
+                                        &error);
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to get instance '%s' of job '%s': %s", instance_.c_str(), job_.c_str(), error->message);
+            g_error_free(error);
+            return 0;
+        }
+
+        /* Jump rope to make this into a C++ type */
+        std::string instance_path;
+        gchar* cinstance_path = nullptr;
+        g_variant_get(vinstance_path, "(o)", &cinstance_path);
+        g_variant_unref(vinstance_path);
+        if (cinstance_path != nullptr)
+        {
+            instance_path = cinstance_path;
+            g_free(cinstance_path);
+        }
+
+        if (instance_path.empty())
+        {
+            g_debug("No instance object for instance name: %s", instance_.c_str());
+            return 0;
+        }
+
+        GVariant* props_tuple =
+            g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                          /* connection */
+                                        DBUS_SERVICE_UPSTART,                                  /* service */
+                                        instance_path.c_str(),                                 /* object path */
+                                        "org.freedesktop.DBus.Properties",                     /* interface */
+                                        "GetAll",                                              /* method */
+                                        g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE), /* params */
+                                        G_VARIANT_TYPE("(a{sv})"),                             /* return type */
+                                        G_DBUS_CALL_FLAGS_NONE,                                /* flags */
+                                        -1,                                                    /* timeout: default */
+                                        registry_->impl->thread.getCancellable().get(),        /* cancellable */
+                                        &error);
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to name of properties '%s': %s", instance_path.c_str(), error->message);
+            g_error_free(error);
+            error = nullptr;
+            return 0;
+        }
+
+        GVariant* props_dict = g_variant_get_child_value(props_tuple, 0);
+
+        pid_t retval = 0;
+        GVariant* processes = g_variant_lookup_value(props_dict, "processes", G_VARIANT_TYPE("a(si)"));
+        if (processes != nullptr && g_variant_n_children(processes) > 0)
+        {
+
+            GVariant* first_entry = g_variant_get_child_value(processes, 0);
+            GVariant* pidv = g_variant_get_child_value(first_entry, 1);
+
+            retval = g_variant_get_int32(pidv);
+
+            g_variant_unref(pidv);
+            g_variant_unref(first_entry);
+        }
+        else
+        {
+            g_debug("Unable to get 'processes' from properties of instance at path: %s", instance_path.c_str());
+        }
+
+        g_variant_unref(props_dict);
+
+        return retval;
+    });
+}
+
+/** Generate the full name of the Upstart job for the job, the
+    instance and how all those fit together.
+
+    Handles the special case of application-click which isn't designed
+    to have multi-instance apps.
+*/
+std::string Upstart::upstartName()
+{
+    std::string path = job_ + "-" + std::string(appId_);
+    if (job_ != "application-click")
+    {
+        path += "-";
+    }
+    if (!instance_.empty())
+    {
+        path += instance_;
+    }
+
+    return path;
+}
+
+/** Gets the path to the log file for this instance */
+std::string Upstart::logPath()
+{
+    std::string logfile = upstartName() + ".log";
+
+    gchar* cpath = g_build_filename(g_get_user_cache_dir(), "upstart", logfile.c_str(), nullptr);
+    std::string path(cpath);
+    g_free(cpath);
+
+    return path;
+}
+
+/** Returns all the PIDs that are in the cgroup for this application */
+std::vector<pid_t> Upstart::pids()
+{
+    auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry_->impl->jobs);
+    auto pids = manager->pidsFromCgroup(upstartName());
+    g_debug("Got %d PIDs for AppID '%s'", int(pids.size()), std::string(appId_).c_str());
+    return pids;
+}
+
+/** Stops this instance by asking Upstart to stop it. Upstart will then
+    send a SIGTERM and five seconds later start killing things. */
+void Upstart::stop()
+{
+    if (!registry_->impl->thread.executeOnThread<bool>([this]() {
+            auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry_->impl->jobs);
+
+            g_debug("Stopping job %s app_id %s instance_id %s", job_.c_str(), std::string(appId_).c_str(),
+                    instance_.c_str());
+
+            auto jobpath = manager->upstartJobPath(job_);
+            if (jobpath.empty())
+            {
+                throw new std::runtime_error("Unable to get job path for Upstart job '" + job_ + "'");
+            }
+
+            GVariantBuilder builder;
+            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+            g_variant_builder_add_value(
+                &builder, g_variant_new_take_string(g_strdup_printf("APP_ID=%s", std::string(appId_).c_str())));
+
+            if (!instance_.empty())
+            {
+                g_variant_builder_add_value(
+                    &builder, g_variant_new_take_string(g_strdup_printf("INSTANCE_ID=%s", instance_.c_str())));
+            }
+
+            g_variant_builder_close(&builder);
+            g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE)); /* wait */
+
+            GError* error = nullptr;
+            GVariant* stop_variant =
+                g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                   /* Dbus */
+                                            DBUS_SERVICE_UPSTART,                           /* Upstart name */
+                                            jobpath.c_str(),                                /* path */
+                                            DBUS_INTERFACE_UPSTART_JOB,                     /* interface */
+                                            "Stop",                                         /* method */
+                                            g_variant_builder_end(&builder),                /* params */
+                                            nullptr,                                        /* return */
+                                            G_DBUS_CALL_FLAGS_NONE,                         /* flags */
+                                            -1,                                             /* timeout: default */
+                                            registry_->impl->thread.getCancellable().get(), /* cancellable */
+                                            &error);                                        /* error (hopefully not) */
+
+            g_clear_pointer(&stop_variant, g_variant_unref);
+
+            if (error != nullptr)
+            {
+                g_warning("Unable to stop job %s app_id %s instance_id %s: %s", job_.c_str(),
+                          std::string(appId_).c_str(), instance_.c_str(), error->message);
+                g_error_free(error);
+                return false;
+            }
+
+            return true;
+        }))
+    {
+        g_warning("Unable to stop Upstart instance");
+    }
+}
+
+/** Create a new Upstart Instance object that can track the job and
+    get information about it.
+
+    \param appId Application ID
+    \param job Upstart job name
+    \param instance Upstart instance name
+    \param urls URLs sent to the application (only on launch today)
+    \param registry Registry of persistent connections to use
+*/
+Upstart::Upstart(const AppID& appId,
+                 const std::string& job,
+                 const std::string& instance,
+                 const std::vector<Application::URL>& urls,
+                 const std::shared_ptr<Registry>& registry)
+    : Base(appId, job, instance, urls, registry)
+{
+    g_debug("Creating a new Upstart for '%s' instance '%s'", std::string(appId).c_str(), instance.c_str());
+}
+
+/** Small helper that we can new/delete to work better with C stuff */
+struct StartCHelper
+{
+    std::shared_ptr<Upstart> ptr;
+};
+
+/** Callback from starting an application. It checks to see whether the
+    app is already running. If it is already running then we need to send
+    the URLs to it via DBus.
+
+    \param obj The GDBusConnection object
+    \param res Async result object
+    \param user_data A pointer to a StartCHelper structure
+*/
+void Upstart::application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data)
+{
+    auto data = static_cast<StartCHelper*>(user_data);
+    GError* error{nullptr};
+    GVariant* result{nullptr};
+
+    tracepoint(ubuntu_app_launch, libual_start_message_callback, std::string(data->ptr->appId_).c_str());
+
+    g_debug("Started Message Callback: %s", std::string(data->ptr->appId_).c_str());
+
+    result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(obj), res, &error);
+
+    g_clear_pointer(&result, g_variant_unref);
+
+    if (error != nullptr)
+    {
+        if (g_dbus_error_is_remote_error(error))
+        {
+            gchar* remote_error = g_dbus_error_get_remote_error(error);
+            g_debug("Remote error: %s", remote_error);
+            if (g_strcmp0(remote_error, "com.ubuntu.Upstart0_6.Error.AlreadyStarted") == 0)
+            {
+                auto urls = urlsToStrv(data->ptr->urls_);
+                second_exec(data->ptr->registry_->impl->_dbus.get(),                   /* DBus */
+                            data->ptr->registry_->impl->thread.getCancellable().get(), /* cancellable */
+                            data->ptr->primaryPid(),                                   /* primary pid */
+                            std::string(data->ptr->appId_).c_str(),                    /* appid */
+                            urls.get());                                               /* urls */
+            }
+
+            g_free(remote_error);
+        }
+        else
+        {
+            g_warning("Unable to emit event to start application: %s", error->message);
+        }
+        g_error_free(error);
+    }
+
+    delete data;
+}
+
+std::string Upstart::upstartJobPath(const std::string& job)
+{
+    auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry_->impl->jobs);
+    return manager->upstartJobPath(job);
+}
+
+}  // namespace instances
+
+namespace manager
+{
+
+Upstart::Upstart(std::shared_ptr<Registry> registry)
+    : Base(registry)
+{
+}
+
+Upstart::~Upstart()
+{
+}
+
+/** Launch an application and create a new Upstart instance object to track
+    its progress.
+
+    \param appId Application ID
+    \param job Upstart job name
+    \param instance Upstart instance name
+    \param urls URLs sent to the application (only on launch today)
+    \param mode Whether or not to setup the environment for testing
+    \param getenv A function to get additional environment variable when appropriate
+*/
+std::shared_ptr<Application::Instance> Upstart::launch(
+    const AppID& appId,
+    const std::string& job,
+    const std::string& instance,
+    const std::vector<Application::URL>& urls,
+    launchMode mode,
+    std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv)
+{
+    if (appId.empty())
+        return {};
+
+    auto registry = registry_.lock();
+    return registry->impl->thread.executeOnThread<std::shared_ptr<instance::Upstart>>(
+        [&]() -> std::shared_ptr<instance::Upstart> {
+            auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry->impl->jobs);
+            std::string appIdStr{appId};
+            g_debug("Initializing params for an new instance::Upstart for: %s", appIdStr.c_str());
+
+            tracepoint(ubuntu_app_launch, libual_start, appIdStr.c_str());
+
+            int timeout = 1;
+            if (ubuntu::app_launch::Registry::Impl::isWatchingAppStarting())
+            {
+                timeout = 0;
+            }
+
+            auto handshake = starting_handshake_start(appIdStr.c_str(), timeout);
+            if (handshake == nullptr)
+            {
+                g_warning("Unable to setup starting handshake");
+            }
+
+            /* Figure out the DBus path for the job */
+            auto jobpath = manager->upstartJobPath(job);
+
+            /* Build up our environment */
+            auto env = getenv();
+
+            env.emplace_back(std::make_pair("APP_ID", appIdStr));                           /* Application ID */
+            env.emplace_back(std::make_pair("APP_LAUNCHER_PID", std::to_string(getpid()))); /* Who we are, for bugs */
+
+            if (!urls.empty())
+            {
+                auto accumfunc = [](const std::string& prev, Application::URL thisurl) -> std::string {
+                    gchar* gescaped = g_shell_quote(thisurl.value().c_str());
+                    std::string escaped;
+                    if (gescaped != nullptr)
+                    {
+                        escaped = gescaped;
+                        g_free(gescaped);
+                    }
+                    else
+                    {
+                        g_warning("Unable to escape URL: %s", thisurl.value().c_str());
+                        return prev;
+                    }
+
+                    if (prev.empty())
+                    {
+                        return escaped;
+                    }
+                    else
+                    {
+                        return prev + " " + escaped;
+                    }
+                };
+                auto urlstring = std::accumulate(urls.begin(), urls.end(), std::string{}, accumfunc);
+                env.emplace_back(std::make_pair("APP_URIS", urlstring));
+            }
+
+            if (mode == launchMode::TEST)
+            {
+                env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
+            }
+
+            /* Convert to GVariant */
+            GVariantBuilder builder;
+            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+            for (const auto& envvar : env)
+            {
+                g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf(
+                                                          "%s=%s", envvar.first.c_str(), envvar.second.c_str())));
+            }
+
+            g_variant_builder_close(&builder);
+            g_variant_builder_add_value(&builder, g_variant_new_boolean(TRUE));
+
+            auto retval = std::make_shared<instance::Upstart>(appId, job, instance, urls, registry);
+            auto chelper = new instance::StartCHelper{};
+            chelper->ptr = retval;
+
+            tracepoint(ubuntu_app_launch, handshake_wait, appIdStr.c_str());
+            starting_handshake_wait(handshake);
+            tracepoint(ubuntu_app_launch, handshake_complete, appIdStr.c_str());
+
+            /* Call the job start function */
+            g_debug("Asking Upstart to start task for: %s", appIdStr.c_str());
+            g_dbus_connection_call(registry->impl->_dbus.get(),                   /* bus */
+                                   DBUS_SERVICE_UPSTART,                          /* service name */
+                                   jobpath.c_str(),                               /* Path */
+                                   DBUS_INTERFACE_UPSTART_JOB,                    /* interface */
+                                   "Start",                                       /* method */
+                                   g_variant_builder_end(&builder),               /* params */
+                                   nullptr,                                       /* return */
+                                   G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                   -1,                                            /* default timeout */
+                                   registry->impl->thread.getCancellable().get(), /* cancellable */
+                                   instance::Upstart::application_start_cb,       /* callback */
+                                   chelper                                        /* object */
+                                   );
+
+            tracepoint(ubuntu_app_launch, libual_start_message_sent, appIdStr.c_str());
+
+            return retval;
+        });
+}
+
+/** Special characters that could be an application name that
+    would activate in a regex */
+const static std::regex regexCharacters("([\\.\\-])");
+
+std::shared_ptr<Application::Instance> Upstart::existing(const AppID& appId,
+                                                         const std::string& job,
+                                                         const std::string& instance,
+                                                         const std::vector<Application::URL>& urls)
+{
+    return std::make_shared<instance::Upstart>(appId, job, instance, urls, registry_.lock());
+}
+
+std::vector<std::shared_ptr<instance::Base>> Upstart::instances(const AppID& appID, const std::string& job)
+{
+    std::vector<std::shared_ptr<instance::Base>> vect;
+    auto startsWith = std::string(appID);
+    if (job != "application-click")
+    {
+        startsWith += "-";
+    }
+
+    auto regexstr =
+        std::string{"^(?:"} + std::regex_replace(startsWith, regexCharacters, "\\$&") + std::string{")(\\d*)$"};
+    auto instanceRegex = std::regex(regexstr);
+
+    for (auto instance : upstartInstancesForJob(job))
+    {
+        std::smatch instanceMatch;
+        g_debug("Looking at job '%s' instance: %s", job.c_str(), instance.c_str());
+        if (std::regex_match(instance, instanceMatch, instanceRegex))
+        {
+            auto app = existing(appID, job, instanceMatch[1].str(), {});
+            vect.emplace_back(std::dynamic_pointer_cast<instance::Base>(app));
+        }
+    }
+
+    g_debug("App '%s' has %d instances", std::string(appID).c_str(), int(vect.size()));
+
+    return vect;
+}
+
+/** Initialize the CGManager connection, including a timeout to disconnect
+    as CGManager doesn't free resources entirely well. So it's better if
+    we connect and disconnect occationally */
+void Upstart::initCGManager()
+{
+    if (cgManager_)
+        return;
+
+    std::promise<std::shared_ptr<GDBusConnection>> promise;
+    auto future = promise.get_future();
+    auto registry = registry_.lock();
+
+    registry->impl->thread.executeOnThread([this, &promise, &registry]() {
+        bool use_session_bus = g_getenv("UBUNTU_APP_LAUNCH_CG_MANAGER_SESSION_BUS") != nullptr;
+        if (use_session_bus)
+        {
+            /* For working dbusmock */
+            g_debug("Connecting to CG Manager on session bus");
+            promise.set_value(registry->impl->_dbus);
+            return;
+        }
+
+        auto cancel =
+            std::shared_ptr<GCancellable>(g_cancellable_new(), [](GCancellable* cancel) { g_clear_object(&cancel); });
+
+        /* Ensure that we do not wait for more than a second */
+        registry->impl->thread.timeoutSeconds(std::chrono::seconds{1},
+                                              [cancel]() { g_cancellable_cancel(cancel.get()); });
+
+        g_dbus_connection_new_for_address(
+            CGMANAGER_DBUS_PATH,                           /* cgmanager path */
+            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, /* flags */
+            nullptr,                                       /* Auth Observer */
+            cancel.get(),                                  /* Cancellable */
+            [](GObject* obj, GAsyncResult* res, gpointer data) -> void {
+                GError* error = nullptr;
+                auto promise = reinterpret_cast<std::promise<std::shared_ptr<GDBusConnection>>*>(data);
+
+                auto gcon = g_dbus_connection_new_for_address_finish(res, &error);
+                if (error != nullptr)
+                {
+                    g_error_free(error);
+                }
+
+                auto con = std::shared_ptr<GDBusConnection>(gcon, [](GDBusConnection* con) { g_clear_object(&con); });
+                promise->set_value(con);
+            },
+            &promise);
+    });
+
+    cgManager_ = future.get();
+    registry->impl->thread.timeoutSeconds(std::chrono::seconds{10}, [this]() { cgManager_.reset(); });
+}
+
+/** Get a list of PIDs from a CGroup, uses the CGManager connection to list
+    all of the PIDs. It is important to note that this is an IPC call, so it can
+    by its nature, be racy. Once the message has been sent the group can change.
+    You should take that into account in your usage of it. */
+std::vector<pid_t> Upstart::pidsFromCgroup(const std::string& jobpath)
+{
+    initCGManager();
+    auto lmanager = cgManager_; /* Grab a local copy so we ensure it lasts through our lifetime */
+    auto registry = registry_.lock();
+
+    return registry->impl->thread.executeOnThread<std::vector<pid_t>>([&jobpath, lmanager]() -> std::vector<pid_t> {
+        GError* error = nullptr;
+        const gchar* name = g_getenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME");
+        std::string groupname;
+        if (!jobpath.empty())
+        {
+            groupname = "upstart/" + jobpath;
+        }
+
+        g_debug("Looking for cg manager '%s' group '%s'", name, groupname.c_str());
+
+        GVariant* vtpids = g_dbus_connection_call_sync(
+            lmanager.get(),                     /* connection */
+            name,                               /* bus name for direct connection is NULL */
+            "/org/linuxcontainers/cgmanager",   /* object */
+            "org.linuxcontainers.cgmanager0_0", /* interface */
+            "GetTasksRecursive",                /* method */
+            g_variant_new("(ss)", "freezer", groupname.empty() ? "" : groupname.c_str()), /* params */
+            G_VARIANT_TYPE("(ai)"),                                                       /* output */
+            G_DBUS_CALL_FLAGS_NONE,                                                       /* flags */
+            -1,                                                                           /* default timeout */
+            nullptr,                                                                      /* cancellable */
+            &error);                                                                      /* error */
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to get PID list from cgroup manager: %s", error->message);
+            g_error_free(error);
+            return {};
+        }
+
+        GVariant* vpids = g_variant_get_child_value(vtpids, 0);
+        GVariantIter iter;
+        g_variant_iter_init(&iter, vpids);
+        gint32 pid;
+        std::vector<pid_t> pids;
+
+        while (g_variant_iter_loop(&iter, "i", &pid))
+        {
+            pids.push_back(pid);
+        }
+
+        g_variant_unref(vpids);
+        g_variant_unref(vtpids);
+
+        return pids;
+    });
+}
+
+/** Looks to find the Upstart object path for a specific Upstart job. This first
+    checks the cache, and otherwise does the lookup on DBus. */
+std::string Upstart::upstartJobPath(const std::string& job)
+{
+    try
+    {
+        return upstartJobPathCache_.at(job);
+    }
+    catch (std::out_of_range& e)
+    {
+        auto registry = registry_.lock();
+        auto path = registry->impl->thread.executeOnThread<std::string>([this, &job, &registry]() -> std::string {
+            GError* error = nullptr;
+            GVariant* job_path_variant =
+                g_dbus_connection_call_sync(registry->impl->_dbus.get(),                   /* connection */
+                                            DBUS_SERVICE_UPSTART,                          /* service */
+                                            DBUS_PATH_UPSTART,                             /* path */
+                                            DBUS_INTERFACE_UPSTART,                        /* iface */
+                                            "GetJobByName",                                /* method */
+                                            g_variant_new("(s)", job.c_str()),             /* params */
+                                            G_VARIANT_TYPE("(o)"),                         /* return */
+                                            G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                            -1,                                            /* timeout: default */
+                                            registry->impl->thread.getCancellable().get(), /* cancellable */
+                                            &error);                                       /* error */
+
+            if (error != nullptr)
+            {
+                g_warning("Unable to find job '%s': %s", job.c_str(), error->message);
+                g_error_free(error);
+                return {};
+            }
+
+            gchar* job_path = nullptr;
+            g_variant_get(job_path_variant, "(o)", &job_path);
+            g_variant_unref(job_path_variant);
+
+            if (job_path != nullptr)
+            {
+                std::string path(job_path);
+                g_free(job_path);
+                return path;
+            }
+            else
+            {
+                return {};
+            }
+        });
+
+        upstartJobPathCache_[job] = path;
+        return path;
+    }
+}
+
+/** Queries Upstart to get all the instances of a given job. This
+    can take a while as the number of dbus calls is n+1. It is
+    rare that apps have many instances though. */
+std::list<std::string> Upstart::upstartInstancesForJob(const std::string& job)
+{
+    std::string jobpath = upstartJobPath(job);
+    if (jobpath.empty())
+    {
+        return {};
+    }
+
+    auto registry = registry_.lock();
+    return registry->impl->thread.executeOnThread<std::list<std::string>>(
+        [this, &job, &jobpath, &registry]() -> std::list<std::string> {
+            GError* error = nullptr;
+            GVariant* instance_tuple =
+                g_dbus_connection_call_sync(registry->impl->_dbus.get(),                   /* connection */
+                                            DBUS_SERVICE_UPSTART,                          /* service */
+                                            jobpath.c_str(),                               /* object path */
+                                            DBUS_INTERFACE_UPSTART_JOB,                    /* iface */
+                                            "GetAllInstances",                             /* method */
+                                            nullptr,                                       /* params */
+                                            G_VARIANT_TYPE("(ao)"),                        /* return type */
+                                            G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                            -1,                                            /* timeout: default */
+                                            registry->impl->thread.getCancellable().get(), /* cancellable */
+                                            &error);
+
+            if (error != nullptr)
+            {
+                g_warning("Unable to get instances of job '%s': %s", job.c_str(), error->message);
+                g_error_free(error);
+                return {};
+            }
+
+            if (instance_tuple == nullptr)
+            {
+                return {};
+            }
+
+            GVariant* instance_list = g_variant_get_child_value(instance_tuple, 0);
+            g_variant_unref(instance_tuple);
+
+            GVariantIter instance_iter;
+            g_variant_iter_init(&instance_iter, instance_list);
+            const gchar* instance_path = nullptr;
+            std::list<std::string> instances;
+
+            while (g_variant_iter_loop(&instance_iter, "&o", &instance_path))
+            {
+                GVariant* props_tuple =
+                    g_dbus_connection_call_sync(registry->impl->_dbus.get(),                           /* connection */
+                                                DBUS_SERVICE_UPSTART,                                  /* service */
+                                                instance_path,                                         /* object path */
+                                                "org.freedesktop.DBus.Properties",                     /* interface */
+                                                "GetAll",                                              /* method */
+                                                g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE), /* params */
+                                                G_VARIANT_TYPE("(a{sv})"),                             /* return type */
+                                                G_DBUS_CALL_FLAGS_NONE,                                /* flags */
+                                                -1,                                            /* timeout: default */
+                                                registry->impl->thread.getCancellable().get(), /* cancellable */
+                                                &error);
+
+                if (error != nullptr)
+                {
+                    g_warning("Unable to name of instance '%s': %s", instance_path, error->message);
+                    g_error_free(error);
+                    error = nullptr;
+                    continue;
+                }
+
+                GVariant* props_dict = g_variant_get_child_value(props_tuple, 0);
+
+                GVariant* namev = g_variant_lookup_value(props_dict, "name", G_VARIANT_TYPE_STRING);
+                if (namev != nullptr)
+                {
+                    auto name = g_variant_get_string(namev, NULL);
+                    g_debug("Adding instance for job '%s': %s", job.c_str(), name);
+                    instances.push_back(name);
+                    g_variant_unref(namev);
+                }
+
+                g_variant_unref(props_dict);
+                g_variant_unref(props_tuple);
+            }
+
+            g_variant_unref(instance_list);
+
+            return instances;
+        });
+}
+
+std::list<std::shared_ptr<Application>> Upstart::runningApps()
+{
+    std::list<std::string> instances;
+
+    /* Get all the legacy instances */
+    instances.splice(instances.begin(), upstartInstancesForJob("application-legacy"));
+    /* Get all the snap instances */
+    instances.splice(instances.begin(), upstartInstancesForJob("application-snap"));
+
+    /* Remove the instance ID */
+    std::transform(instances.begin(), instances.end(), instances.begin(), [](std::string& instancename) -> std::string {
+        static const std::regex instanceregex("^(.*)-[0-9]*$");
+        std::smatch match;
+        if (std::regex_match(instancename, match, instanceregex))
+        {
+            return match[1].str();
+        }
+        else
+        {
+            g_warning("Unable to match instance name: %s", instancename.c_str());
+            return {};
+        }
+    });
+
+    /* Deduplicate Set */
+    std::set<std::string> instanceset;
+    for (auto instance : instances)
+    {
+        if (!instance.empty())
+            instanceset.insert(instance);
+    }
+
+    /* Add in the click instances */
+    for (auto instance : upstartInstancesForJob("application-click"))
+    {
+        instanceset.insert(instance);
+    }
+
+    g_debug("Overall there are %d instances: %s", int(instanceset.size()),
+            std::accumulate(instanceset.begin(), instanceset.end(), std::string{},
+                            [](const std::string& instr, std::string instance) {
+                                return instr.empty() ? instance : instr + ", " + instance;
+                            })
+                .c_str());
+
+    /* Convert to Applications */
+    auto registry = registry_.lock();
+    std::list<std::shared_ptr<Application>> apps;
+    for (auto instance : instanceset)
+    {
+        auto appid = AppID::find(registry, instance);
+        auto app = Application::create(appid, registry);
+        apps.push_back(app);
+    }
+
+    return apps;
+}
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu
 
=== added file 'libubuntu-app-launch/jobs-upstart.h'
--- libubuntu-app-launch/jobs-upstart.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-upstart.h	2016-11-01 14:53:56 +0000
@@ -0,0 +1,75 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#pragma once
+
+#include "jobs-base.h"
+#include <gio/gio.h>
+#include <map>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace manager
+{
+
+class Upstart : public Base
+{
+public:
+    Upstart(std::shared_ptr<Registry> registry);
+    virtual ~Upstart();
+
+    virtual std::shared_ptr<Application::Instance> launch(
+        const AppID& appId,
+        const std::string& job,
+        const std::string& instance,
+        const std::vector<Application::URL>& urls,
+        launchMode mode,
+        std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv) override;
+    virtual std::shared_ptr<Application::Instance> existing(const AppID& appId,
+                                                            const std::string& job,
+                                                            const std::string& instance,
+                                                            const std::vector<Application::URL>& urls) override;
+
+    virtual std::list<std::shared_ptr<Application>> runningApps() override;
+
+    virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) override;
+
+    std::vector<pid_t> pidsFromCgroup(const std::string& jobpath);
+
+    std::list<std::string> upstartInstancesForJob(const std::string& job);
+    std::string upstartJobPath(const std::string& job);
+
+private:
+    void initCGManager();
+
+    std::shared_ptr<GDBusConnection> cgManager_;
+
+    /** Getting the Upstart job path is relatively expensive in
+        that it requires a DBus call. Worth keeping a cache of. */
+    std::map<std::string, std::string> upstartJobPathCache_;
+};
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu
 
=== modified file 'libubuntu-app-launch/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2016-09-23 22:30:51 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2016-11-01 14:53:56 +0000
@@ -19,8 +19,6 @@
 
 #include "registry-impl.h"
 #include "application-icon-finder.h"
-#include <cgmanager/cgmanager.h>
-#include <upstart.h>
 
 namespace ubuntu
 {
@@ -34,7 +32,7 @@
                  _clickDB.reset();
 
                  zgLog_.reset();
-                 cgManager_.reset();
+                 jobs.reset();
 
                  if (_dbus)
                      g_dbus_connection_flush_sync(_dbus.get(), nullptr, nullptr);
@@ -49,6 +47,14 @@
         return std::shared_ptr<GDBusConnection>(g_bus_get_sync(G_BUS_TYPE_SESSION, cancel.get(), nullptr),
                                                 [](GDBusConnection* bus) { g_clear_object(&bus); });
     });
+
+    /* Determine where we're getting the helper from */
+    oomHelper_ = OOM_HELPER;
+    auto goomHelper = g_getenv("UBUNTU_APP_LAUNCH_OOM_HELPER");
+    if (goomHelper != nullptr)
+    {
+        oomHelper_ = goomHelper;
+    }
 }
 
 void Registry::Impl::initClick()
@@ -145,7 +151,7 @@
         if (error != nullptr)
         {
             auto perror = std::shared_ptr<GError>(error, [](GError* error) { g_error_free(error); });
-            g_critical("Error parsing manifest for package '%s': %s", package.c_str(), perror->message);
+            g_debug("Error parsing manifest for package '%s': %s", package.c_str(), perror->message);
             return std::shared_ptr<JsonObject>();
         }
 
@@ -214,257 +220,6 @@
     });
 }
 
-/** Initialize the CGManager connection, including a timeout to disconnect
-    as CGManager doesn't free resources entirely well. So it's better if
-    we connect and disconnect occationally */
-void Registry::Impl::initCGManager()
-{
-    if (cgManager_)
-        return;
-
-    std::promise<std::shared_ptr<GDBusConnection>> promise;
-    auto future = promise.get_future();
-
-    thread.executeOnThread([this, &promise]() {
-        bool use_session_bus = g_getenv("UBUNTU_APP_LAUNCH_CG_MANAGER_SESSION_BUS") != nullptr;
-        if (use_session_bus)
-        {
-            /* For working dbusmock */
-            g_debug("Connecting to CG Manager on session bus");
-            promise.set_value(_dbus);
-            return;
-        }
-
-        auto cancel =
-            std::shared_ptr<GCancellable>(g_cancellable_new(), [](GCancellable* cancel) { g_clear_object(&cancel); });
-
-        /* Ensure that we do not wait for more than a second */
-        thread.timeoutSeconds(std::chrono::seconds{1}, [cancel]() { g_cancellable_cancel(cancel.get()); });
-
-        g_dbus_connection_new_for_address(
-            CGMANAGER_DBUS_PATH,                           /* cgmanager path */
-            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, /* flags */
-            nullptr,                                       /* Auth Observer */
-            cancel.get(),                                  /* Cancellable */
-            [](GObject* obj, GAsyncResult* res, gpointer data) -> void {
-                GError* error = nullptr;
-                auto promise = reinterpret_cast<std::promise<std::shared_ptr<GDBusConnection>>*>(data);
-
-                auto gcon = g_dbus_connection_new_for_address_finish(res, &error);
-                if (error != nullptr)
-                {
-                    g_error_free(error);
-                }
-
-                auto con = std::shared_ptr<GDBusConnection>(gcon, [](GDBusConnection* con) { g_clear_object(&con); });
-                promise->set_value(con);
-            },
-            &promise);
-    });
-
-    cgManager_ = future.get();
-    thread.timeoutSeconds(std::chrono::seconds{10}, [this]() { cgManager_.reset(); });
-}
-
-/** Get a list of PIDs from a CGroup, uses the CGManager connection to list
-    all of the PIDs. It is important to note that this is an IPC call, so it can
-    by its nature, be racy. Once the message has been sent the group can change.
-    You should take that into account in your usage of it. */
-std::vector<pid_t> Registry::Impl::pidsFromCgroup(const std::string& jobpath)
-{
-    initCGManager();
-    auto lmanager = cgManager_; /* Grab a local copy so we ensure it lasts through our lifetime */
-
-    return thread.executeOnThread<std::vector<pid_t>>([&jobpath, lmanager]() -> std::vector<pid_t> {
-        GError* error = nullptr;
-        const gchar* name = g_getenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME");
-        std::string groupname;
-        if (!jobpath.empty())
-        {
-            groupname = "upstart/" + jobpath;
-        }
-
-        g_debug("Looking for cg manager '%s' group '%s'", name, groupname.c_str());
-
-        GVariant* vtpids = g_dbus_connection_call_sync(
-            lmanager.get(),                     /* connection */
-            name,                               /* bus name for direct connection is NULL */
-            "/org/linuxcontainers/cgmanager",   /* object */
-            "org.linuxcontainers.cgmanager0_0", /* interface */
-            "GetTasksRecursive",                /* method */
-            g_variant_new("(ss)", "freezer", groupname.empty() ? "" : groupname.c_str()), /* params */
-            G_VARIANT_TYPE("(ai)"),                                                       /* output */
-            G_DBUS_CALL_FLAGS_NONE,                                                       /* flags */
-            -1,                                                                           /* default timeout */
-            nullptr,                                                                      /* cancellable */
-            &error);                                                                      /* error */
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to get PID list from cgroup manager: %s", error->message);
-            g_error_free(error);
-            return {};
-        }
-
-        GVariant* vpids = g_variant_get_child_value(vtpids, 0);
-        GVariantIter iter;
-        g_variant_iter_init(&iter, vpids);
-        gint32 pid;
-        std::vector<pid_t> pids;
-
-        while (g_variant_iter_loop(&iter, "i", &pid))
-        {
-            pids.push_back(pid);
-        }
-
-        g_variant_unref(vpids);
-        g_variant_unref(vtpids);
-
-        return pids;
-    });
-}
-
-/** Looks to find the Upstart object path for a specific Upstart job. This first
-    checks the cache, and otherwise does the lookup on DBus. */
-std::string Registry::Impl::upstartJobPath(const std::string& job)
-{
-    try
-    {
-        return upstartJobPathCache_.at(job);
-    }
-    catch (std::out_of_range& e)
-    {
-        auto path = thread.executeOnThread<std::string>([this, &job]() -> std::string {
-            GError* error = nullptr;
-            GVariant* job_path_variant = g_dbus_connection_call_sync(_dbus.get(),                       /* connection */
-                                                                     DBUS_SERVICE_UPSTART,              /* service */
-                                                                     DBUS_PATH_UPSTART,                 /* path */
-                                                                     DBUS_INTERFACE_UPSTART,            /* iface */
-                                                                     "GetJobByName",                    /* method */
-                                                                     g_variant_new("(s)", job.c_str()), /* params */
-                                                                     G_VARIANT_TYPE("(o)"),             /* return */
-                                                                     G_DBUS_CALL_FLAGS_NONE,            /* flags */
-                                                                     -1, /* timeout: default */
-                                                                     thread.getCancellable().get(), /* cancellable */
-                                                                     &error);                       /* error */
-
-            if (error != nullptr)
-            {
-                g_warning("Unable to find job '%s': %s", job.c_str(), error->message);
-                g_error_free(error);
-                return {};
-            }
-
-            gchar* job_path = nullptr;
-            g_variant_get(job_path_variant, "(o)", &job_path);
-            g_variant_unref(job_path_variant);
-
-            if (job_path != nullptr)
-            {
-                std::string path(job_path);
-                g_free(job_path);
-                return path;
-            }
-            else
-            {
-                return {};
-            }
-        });
-
-        upstartJobPathCache_[job] = path;
-        return path;
-    }
-}
-
-/** Queries Upstart to get all the instances of a given job. This
-    can take a while as the number of dbus calls is n+1. It is
-    rare that apps have many instances though. */
-std::list<std::string> Registry::Impl::upstartInstancesForJob(const std::string& job)
-{
-    std::string jobpath = upstartJobPath(job);
-    if (jobpath.empty())
-    {
-        return {};
-    }
-
-    return thread.executeOnThread<std::list<std::string>>([this, &job, &jobpath]() -> std::list<std::string> {
-        GError* error = nullptr;
-        GVariant* instance_tuple = g_dbus_connection_call_sync(_dbus.get(),                   /* connection */
-                                                               DBUS_SERVICE_UPSTART,          /* service */
-                                                               jobpath.c_str(),               /* object path */
-                                                               DBUS_INTERFACE_UPSTART_JOB,    /* iface */
-                                                               "GetAllInstances",             /* method */
-                                                               nullptr,                       /* params */
-                                                               G_VARIANT_TYPE("(ao)"),        /* return type */
-                                                               G_DBUS_CALL_FLAGS_NONE,        /* flags */
-                                                               -1,                            /* timeout: default */
-                                                               thread.getCancellable().get(), /* cancellable */
-                                                               &error);
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to get instances of job '%s': %s", job.c_str(), error->message);
-            g_error_free(error);
-            return {};
-        }
-
-        if (instance_tuple == nullptr)
-        {
-            return {};
-        }
-
-        GVariant* instance_list = g_variant_get_child_value(instance_tuple, 0);
-        g_variant_unref(instance_tuple);
-
-        GVariantIter instance_iter;
-        g_variant_iter_init(&instance_iter, instance_list);
-        const gchar* instance_path = nullptr;
-        std::list<std::string> instances;
-
-        while (g_variant_iter_loop(&instance_iter, "&o", &instance_path))
-        {
-            GVariant* props_tuple =
-                g_dbus_connection_call_sync(_dbus.get(),                                           /* connection */
-                                            DBUS_SERVICE_UPSTART,                                  /* service */
-                                            instance_path,                                         /* object path */
-                                            "org.freedesktop.DBus.Properties",                     /* interface */
-                                            "GetAll",                                              /* method */
-                                            g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE), /* params */
-                                            G_VARIANT_TYPE("(a{sv})"),                             /* return type */
-                                            G_DBUS_CALL_FLAGS_NONE,                                /* flags */
-                                            -1,                            /* timeout: default */
-                                            thread.getCancellable().get(), /* cancellable */
-                                            &error);
-
-            if (error != nullptr)
-            {
-                g_warning("Unable to name of instance '%s': %s", instance_path, error->message);
-                g_error_free(error);
-                error = nullptr;
-                continue;
-            }
-
-            GVariant* props_dict = g_variant_get_child_value(props_tuple, 0);
-
-            GVariant* namev = g_variant_lookup_value(props_dict, "name", G_VARIANT_TYPE_STRING);
-            if (namev != nullptr)
-            {
-                auto name = g_variant_get_string(namev, NULL);
-                g_debug("Adding instance for job '%s': %s", job.c_str(), name);
-                instances.push_back(name);
-                g_variant_unref(namev);
-            }
-
-            g_variant_unref(props_dict);
-            g_variant_unref(props_tuple);
-        }
-
-        g_variant_unref(instance_list);
-
-        return instances;
-    });
-}
-
 /** Send an event to Zietgeist using the registry thread so that
         the callback comes back in the right place. */
 void Registry::Impl::zgSendEvent(AppID appid, const std::string& eventtype)
 
=== modified file 'libubuntu-app-launch/registry-impl.h'
--- libubuntu-app-launch/registry-impl.h	2016-09-23 22:30:51 +0000
+++ libubuntu-app-launch/registry-impl.h	2016-11-01 14:53:56 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "glib-thread.h"
+#include "jobs-base.h"
 #include "registry.h"
 #include "snapd-info.h"
 #include <click.h>
@@ -69,15 +70,11 @@
     snapd::Info snapdInfo;
 #endif
 
+    std::shared_ptr<jobs::manager::Base> jobs;
+
     std::shared_ptr<IconFinder> getIconFinder(std::string basePath);
 
-    void zgSendEvent(AppID appid, const std::string& eventtype);
-
-    std::vector<pid_t> pidsFromCgroup(const std::string& jobpath);
-
-    /* Upstart Jobs */
-    std::list<std::string> upstartInstancesForJob(const std::string& job);
-    std::string upstartJobPath(const std::string& job);
+    virtual void zgSendEvent(AppID appid, const std::string& eventtype);
 
     static std::string printJson(std::shared_ptr<JsonObject> jsonobj);
     static std::string printJson(std::shared_ptr<JsonNode> jsonnode);
@@ -88,6 +85,11 @@
     static void watchingAppStarting(bool rWatching);
     static bool isWatchingAppStarting();
 
+    const std::string oomHelper()
+    {
+        return oomHelper_;
+    }
+
 private:
     Registry* _registry;
 #if 0
@@ -101,15 +103,14 @@
 
     std::shared_ptr<ZeitgeistLog> zgLog_;
 
-    std::shared_ptr<GDBusConnection> cgManager_;
-
-    void initCGManager();
-
     std::unordered_map<std::string, std::shared_ptr<IconFinder>> _iconFinders;
 
     /** Getting the Upstart job path is relatively expensive in
         that it requires a DBus call. Worth keeping a cache of. */
     std::map<std::string, std::string> upstartJobPathCache_;
+
+    /** Path to the OOM Helper */
+    std::string oomHelper_;
 };
 
 }  // namespace app_launch
 
=== modified file 'libubuntu-app-launch/registry.cpp'
--- libubuntu-app-launch/registry.cpp	2016-08-26 17:33:34 +0000
+++ libubuntu-app-launch/registry.cpp	2016-11-01 14:53:56 +0000
@@ -47,61 +47,14 @@
 {
 }
 
-std::list<std::shared_ptr<Application>> Registry::runningApps(std::shared_ptr<Registry> connection)
+std::list<std::shared_ptr<Application>> Registry::runningApps(std::shared_ptr<Registry> registry)
 {
-    std::list<std::string> instances;
-
-    /* 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 {
-        static const std::regex instanceregex("^(.*)-[0-9]*$");
-        std::smatch match;
-        if (std::regex_match(instancename, match, instanceregex))
-        {
-            return match[1].str();
-        }
-        else
-        {
-            g_warning("Unable to match instance name: %s", instancename.c_str());
-            return {};
-        }
-    });
-
-    /* Deduplicate Set */
-    std::set<std::string> instanceset;
-    for (auto instance : instances)
-    {
-        if (!instance.empty())
-            instanceset.insert(instance);
-    }
-
-    /* Add in the click instances */
-    for (auto instance : connection->impl->upstartInstancesForJob("application-click"))
-    {
-        instanceset.insert(instance);
-    }
-
-    g_debug("Overall there are %d instances: %s", int(instanceset.size()),
-            std::accumulate(instanceset.begin(), instanceset.end(), std::string{},
-                            [](const std::string &instr, std::string instance) {
-                                return instr.empty() ? instance : instr + ", " + instance;
-                            })
-                .c_str());
-
-    /* Convert to Applications */
-    std::list<std::shared_ptr<Application>> apps;
-    for (auto instance : instanceset)
-    {
-        auto appid = AppID::find(connection, instance);
-        auto app = Application::create(appid, connection);
-        apps.push_back(app);
-    }
-
-    return apps;
+    if (!registry->impl->jobs)
+    {
+        registry->impl->jobs = jobs::manager::Base::determineFactory(registry);
+    }
+
+    return registry->impl->jobs->runningApps();
 }
 
 std::list<std::shared_ptr<Application>> Registry::installedApps(std::shared_ptr<Registry> connection)
 
=== modified file 'libubuntu-app-launch/snapd-info.cpp'
--- libubuntu-app-launch/snapd-info.cpp	2016-10-03 23:54:08 +0000
+++ libubuntu-app-launch/snapd-info.cpp	2016-11-01 14:53:56 +0000
@@ -170,7 +170,7 @@
     }
     catch (std::runtime_error &e)
     {
-        g_warning("Unable to get snap information for '%s': %s", package.value().c_str(), e.what());
+        g_debug("Unable to get snap information for '%s': %s", package.value().c_str(), e.what());
         return {};
     }
 }
 
=== modified file 'libubuntu-app-launch/ubuntu-app-launch.cpp'
--- libubuntu-app-launch/ubuntu-app-launch.cpp	2016-09-14 21:58:39 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.cpp	2016-11-01 14:53:56 +0000
@@ -1746,7 +1746,11 @@
 	/* The exec value */
 	gchar * envstr = NULL;
 	if (demangler) {
-		envstr = g_strdup_printf("APP_EXEC=%s %s", DEMANGLER_PATH, execline);
+		const gchar * demangler_path = g_getenv("UBUNTU_APP_LAUNCH_DEMANGLER");
+		if (demangler_path == nullptr) {
+			demangler_path = DEMANGLER_PATH;
+		}
+		envstr = g_strdup_printf("APP_EXEC=%s %s", demangler_path, execline);
 	} else {
 		envstr = g_strdup_printf("APP_EXEC=%s", execline);
 	}
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-09-14 16:43:36 +0000
+++ tests/CMakeLists.txt	2016-11-01 14:53:56 +0000
@@ -12,23 +12,21 @@
 
 include_directories(${GTEST_INCLUDE_DIR})
 
-add_library (gtest STATIC
-             ${GTEST_SOURCE_DIR}/gtest-all.cc
-             ${GTEST_SOURCE_DIR}/gtest_main.cc)
+add_subdirectory("/usr/src/gmock" gmock)
 
 # Helper test
 
 add_executable (helper-test helper-test.cc)
 add_definitions ( -DCMAKE_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}" )
 add_definitions ( -DCMAKE_BINARY_DIR="${CMAKE_CURRENT_BINARY_DIR}" )
-target_link_libraries (helper-test helpers gtest ${GTEST_LIBS} ${DBUSTEST_LIBRARIES})
+target_link_libraries (helper-test helpers gtest_main ${GTEST_LIBS} ${DBUSTEST_LIBRARIES})
 
 add_test (helper-test helper-test)
 
 # Helper test
 
 add_executable (helper-handshake-test helper-handshake-test.cc)
-target_link_libraries (helper-handshake-test helpers gtest ${GTEST_LIBS})
+target_link_libraries (helper-handshake-test helpers gtest_main ${GTEST_LIBS})
 
 add_test (helper-handshake-test helper-handshake-test)
 
@@ -45,13 +43,13 @@
 add_executable (libual-test
 	libual-test.cc
 	mir-mock.cpp)
-target_link_libraries (libual-test gtest ${GTEST_LIBS} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} ubuntu-launcher)
+target_link_libraries (libual-test gtest_main ${GTEST_LIBS} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} ubuntu-launcher)
 
 add_executable (libual-cpp-test
 	libual-cpp-test.cc
 	${CMAKE_SOURCE_DIR}/libubuntu-app-launch/glib-thread.cpp
 	mir-mock.cpp)
-target_link_libraries (libual-cpp-test gtest ${GTEST_LIBS} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} ubuntu-launcher)
+target_link_libraries (libual-cpp-test gtest_main ${GTEST_LIBS} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} ubuntu-launcher)
 
 add_executable (data-spew
 	data-spew.c)
@@ -63,13 +61,21 @@
 add_test (NAME libual-test COMMAND libual-test)
 add_test (NAME libual-cpp-test COMMAND libual-cpp-test)
 
+# Jobs Base Test
+
+add_executable (jobs-base-test
+	jobs-base-test.cpp)
+target_link_libraries (jobs-base-test gmock_main ${GTEST_LIBS} launcher-static)
+
+add_test(NAME jobs-base-test COMMAND jobs-base-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)
+target_link_libraries (snapd-info-test gtest_main ${GTEST_LIBS} launcher-static)
 add_test (NAME snapd-info-test COMMAND snapd-info-test)
 endif()
 
@@ -77,7 +83,7 @@
 
 add_executable (list-apps
 	list-apps.cpp)
-target_link_libraries (list-apps gtest ${GTEST_LIBS} launcher-static)
+target_link_libraries (list-apps gtest_main ${GTEST_LIBS} launcher-static)
 add_test (NAME list-apps COMMAND ${CMAKE_CURRENT_BINARY_DIR}/list-apps)
 
 # Application Info Desktop
@@ -85,7 +91,7 @@
 add_executable (application-info-desktop-test
   application-info-desktop.cpp
 )
-target_link_libraries (application-info-desktop-test gtest ${GTEST_LIBS} launcher-static)
+target_link_libraries (application-info-desktop-test gtest_main ${GTEST_LIBS} launcher-static)
 
 add_test (NAME application-info-desktop-test COMMAND application-info-desktop-test)
 
@@ -97,7 +103,7 @@
 
   #sources
   ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/application-icon-finder.cpp)
-target_link_libraries (application-icon-finder-test gtest ${GTEST_LIBS} ubuntu-launcher)
+target_link_libraries (application-icon-finder-test gtest_main ${GTEST_LIBS} ubuntu-launcher)
 
 add_test (NAME application-icon-finder-test COMMAND application-icon-finder-test)
 
@@ -109,7 +115,7 @@
 
 add_executable (failure-test
 	failure-test.cc)
-target_link_libraries (failure-test gtest ${GTEST_LIBS} ubuntu-launcher)
+target_link_libraries (failure-test gtest_main ${GTEST_LIBS} ubuntu-launcher)
 add_test (failure-test failure-test)
 
 # ZG Test
@@ -118,7 +124,7 @@
 
 add_executable (zg-test
 	zg-test.cc)
-target_link_libraries (zg-test gtest ${GTEST_LIBS} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
+target_link_libraries (zg-test gtest_main ${GTEST_LIBS} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
 add_test (zg-test zg-test)
 
 # Exec Line Exec Test
@@ -130,7 +136,7 @@
 
 add_executable (exec-util-test
 	exec-util-test.cc)
-target_link_libraries (exec-util-test gtest ubuntu-launcher ${GTEST_LIBS} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
+target_link_libraries (exec-util-test gtest_main ubuntu-launcher ${GTEST_LIBS} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
 add_test (exec-util-test exec-util-test)
 
 # CGroup Reap Test
@@ -139,7 +145,7 @@
 
 add_executable (cgroup-reap-test
 	cgroup-reap-test.cc)
-target_link_libraries (cgroup-reap-test gtest ${GTEST_LIBS} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
+target_link_libraries (cgroup-reap-test gtest_main ${GTEST_LIBS} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
 add_test (cgroup-reap-test cgroup-reap-test)
 
 # Desktop Hook Test
@@ -161,6 +167,7 @@
 	libual-cpp-test.cc
 	list-apps.cpp
 	eventually-fixture.h
+	jobs-base-test.cpp
 	snapd-info-test.cpp
 	snapd-mock.h
 	zg-test.cc
 
=== modified file 'tests/exec-util-test.cc'
--- tests/exec-util-test.cc	2016-09-15 17:13:04 +0000
+++ tests/exec-util-test.cc	2016-11-01 14:53:56 +0000
@@ -45,6 +45,7 @@
 			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);
+			g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
 
 			service = dbus_test_service_new(NULL);
 
@@ -184,12 +185,15 @@
 			EXPECT_STREQ("grep", value); }},
 		{"APP_ID", [](const gchar * value) {
 			EXPECT_STREQ("com.test.good_application_1.2.3", value); }},
+		{"APP_EXEC_POLICY", [](const gchar * value) {
+			EXPECT_STREQ("com.test.good_application_1.2.3", value); }},
 		{"APP_LAUNCHER_PID", [](const gchar * value) {
 			EXPECT_EQ(getpid(), atoi(value)); }},
 		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
 			EXPECT_STREQ(APP_DIR "/application.desktop", value); }},
 		{"APP_XMIR_ENABLE", [](const gchar * value) {
 			EXPECT_STREQ("0", value); }},
+		{"QML2_IMPORT_PATH", nocheck},
 	});
 
 #undef APP_DIR
@@ -267,10 +271,13 @@
 		{"APP_EXEC", nocheck},
 		{"APP_ID", [](const gchar * value) {
 			EXPECT_STREQ("com.test.mir_mir_1", value); }},
+		{"APP_EXEC_POLICY", [](const gchar * value) {
+			EXPECT_STREQ("com.test.mir_mir_1", value); }},
 		{"APP_LAUNCHER_PID", nocheck},
 		{"APP_DESKTOP_FILE_PATH", nocheck},
 		{"APP_XMIR_ENABLE", [](const gchar * value) {
 			EXPECT_STREQ("1", value); }},
+		{"QML2_IMPORT_PATH", nocheck},
 	});
 }
 
@@ -289,10 +296,13 @@
 		{"APP_EXEC", nocheck},
 		{"APP_ID", [](const gchar * value) {
 			EXPECT_STREQ("com.test.mir_nomir_1", value); }},
+		{"APP_EXEC_POLICY", [](const gchar * value) {
+			EXPECT_STREQ("com.test.mir_nomir_1", value); }},
 		{"APP_LAUNCHER_PID", nocheck},
 		{"APP_DESKTOP_FILE_PATH", nocheck},
 		{"APP_XMIR_ENABLE", [](const gchar * value) {
 			EXPECT_STREQ("0", value); }},
+		{"QML2_IMPORT_PATH", nocheck},
 	});
 }
 
 
=== added file 'tests/jobs-base-test.cpp'
--- tests/jobs-base-test.cpp	1970-01-01 00:00:00 +0000
+++ tests/jobs-base-test.cpp	2016-11-01 14:53:56 +0000
@@ -0,0 +1,364 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#include "jobs-base.h"
+#include "appid.h"
+#include "registry-impl.h"
+#include "registry.h"
+
+#include "eventually-fixture.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+class RegistryImplMock : public ubuntu::app_launch::Registry::Impl
+{
+public:
+    RegistryImplMock(ubuntu::app_launch::Registry* reg)
+        : ubuntu::app_launch::Registry::Impl(reg)
+    {
+    }
+
+    MOCK_METHOD2(zgSendEvent, void(ubuntu::app_launch::AppID, const std::string& eventtype));
+};
+
+class RegistryMock : public ubuntu::app_launch::Registry
+{
+public:
+    RegistryMock()
+    {
+        impl = std::unique_ptr<RegistryImplMock>(new RegistryImplMock(this));
+    }
+};
+
+class instanceMock : public ubuntu::app_launch::jobs::instance::Base
+{
+public:
+    instanceMock(const ubuntu::app_launch::AppID& appId,
+                 const std::string& job,
+                 const std::string& instance,
+                 const std::vector<ubuntu::app_launch::Application::URL>& urls,
+                 const std::shared_ptr<ubuntu::app_launch::Registry>& registry)
+        : ubuntu::app_launch::jobs::instance::Base(appId, job, instance, urls, registry)
+    {
+    }
+
+    MOCK_METHOD0(primaryPid, pid_t());
+    MOCK_METHOD0(logPath, std::string());
+    MOCK_METHOD0(pids, std::vector<pid_t>());
+
+    MOCK_METHOD0(stop, void());
+};
+
+class SpewMaster
+{
+public:
+    SpewMaster()
+        : thread(
+              [this]() {
+                  gint spewstdout = 0;
+                  std::array<const gchar*, 2> spewline{SPEW_UTILITY, nullptr};
+                  ASSERT_TRUE(g_spawn_async_with_pipes(NULL,                    /* directory */
+                                                       (char**)spewline.data(), /* command line */
+                                                       NULL,                    /* environment */
+                                                       G_SPAWN_DEFAULT,         /* flags */
+                                                       NULL,                    /* child setup */
+                                                       NULL,                    /* child setup */
+                                                       &pid_,                   /* pid */
+                                                       NULL,                    /* stdin */
+                                                       &spewstdout,             /* stdout */
+                                                       NULL,                    /* stderr */
+                                                       NULL));                  /* error */
+
+                  spewoutchan = g_io_channel_unix_new(spewstdout);
+                  g_io_channel_set_flags(spewoutchan, G_IO_FLAG_NONBLOCK, NULL);
+
+                  iosource = g_io_create_watch(spewoutchan, G_IO_IN);
+                  g_source_set_callback(iosource, (GSourceFunc)datain, this, nullptr);
+                  g_source_attach(iosource, g_main_context_get_thread_default());
+
+                  /* Setup our OOM adjust file */
+                  gchar* procdir = g_strdup_printf(CMAKE_BINARY_DIR "/jobs-base-proc/%d", pid_);
+                  ASSERT_EQ(0, g_mkdir_with_parents(procdir, 0700));
+                  oomadjfile = g_strdup_printf("%s/oom_score_adj", procdir);
+                  g_free(procdir);
+                  ASSERT_TRUE(g_file_set_contents(oomadjfile, "0", -1, NULL));
+              },
+              [this]() {
+                  /* Clean up */
+                  gchar* killstr = g_strdup_printf("kill -9 %d", pid_);
+                  ASSERT_TRUE(g_spawn_command_line_sync(killstr, NULL, NULL, NULL, NULL));
+                  g_free(killstr);
+
+                  g_source_destroy(iosource);
+                  g_io_channel_unref(spewoutchan);
+                  g_clear_pointer(&oomadjfile, g_free);
+              })
+    {
+        datacnt_ = 0;
+    }
+
+    ~SpewMaster()
+    {
+    }
+
+    std::string oomScore()
+    {
+        gchar* oomvalue = nullptr;
+        g_file_get_contents(oomadjfile, &oomvalue, nullptr, nullptr);
+        if (oomvalue != nullptr)
+        {
+            return std::string(oomvalue);
+        }
+        else
+        {
+            return {};
+        }
+    }
+
+    GPid pid()
+    {
+        return pid_;
+    }
+
+    gsize dataCnt()
+    {
+        g_debug("Data Count for %d: %d", pid_, int(datacnt_));
+        return datacnt_;
+    }
+
+    void reset()
+    {
+        bool endofqueue = thread.executeOnThread<bool>([this]() {
+            while (G_IO_STATUS_AGAIN == g_io_channel_flush(spewoutchan, nullptr))
+                ;
+            return true; /* the main loop has processed */
+        });
+        g_debug("Reset %d", pid_);
+        if (endofqueue)
+            datacnt_ = 0;
+        else
+            g_warning("Unable to clear mainloop on reset");
+    }
+
+    std::atomic<gsize> datacnt_;
+
+private:
+    GPid pid_ = 0;
+    gchar* oomadjfile = nullptr;
+    GIOChannel* spewoutchan = nullptr;
+    GSource* iosource = nullptr;
+    GLib::ContextThread thread;
+
+    static gboolean datain(GIOChannel* source, GIOCondition cond, gpointer data)
+    {
+        auto spew = static_cast<SpewMaster*>(data);
+        gchar* str = NULL;
+        gsize len = 0;
+        GError* error = NULL;
+
+        g_io_channel_read_line(source, &str, &len, NULL, &error);
+        g_free(str);
+
+        if (error != NULL)
+        {
+            g_warning("Unable to read from channel: %s", error->message);
+            g_error_free(error);
+        }
+
+        spew->datacnt_ += len;
+
+        return TRUE;
+    }
+};
+
+class JobBaseTest : public EventuallyFixture
+{
+protected:
+    std::shared_ptr<RegistryMock> registry;
+
+    virtual void SetUp()
+    {
+        registry = std::make_shared<RegistryMock>();
+    }
+
+    virtual void TearDown()
+    {
+        registry.reset();
+    }
+
+    ubuntu::app_launch::AppID simpleAppID()
+    {
+        return {ubuntu::app_launch::AppID::Package::from_raw("package"),
+                ubuntu::app_launch::AppID::AppName::from_raw("appname"),
+                ubuntu::app_launch::AppID::Version::from_raw("version")};
+    }
+
+    std::shared_ptr<instanceMock> simpleInstance()
+    {
+        return std::make_shared<instanceMock>(simpleAppID(), "application-job", "1234567890",
+                                              std::vector<ubuntu::app_launch::Application::URL>{}, registry);
+    }
+};
+
+TEST_F(JobBaseTest, InitTest)
+{
+    auto instance = simpleInstance();
+
+    instance.reset();
+}
+
+TEST_F(JobBaseTest, isRunning)
+{
+    auto instance = simpleInstance();
+
+    EXPECT_CALL(*instance, primaryPid()).WillOnce(testing::Return(0));
+
+    EXPECT_FALSE(instance->isRunning());
+
+    EXPECT_CALL(*instance, primaryPid()).WillOnce(testing::Return(100));
+
+    EXPECT_TRUE(instance->isRunning());
+}
+
+TEST_F(JobBaseTest, pauseResume)
+{
+    g_setenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH", CMAKE_BINARY_DIR "/jobs-base-proc", TRUE);
+
+    /* Setup some spew */
+    SpewMaster spew;
+    std::vector<pid_t> pids{spew.pid()};
+
+    /* Build our instance */
+    auto instance = simpleInstance();
+    EXPECT_CALL(*instance, pids()).WillRepeatedly(testing::Return(pids));
+
+    /* Setup registry */
+    EXPECT_CALL(dynamic_cast<RegistryImplMock&>(*registry->impl), zgSendEvent(simpleAppID(), ZEITGEIST_ZG_LEAVE_EVENT))
+        .WillOnce(testing::Return());
+
+    /* Make sure it is running */
+    EXPECT_EVENTUALLY_NE(0, spew.datacnt_);
+
+    /*** Do Pause ***/
+    instance->pause();
+
+    spew.reset();
+    pause(100);  // give spew a chance to send data if it is running
+
+    EXPECT_EQ(0, spew.dataCnt());
+
+    EXPECT_EQ(std::to_string(int(ubuntu::app_launch::oom::paused())), spew.oomScore());
+
+    /* Setup for Resume */
+    EXPECT_CALL(dynamic_cast<RegistryImplMock&>(*registry->impl), zgSendEvent(simpleAppID(), ZEITGEIST_ZG_ACCESS_EVENT))
+        .WillOnce(testing::Return());
+
+    spew.reset();
+    EXPECT_EQ(0, spew.dataCnt());
+
+    /*** Do Resume ***/
+    instance->resume();
+
+    EXPECT_EVENTUALLY_NE(0, spew.datacnt_);
+
+    EXPECT_EQ(std::to_string(int(ubuntu::app_launch::oom::focused())), spew.oomScore());
+}
+
+TEST_F(JobBaseTest, pauseResumeNone)
+{
+    std::vector<pid_t> pids{};
+
+    /* Build our instance */
+    auto instance = simpleInstance();
+    EXPECT_CALL(*instance, pids()).WillRepeatedly(testing::Return(pids));
+
+    /* Setup registry */
+    EXPECT_CALL(dynamic_cast<RegistryImplMock&>(*registry->impl), zgSendEvent(simpleAppID(), ZEITGEIST_ZG_LEAVE_EVENT))
+        .WillOnce(testing::Return());
+
+    /*** Do Pause ***/
+    instance->pause();
+
+    /* Setup for Resume */
+    EXPECT_CALL(dynamic_cast<RegistryImplMock&>(*registry->impl), zgSendEvent(simpleAppID(), ZEITGEIST_ZG_ACCESS_EVENT))
+        .WillOnce(testing::Return());
+
+    /*** Do Resume ***/
+    instance->resume();
+}
+
+TEST_F(JobBaseTest, pauseResumeMany)
+{
+    g_setenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH", CMAKE_BINARY_DIR "/jobs-base-proc", TRUE);
+