Merge lp:~ted/ubuntu-app-launch/rm-rf-upstart into lp:ubuntu-app-launch

[Ted Gould]

Remove Upstart

Removes upstart implementations and dependencies. The tests do not work and are fixed in the rm-rf-click branch. They should be landed together.

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

FAILED: Continuous integration, rev:295
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/233/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1705/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1712
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1486/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1486/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1486/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1486/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1486/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1486/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:299
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/235/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1721/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1728
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1503/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1503/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1503/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1503/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1503/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1503/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:305
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/258/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1783/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1790
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1566/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1566/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1566/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1566/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1566/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1566/console

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

review: Needs Fixing (continuous-integration)

[lp:~ted/ubuntu-app-launch/rm-rf-upstart]

306. By Ted Gould on 2017-03-18

Drop CG Manager variables

307. By Ted Gould on 2017-03-18

Grab upstream fixes

308. By Ted Gould on 2017-03-18

Remove Upstart objects from docs

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

FAILED: Continuous integration, rev:306
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/266/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1828/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1835
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1611/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1611/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1611/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1611/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1611/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1611/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:308
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/268/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1830/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1837
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1613/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1613/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1613/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1613/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1613/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1613/console

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

review: Needs Fixing (continuous-integration)

[lp:~ted/ubuntu-app-launch/rm-rf-upstart]

309. By Ted Gould on 2017-03-21

Merge updated jobs-helpers

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

FAILED: Continuous integration, rev:309
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/279/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1849/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1856
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1632/console

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

review: Needs Fixing (continuous-integration)

[Pete Woods (pete-woods)]

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-03-21 03:20:55 +0000
+++ CMakeLists.txt	2017-03-21 03:20:55 +0000
@@ -79,9 +79,6 @@
 pkg_check_modules(CLICK REQUIRED click-0.4>=0.4.18)
 include_directories(${CLICK_INCLUDE_DIRS})
 
-pkg_check_modules(LIBUPSTART REQUIRED libupstart)
-include_directories(${LIBUPSTART_INCLUDE_DIRS})
-
 pkg_check_modules(DBUS REQUIRED dbus-1)
 include_directories(${DBUS_INCLUDE_DIRS})
 
@@ -130,62 +127,6 @@
 install(TARGETS desktop-hook RUNTIME DESTINATION "${pkglibexecdir}")
 
 ####################
-# exec-line-exec
-####################
-
-add_lttng_gen_tp(NAME exec-line-exec-trace)
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
-add_executable(exec-line-exec exec-line-exec.c "${CMAKE_CURRENT_BINARY_DIR}/exec-line-exec-trace.c")
-set_target_properties(exec-line-exec PROPERTIES OUTPUT_NAME "exec-line-exec")
-target_link_libraries(exec-line-exec helpers ${LTTNG_LIBRARIES})
-install(TARGETS exec-line-exec RUNTIME DESTINATION "${pkglibexecdir}")
-
-####################
-# zg-report-app
-####################
-
-add_executable(zg-report-app zg-report-app.c)
-set_target_properties(zg-report-app PROPERTIES OUTPUT_NAME "zg-report-app")
-target_link_libraries(zg-report-app ubuntu-launcher ${ZEITGEIST_LIBRARIES} ${GOBJECT2_LIBRARIES} ${GLIB2_LIBRARIES})
-install(TARGETS zg-report-app RUNTIME DESTINATION "${pkglibexecdir}")
-
-####################
-# application-job
-####################
-
-add_executable(application-job application-job.c)
-set_target_properties(application-job PROPERTIES OUTPUT_NAME "application-job")
-target_link_libraries(application-job ubuntu-launcher)
-install(TARGETS application-job RUNTIME DESTINATION "${pkglibexecdir}")
-
-####################
-# application-failed
-####################
-
-add_executable(application-failed application-failed.c)
-set_target_properties(application-failed PROPERTIES OUTPUT_NAME "application-failed")
-target_link_libraries(application-failed ${GIO2_LIBRARIES})
-install(TARGETS application-failed RUNTIME DESTINATION "${pkglibexecdir}")
-
-####################
-# untrusted-helper-type-end
-####################
-
-add_executable(untrusted-helper-type-end untrusted-helper-type-end.c)
-set_target_properties(untrusted-helper-type-end PROPERTIES OUTPUT_NAME "untrusted-helper-type-end")
-target_link_libraries(untrusted-helper-type-end ubuntu-launcher)
-install(TARGETS untrusted-helper-type-end RUNTIME DESTINATION "${pkglibexecdir}")
-
-####################
-# cgroup-reap-all
-####################
-
-add_executable(cgroup-reap-all cgroup-reap-all.c)
-set_target_properties(cgroup-reap-all PROPERTIES OUTPUT_NAME "cgroup-reap-all")
-target_link_libraries(cgroup-reap-all helpers)
-install(TARGETS cgroup-reap-all RUNTIME DESTINATION "${pkglibexecdir}")
-
-####################
 # oom-adjust-setuid-helper
 ####################
 
@@ -200,7 +141,6 @@
 configure_file("ubuntu-app-launch-desktop.click-hook.in" "${CMAKE_CURRENT_SOURCE_DIR}/debian/ubuntu-app-launch-desktop.click-hook" @ONLY)
 
 add_subdirectory(libubuntu-app-launch)
-add_subdirectory(upstart-jobs)
 add_subdirectory(tools)
 add_subdirectory(ubuntu-app-test)
 add_subdirectory(utils)
@@ -225,7 +165,6 @@
   TESTS
   	application-icon-finder-test
 	application-info-desktop-test
-	cgroup-reap-test
 	exec-util-test
 	failure-test
 	helper-test

=== removed file 'application-failed.c'
--- application-failed.c	2016-12-14 21:11:09 +0000
+++ application-failed.c	1970-01-01 00:00:00 +0000
@@ -1,80 +0,0 @@
-
-/*
- * Copyright 2013 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 <gio/gio.h>
-
-int
-main (int argc, char * argv[])
-{
-	const gchar * job = g_getenv("JOB");
-	g_return_val_if_fail(job != NULL, -1);
-
-	const gchar * instance = g_getenv("INSTANCE");
-	g_return_val_if_fail(instance != NULL, -1);
-
-	gboolean crashed = FALSE;
-	if (g_getenv("EXIT_STATUS") != NULL || g_getenv("EXIT_SIGNAL") != NULL) {
-		crashed = TRUE;
-	}
-
-	gchar * appid = g_strdup(instance);
-	gchar * lasthyphenstanding = NULL;
-	if (g_strcmp0(job, "application-legacy") == 0
-			|| g_strcmp0(job, "application-snap") == 0) {
-		lasthyphenstanding = g_strrstr(appid, "-");
-		if (lasthyphenstanding != NULL) {
-			lasthyphenstanding[0] = '\0';
-		} else {
-			g_warning("Legacy job instance '%s' is missing a hyphen", appid);
-		}
-	}
-
-	if (lasthyphenstanding == NULL) {
-		lasthyphenstanding = "";
-	} else {
-		lasthyphenstanding++;
-	}
-
-	GDBusConnection * bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-	g_return_val_if_fail(bus != NULL, -1);
-
-	GError * error = NULL;
-	g_dbus_connection_emit_signal(bus,
-		NULL, /* destination */
-		"/", /* path */
-		"com.canonical.UbuntuAppLaunch",
-		"ApplicationFailed",
-		g_variant_new("(sss)", appid, lasthyphenstanding, crashed ? "crash" : "start-failure"),
-		&error);
-
-	g_debug("Emitting failed event '%s' for app '%s'", crashed ? "crash" : "start-failure", appid);
-
-	if (error != NULL) {
-		g_warning("Unable to emit signal: %s", error->message);
-		g_error_free(error);
-		return -1;
-	}
-
-	g_dbus_connection_flush_sync(bus, NULL, NULL);
-	g_object_unref(bus);
-	g_free(appid);
-
-	return 0;
-}

=== removed file 'application-job.c'
--- application-job.c	2014-04-30 16:34:06 +0000
+++ application-job.c	1970-01-01 00:00:00 +0000
@@ -1,113 +0,0 @@
-/*
- * Copyright 2013 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 <gio/gio.h>
-#include "libubuntu-app-launch/ubuntu-app-launch.h"
-
-int retval = 0;
-const gchar * global_appid;
-
-static void
-app_started (const gchar * appid, gpointer user_data)
-{
-	if (g_strcmp0(appid, global_appid) != 0)
-		return;
-	g_debug("Application Started: %s", appid);
-	g_main_loop_quit((GMainLoop *)user_data);
-}
-
-static void
-app_focus (const gchar * appid, gpointer user_data)
-{
-	if (g_strcmp0(appid, global_appid) != 0)
-		return;
-	g_debug("Application Focused");
-	g_main_loop_quit((GMainLoop *)user_data);
-}
-
-static void
-app_failed (const gchar * appid, UbuntuAppLaunchAppFailed failure_type, gpointer user_data)
-{
-	if (g_strcmp0(appid, global_appid) != 0)
-		return;
-	g_warning("Application Startup Failed");
-	retval = 1;
-	g_main_loop_quit((GMainLoop *)user_data);
-}
-
-/* A fallback so that we can see what is going on.  The job can not always signal
-   that it has been started, and thus we wouldn't quit.  Which would be a bad thing. */
-static gboolean
-timeout_check (gpointer user_data)
-{
-	g_debug("Timeout reached");
-	g_main_loop_quit((GMainLoop *)user_data);
-	return TRUE; /* Keep the source connected to avoid the disconnect error */
-}
-
-int
-main (int argc, char * argv[])
-{
-	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-	g_return_val_if_fail(con != NULL, 1);
-
-	global_appid = g_getenv("APP_ID");
-	g_return_val_if_fail(global_appid != NULL, 1);
-
-	const gchar * uris_str = g_getenv("APP_URIS");
-	gchar ** uris = NULL;
-	if (uris_str != NULL) {
-		GError * error = NULL;
-		gint uri_count = 0;
-		g_shell_parse_argv(uris_str, &uri_count, &uris, &error);
-
-		if (error != NULL) {
-			g_warning("Unable to parse uris '%s': %s", uris_str, error->message);
-			g_error_free(error);
-		} else {
-			g_debug("Got %d URIs", uri_count);
-		}
-	}
-
-	GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
-
-	ubuntu_app_launch_observer_add_app_started(app_started, mainloop);
-	ubuntu_app_launch_observer_add_app_focus(app_focus, mainloop);
-	ubuntu_app_launch_observer_add_app_failed(app_failed, mainloop);
-
-	guint timer = g_timeout_add_seconds(1, timeout_check, mainloop);
-
-	g_debug("Start Application: %s", global_appid);
-	g_return_val_if_fail(ubuntu_app_launch_start_application(global_appid, (const gchar * const *)uris), -1);
-	g_strfreev(uris);
-
-	g_debug("Wait for results");
-	g_main_loop_run(mainloop);
-
-	g_source_remove(timer);
-
-	ubuntu_app_launch_observer_delete_app_started(app_started, mainloop);
-	ubuntu_app_launch_observer_delete_app_focus(app_focus, mainloop);
-	ubuntu_app_launch_observer_delete_app_failed(app_failed, mainloop);
-
-	g_main_loop_unref(mainloop);
-	g_object_unref(con);
-
-	return retval;
-}

=== removed file 'cgroup-reap-all.c'
--- cgroup-reap-all.c	2014-11-20 20:33:59 +0000
+++ cgroup-reap-all.c	1970-01-01 00:00:00 +0000
@@ -1,65 +0,0 @@
-/*
- * Copyright © 2014 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 "helpers.h"
-
-int kill (pid_t pid, int signal);
-pid_t getpgid (pid_t);
-
-int
-main (int argc, char * argv[])
-{
-	/* Break off a new process group */
-	setpgid(0, 0);
-
-	GDBusConnection * cgmanager = cgroup_manager_connection();
-	g_return_val_if_fail(cgmanager != NULL, -1);
-
-	GPid selfpid = getpid();
-	GPid parentpid = getppid();
-
-	/* We're gonna try to kill things forever, literally. It's important
-	   enough that we can't consider failure an option. */
-	gboolean killed = TRUE;
-	while (killed) {
-		GList * pidlist = pids_from_cgroup(cgmanager, NULL, NULL);
-		GList * head;
-
-		killed = FALSE;
-
-		for (head = pidlist; head != NULL; head = g_list_next(head)) {
-			GPid pid = GPOINTER_TO_INT(head->data);
-
-			/* We don't want to kill ourselves, or if we're being executed by
-			   a script, that script, either. We also don't want things in our
-			   process group which we forked at the opening */
-			if (pid != selfpid && pid != parentpid && getpgid(pid) != selfpid) {
-				g_debug("Killing pid: %d", pid);
-				kill(pid, SIGKILL);
-				killed = TRUE;
-			}
-		}
-
-		g_list_free(pidlist);
-	}
-
-	cgroup_manager_unref(cgmanager);
-
-	return 0;
-}

=== modified file 'debian/control'
--- debian/control	2017-03-07 19:03:36 +0000
+++ debian/control	2017-03-21 03:20:55 +0000
@@ -23,18 +23,14 @@
                liblibertine-dev,
                liblttng-ust-dev,
                libmirclient-dev (>= 0.5),
-               libnih-dbus-dev,
-               libnih-dev,
                libproperties-cpp-dev,
 # For ABI check to distro version
 # Make sure to set DEB_BUILD_PROFILES when bootstrapping
                libubuntu-app-launch3-dev <!stage1>,
-               libupstart-dev,
                libwhoopsie-dev (>= 0.2.52),
                libzeitgeist-2.0-dev,
                gobject-introspection,
                python3-dbusmock,
-               upstart (>= 1.13),
 Standards-Version: 3.9.4
 Homepage: http://launchpad.net/ubuntu-app-launch
 # If you aren't a member of ~indicator-applet-developers but need to upload packaging changes,
@@ -46,10 +42,8 @@
 Architecture: any
 Depends: ${shlibs:Depends},
          ${misc:Depends},
-         cgmanager,
          click-apparmor,
-         libpam-cgfs | libpam-cgm | cgmanager (<< 0.37),
-         upstart (>= 1.13),
+         dbus-user-session,
          xmir [amd64 armhf i386],
          zeitgeist-core,
 Replaces: upstart-app-launch
@@ -78,6 +72,7 @@
 Architecture: any
 Depends: ${misc:Depends},
          ${shlibs:Depends},
+         ubuntu-app-launch (= ${binary:Version}),
          libertine-tools,
 Pre-Depends: ${misc:Pre-Depends},
 Multi-Arch: same

=== modified file 'debian/ubuntu-app-launch.install'
--- debian/ubuntu-app-launch.install	2016-11-21 20:54:34 +0000
+++ debian/ubuntu-app-launch.install	2017-03-21 03:20:55 +0000
@@ -1,3 +1,2 @@
-usr/share/upstart/sessions/*
 usr/lib/*/ubuntu-app-launch/*
 usr/bin/snappy-xmir*

=== modified file 'docs/index.rst'
--- docs/index.rst	2017-03-21 03:20:55 +0000
+++ docs/index.rst	2017-03-21 03:20:55 +0000
@@ -13,10 +13,10 @@
 managing apps on Ubuntu Touch. It is used by Unity8 and other programs to
 start and stop applications, as well as query which ones are currently open.
 It doesn't have its own service or processes though, it relies on the system
-init daemon to manage the processes (currently Upstart_) but configures them
+init daemon to manage the processes (currently systemd_) but configures them
 in a way that they're discoverable and usable by higher level applications.
 
-.. _Upstart: http://upstart.ubuntu.com/
+.. _systemd: http://freedesktop.org/wiki/Software/systemd/
 
 
 Environment Variables
@@ -25,12 +25,6 @@
 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.
 
@@ -275,26 +269,6 @@
    :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
 -----------------------
 

=== removed file 'exec-line-exec-trace.tp'
--- exec-line-exec-trace.tp	2014-09-17 14:11:59 +0000
+++ exec-line-exec-trace.tp	1970-01-01 00:00:00 +0000
@@ -1,19 +0,0 @@
-
-TRACEPOINT_EVENT(ubuntu_app_launch, exec_start,
-	TP_ARGS(const char *, appid),
-	TP_FIELDS(
-		ctf_string(appid, appid)
-	)
-)
-TRACEPOINT_EVENT(ubuntu_app_launch, exec_parse_complete,
-	TP_ARGS(const char *, appid),
-	TP_FIELDS(
-		ctf_string(appid, appid)
-	)
-)
-TRACEPOINT_EVENT(ubuntu_app_launch, exec_pre_exec,
-	TP_ARGS(const char *, appid),
-	TP_FIELDS(
-		ctf_string(appid, appid)
-	)
-)

=== removed file 'exec-line-exec.c'
--- exec-line-exec.c	2015-06-30 20:42:24 +0000
+++ exec-line-exec.c	1970-01-01 00:00:00 +0000
@@ -1,170 +0,0 @@
-/*
- * Copyright 2013 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 <unistd.h>
-#include <errno.h>
-#include <string.h>
-
-#include <glib.h>
-#include <glib/gstdio.h>
-
-#include "exec-line-exec-trace.h"
-#include "helpers.h"
-#include "ual-tracepoint.h"
-
-int
-main (int argc, char * argv[])
-{
-	/* Make sure we have work to do */
-	/* This string is quoted using desktop file quoting:
-	   http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#exec-variables */
-	const gchar * app_exec = g_getenv("APP_EXEC");
-	if (app_exec == NULL) {
-		/* There should be no reason for this, a g_error() so that it gets
-		   picked up by Apport and we can track it */
-		g_error("No exec line given, nothing to do except fail");
-		return 1;
-	}
-
-	/* For the tracepoints */
-	const gchar * app_id = g_getenv("APP_ID");
-
-	ual_tracepoint(exec_start, app_id);
-
-	/* URIs */
-	const gchar * app_uris = g_getenv("APP_URIS");
-
-	/* Look to see if we have a directory defined that we
-	   should be using for everything.  If so, change to it
-	   and add it to the path */
-	const gchar * appdir = g_getenv("APP_DIR");
-
-	if (appdir != NULL) {
-		if (g_chdir(appdir) != 0) {
-			g_warning("Unable to change directory to '%s'", appdir);
-		}
-	}
-
-	/* Protect against app directories that have ':' in them */
-	if (appdir != NULL && strchr(appdir, ':') == NULL) {
-		const gchar * path_path = g_getenv("PATH");
-		if (path_path != NULL && path_path[0] == '\0')
-			path_path = NULL;
-		gchar * path_libpath = NULL;
-		const gchar * path_joinable[4] = { 0 };
-
-		const gchar * lib_path = g_getenv("LD_LIBRARY_PATH");
-		if (lib_path != NULL && lib_path[0] == '\0')
-			lib_path = NULL;
-		gchar * lib_libpath = g_build_filename(appdir, "lib", NULL);
-		const gchar * lib_joinable[4] = { 0 };
-
-		const gchar * import_path = g_getenv("QML2_IMPORT_PATH");
-		if (import_path != NULL && import_path[0] == '\0')
-			import_path = NULL;
-		gchar * import_libpath = NULL;
-		const gchar * import_joinable[4] = { 0 };
-
-		/* If we've got an architecture set insert that into the
-		   path before everything else */
-		const gchar * archdir = g_getenv("UBUNTU_APP_LAUNCH_ARCH");
-		if (archdir != NULL && strchr(archdir, ':') == NULL) {
-			path_libpath = g_build_filename(appdir, "lib", archdir, "bin", NULL);
-			import_libpath = g_build_filename(appdir, "lib", archdir, NULL);
-
-			path_joinable[0] = path_libpath;
-			path_joinable[1] = appdir;
-			path_joinable[2] = path_path;
-
-			lib_joinable[0] = import_libpath;
-			lib_joinable[1] = lib_libpath;
-			lib_joinable[2] = lib_path;
-
-			/* Need to check whether the original is NULL because we're
-			   appending instead of prepending */
-			if (import_path == NULL) {
-				import_joinable[0] = import_libpath;
-			} else {
-				import_joinable[0] = import_path;
-				import_joinable[1] = import_libpath;
-			}
-		} else {
-			path_joinable[0] = appdir;
-			path_joinable[1] = path_path;
-
-			lib_joinable[0] = lib_libpath;
-			lib_joinable[1] = lib_path;
-
-			import_joinable[0] = import_path;
-		}
-
-		gchar * newpath = g_strjoinv(":", (gchar**)path_joinable);
-		g_setenv("PATH", newpath, TRUE);
-		g_free(path_libpath);
-		g_free(newpath);
-
-		gchar * newlib = g_strjoinv(":", (gchar**)lib_joinable);
-		g_setenv("LD_LIBRARY_PATH", newlib, TRUE);
-		g_free(lib_libpath);
-		g_free(newlib);
-
-		if (import_joinable[0] != NULL) {
-			gchar * newimport = g_strjoinv(":", (gchar**)import_joinable);
-			g_setenv("QML2_IMPORT_PATH", newimport, TRUE);
-			g_free(newimport);
-		}
-		g_free(import_libpath);
-	}
-
-	/* Parse the execiness of it all */
-	GArray * newargv = desktop_exec_parse(app_exec, app_uris);
-	if (newargv == NULL) {
-		g_warning("Unable to parse exec line '%s'", app_exec);
-		return 1;
-	}
-
-	ual_tracepoint(exec_parse_complete, app_id);
-
-	if (g_getenv("MIR_SOCKET") != NULL && g_strcmp0(g_getenv("APP_XMIR_ENABLE"), "1") == 0) {
-		g_debug("XMir Helper being used");
-
-		/* xmir-helper $(APP_ID) $(COMMAND) */
-		const gchar * appid = g_getenv("APP_ID");
-		g_array_prepend_val(newargv, appid);
-
-		/* Pulling into the heap instead of the code page */
-		char * xmir_helper = g_strdup(XMIR_HELPER);
-		g_array_prepend_val(newargv, xmir_helper);
-	}
-
-	/* Now exec */
-	gchar ** nargv = (gchar**)g_array_free(newargv, FALSE);
-
-	ual_tracepoint(exec_pre_exec, app_id);
-
-	int execret = execvp(nargv[0], nargv);
-
-	if (execret != 0) {
-		gchar * execprint = g_strjoinv(" ", nargv);
-		g_warning("Unable to exec '%s' in '%s': %s", execprint, appdir, strerror(errno));
-		g_free(execprint);
-	}
-
-	return execret;
-}

=== modified file 'helpers.c'
--- helpers.c	2016-12-14 21:23:09 +0000
+++ helpers.c	2017-03-21 03:20:55 +0000
@@ -19,7 +19,6 @@
 
 #include <json-glib/json-glib.h>
 #include <click.h>
-#include <upstart.h>
 #include "helpers.h"
 
 /* Take an app ID and validate it and then break it up
@@ -423,62 +422,6 @@
 	return newargv;
 }
 
-/* Set environment various variables to make apps work under
- * confinement according to:
- * https://wiki.ubuntu.com/SecurityTeam/Specifications/ApplicationConfinement
- */
-void
-set_confined_envvars (EnvHandle * handle, const gchar * package, const gchar * app_dir)
-{
-	g_return_if_fail(package != NULL);
-	g_return_if_fail(app_dir != NULL);
-
-	g_debug("Setting 'UBUNTU_APPLICATION_ISOLATION' to '1'");
-	env_handle_add(handle, "UBUNTU_APPLICATION_ISOLATION", "1");
-
-	/* Make sure the XDG base dirs are set for the application using
-	 * the user's current values/system defaults. We could set these to
-	 * what is expected in the AppArmor profile, but that might be too
-	 * brittle if someone uses different base dirs.
-	 */
-	g_debug("Setting 'XDG_CACHE_HOME' using g_get_user_cache_dir()");
-	env_handle_add(handle, "XDG_CACHE_HOME", g_get_user_cache_dir());
-
-	g_debug("Setting 'XDG_CONFIG_HOME' using g_get_user_config_dir()");
-	env_handle_add(handle, "XDG_CONFIG_HOME", g_get_user_config_dir());
-
-	g_debug("Setting 'XDG_DATA_HOME' using g_get_user_data_dir()");
-	env_handle_add(handle, "XDG_DATA_HOME", g_get_user_data_dir());
-
-	g_debug("Setting 'XDG_RUNTIME_DIR' using g_get_user_runtime_dir()");
-	env_handle_add(handle, "XDG_RUNTIME_DIR", g_get_user_runtime_dir());
-
-	/* Add the application's dir to the list of sources for data */
-	const gchar * basedatadirs = g_getenv("XDG_DATA_DIRS");
-	if (basedatadirs == NULL || basedatadirs[0] == '\0') {
-		basedatadirs = "/usr/local/share:/usr/share";
-	}
-	gchar * datadirs = g_strjoin(":", app_dir, basedatadirs, NULL);
-	env_handle_add(handle, "XDG_DATA_DIRS", datadirs);
-	g_free(datadirs);
-
-	/* Set TMPDIR to something sane and application-specific */
-	gchar * tmpdir = g_strdup_printf("%s/confined/%s", g_get_user_runtime_dir(), package);
-	g_debug("Setting 'TMPDIR' to '%s'", tmpdir);
-	env_handle_add(handle, "TMPDIR", tmpdir);
-	g_debug("Creating '%s'", tmpdir);
-	g_mkdir_with_parents(tmpdir, 0700);
-	g_free(tmpdir);
-
-	/* Do the same for nvidia */
-	gchar * nv_shader_cachedir = g_strdup_printf("%s/%s", g_get_user_cache_dir(), package);
-	g_debug("Setting '__GL_SHADER_DISK_CACHE_PATH' to '%s'", nv_shader_cachedir);
-	env_handle_add(handle, "__GL_SHADER_DISK_CACHE_PATH", nv_shader_cachedir);
-	g_free(nv_shader_cachedir);
-
-	return;
-}
-
 static void
 unity_signal_cb (GDBusConnection * con, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
 {
@@ -568,72 +511,3 @@
 	g_free(handshake);
 }
 
-EnvHandle *
-env_handle_start (void)
-{
-	GVariantBuilder * builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);
-	return (EnvHandle *)builder;
-}
-
-void
-env_handle_add (EnvHandle * handle, const gchar * variable, const gchar * value)
-{
-	g_return_if_fail(handle != NULL);
-	gchar * combinedstr = g_strdup_printf("%s=%s", variable, value);
-	GVariant * env = g_variant_new_take_string(combinedstr);
-	g_variant_builder_add_value((GVariantBuilder*)handle, env);
-}
-
-void
-env_handle_finish (EnvHandle * handle)
-{
-	g_return_if_fail(handle != NULL);
-	/* Check to see if we can get the job environment */
-	const gchar * job_name = g_getenv("UPSTART_JOB");
-	const gchar * instance_name = g_getenv("UPSTART_INSTANCE");
-	g_return_if_fail(job_name != NULL);
-
-	/* Get a bus, let's go! */
-	GDBusConnection * bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-	g_return_if_fail(bus != NULL);
-
-	GVariantBuilder builder; /* Target: (assb) */
-	g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
-
-	/* Setup the job properties */
-	g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
-	g_variant_builder_add_value(&builder, g_variant_new_string(job_name));
-	if (instance_name != NULL)
-		g_variant_builder_add_value(&builder, g_variant_new_string(instance_name));
-	g_variant_builder_close(&builder);
-
-	/* The value itself */
-	g_variant_builder_add_value(&builder, g_variant_builder_end((GVariantBuilder*)handle));
-
-	/* Do we want to replace?  Yes, we do! */
-	g_variant_builder_add_value(&builder, g_variant_new_boolean(TRUE));
-
-	GError * error = NULL;
-	GVariant * reply = g_dbus_connection_call_sync(bus,
-		DBUS_SERVICE_UPSTART,
-		DBUS_PATH_UPSTART,
-		DBUS_INTERFACE_UPSTART,
-		"SetEnvList",
-		g_variant_builder_end(&builder),
-		NULL, /* reply */
-		G_DBUS_CALL_FLAGS_NONE,
-		-1, /* timeout */
-		NULL, /* cancelable */
-		&error); /* error */
-
-	if (reply != NULL) {
-		g_variant_unref(reply);
-	}
-
-	if (error != NULL) {
-		g_warning("Unable to set environment variables: %s", error->message);
-		g_error_free(error);
-	}
-
-	g_object_unref(bus);
-}

=== modified file 'helpers.h'
--- helpers.h	2016-12-14 21:23:09 +0000
+++ helpers.h	2017-03-21 03:20:55 +0000
@@ -21,8 +21,6 @@
 
 G_BEGIN_DECLS
 
-typedef struct _EnvHandle EnvHandle;
-
 gboolean  app_id_to_triplet      (const gchar *   app_id,
                                   gchar **        package,
                                   gchar **        application,
@@ -35,16 +33,6 @@
                                   const gchar *   uri_list);
 GKeyFile * keyfile_for_appid     (const gchar *   appid,
                                   gchar * *       desktopfile);
-void      set_confined_envvars   (EnvHandle *     handle,
-                                  const gchar *   package,
-                                  const gchar *   app_dir);
-
-/* A handle to group environment setting */
-EnvHandle * env_handle_start     (void);
-void        env_handle_add       (EnvHandle *     handle,
-                                  const gchar *   variable,
-                                  const gchar *   value);
-void        env_handle_finish    (EnvHandle *     handle);
 
 typedef struct _handshake_t handshake_t;
 handshake_t * starting_handshake_start   (const gchar *   app_id,

=== modified file 'libubuntu-app-launch/CMakeLists.txt'
--- libubuntu-app-launch/CMakeLists.txt	2017-03-21 03:20:55 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2017-03-21 03:20:55 +0000
@@ -74,8 +74,6 @@
 jobs-base.cpp
 jobs-systemd.h
 jobs-systemd.cpp
-jobs-upstart.h
-jobs-upstart.cpp
 )
 
 set(LAUNCHER_SOURCES

=== added file 'libubuntu-app-launch/helper.cpp'
--- libubuntu-app-launch/helper.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/helper.cpp	2017-03-21 03:20:55 +0000
@@ -0,0 +1,468 @@
+/*
+ * Copyright © 2016-2017 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 <list>
+#include <numeric>
+
+#include "helper-impl.h"
+#include "registry-impl.h"
+
+#include "ubuntu-app-launch.h"
+
+extern "C" {
+#include "proxy-socket-demangler.h"
+#include <gio/gunixfdlist.h>
+}
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace helper_impls
+{
+
+/**********************
+ * Instance
+ **********************/
+
+BaseInstance::BaseInstance(const std::shared_ptr<jobs::instance::Base>& inst)
+    : impl{inst}
+{
+}
+
+BaseInstance::BaseInstance(const std::shared_ptr<Application::Instance>& inst)
+    : impl{std::dynamic_pointer_cast<jobs::instance::Base>(inst)}
+{
+}
+
+bool BaseInstance::isRunning()
+{
+    return impl->isRunning();
+}
+
+void BaseInstance::stop()
+{
+    impl->stop();
+}
+
+/**********************
+ * Helper Class
+ **********************/
+
+Base::Base(const Helper::Type& type, const AppID& appid, const std::shared_ptr<Registry>& registry)
+    : _type(type)
+    , _appid(appid)
+    , _registry(registry)
+{
+}
+
+AppID Base::appId()
+{
+    return _appid;
+}
+
+bool Base::hasInstances()
+{
+    return instances().size() > 0;
+}
+
+std::vector<std::shared_ptr<Helper::Instance>> Base::instances()
+{
+    auto insts = _registry->impl->jobs->instances(_appid, _type.value());
+    std::vector<std::shared_ptr<Helper::Instance>> wrapped;
+
+    std::transform(insts.begin(), insts.end(), wrapped.begin(),
+                   [](std::shared_ptr<jobs::instance::Base>& inst) { return std::make_shared<BaseInstance>(inst); });
+
+    return wrapped;
+}
+
+/** Find an instance that we already know the ID of */
+std::shared_ptr<Helper::Instance> Base::existingInstance(const std::string& instanceid)
+{
+    auto appinst = _registry->impl->jobs->existing(_appid, _type.value(), instanceid, {});
+
+    return std::make_shared<BaseInstance>(appinst);
+}
+
+std::string genInstanceId()
+{
+    return std::to_string(g_get_real_time());
+}
+
+std::vector<Application::URL> appURL(const std::vector<Helper::URL>& in)
+{
+    std::vector<Application::URL> out;
+    std::transform(in.begin(), in.end(), out.begin(),
+                   [](Helper::URL url) { return Application::URL::from_raw(url.value()); });
+    return out;
+}
+
+/** Sets up the executable environment variable based on the appid and
+ *  the type of helper. We look for the exec-tool, but if we can't find
+ *  it we're cool with that and we just execute the helper. If we do find
+ *  an exec-tool we'll use that to fill in the parameters. For legacy appid's
+ *  we'll allow the exec-tool to set everything. */
+std::list<std::pair<std::string, std::string>> Base::defaultEnv()
+{
+    std::list<std::pair<std::string, std::string>> envs{};
+    auto csnapenv = getenv("SNAP");
+    std::string helperpath;
+    if (csnapenv != nullptr)
+    {
+        helperpath = std::string{csnapenv} + "/" HELPER_EXEC_TOOL_DIR "/" + _type.value() + "/exec-tool";
+    }
+    else
+    {
+        helperpath = HELPER_EXEC_TOOL_DIR "/" + _type.value() + "/exec-tool";
+    }
+
+    std::list<std::string> exec;
+    /* We have an exec tool that'll give us params */
+    if (g_file_test(helperpath.c_str(), G_FILE_TEST_IS_EXECUTABLE))
+    {
+        const char* chelperenv = getenv("UBUNTU_APP_LAUNCH_HELPER_HELPER");
+        if (chelperenv == nullptr)
+        {
+            chelperenv = HELPER_HELPER_TOOL;
+        }
+
+        if (csnapenv != nullptr)
+        {
+            exec.push_back(std::string{csnapenv} + "/" + chelperenv);
+        }
+        else
+        {
+            exec.push_back(std::string{"/"} + chelperenv);
+        }
+        exec.push_back(helperpath);
+    }
+    else
+    {
+        if (_appid.package.value().empty())
+        {
+            throw std::runtime_error{
+                "Executing a helper that isn't package, but doesn't have an exec-tool. We can't do that. Sorry. Bad "
+                "things will happen."};
+        }
+    }
+
+    /* This is kinda hard coded for snaps right now, we don't have
+     * another posibility today other than really custom stuff. But
+     * if we do, we'll need to abstract this. */
+    /* Insert package executable */
+    if (!_appid.package.value().empty())
+    {
+        std::string snapdir{"/snap/bin/"};
+
+        if (_appid.package.value() == _appid.appname.value())
+        {
+            exec.push_back(snapdir + _appid.package.value());
+        }
+        else
+        {
+            exec.push_back(snapdir + _appid.package.value() + "." + _appid.appname.value());
+        }
+    }
+
+    exec.push_back("--");
+    exec.push_back("%U");
+
+    envs.emplace_back(
+        std::make_pair("APP_EXEC", std::accumulate(exec.begin(), exec.end(), std::string{},
+                                                   [](const std::string& accum, const std::string& addon) {
+                                                       return accum.empty() ? addon : accum + " " + addon;
+                                                   })));
+
+    return envs;
+}
+
+std::shared_ptr<Helper::Instance> Base::launch(std::vector<Helper::URL> urls)
+{
+    auto defaultenv = defaultEnv();
+    std::function<std::list<std::pair<std::string, std::string>>()> envfunc = [defaultenv]() { return defaultenv; };
+
+    return std::make_shared<BaseInstance>(_registry->impl->jobs->launch(
+        _appid, _type.value(), genInstanceId(), appURL(urls), jobs::manager::launchMode::STANDARD, envfunc));
+}
+
+class MirFDProxy
+{
+public:
+    int mirfd;
+    std::shared_ptr<proxySocketDemangler> skel;
+    guint handle;
+    std::string path;
+    std::string name;
+
+    MirFDProxy(MirPromptSession* session, const AppID& appid, const std::shared_ptr<Registry>& reg)
+        : name(g_dbus_connection_get_unique_name(reg->impl->_dbus.get()))
+    {
+        if (appid.empty())
+        {
+            throw std::runtime_error{"Invalid AppID"};
+        }
+
+        /* Get the Mir FD */
+        std::promise<int> promise;
+        mir_prompt_session_new_fds_for_prompt_providers(
+            session, 1,
+            [](MirPromptSession* session, size_t count, int const* fdin, void* user_data) {
+                auto promise = static_cast<std::promise<int>*>(user_data);
+
+                if (count != 1)
+                {
+                    g_warning("Mir trusted session returned %d FDs instead of one", (int)count);
+                    promise->set_value(0);
+                    return;
+                }
+
+                promise->set_value(fdin[0]);
+            },
+            &promise);
+
+        mirfd = promise.get_future().get();
+
+        if (mirfd == 0)
+        {
+            throw std::runtime_error{"Unable to Mir FD from Prompt Session"};
+        }
+
+        /* Setup the DBus interface */
+        std::tie(skel, handle, path) =
+            reg->impl->thread.executeOnThread<std::tuple<std::shared_ptr<proxySocketDemangler>, guint, std::string>>(
+                [this, appid, reg]() {
+                    auto skel = std::shared_ptr<proxySocketDemangler>(
+                        proxy_socket_demangler_skeleton_new(),
+                        [](proxySocketDemangler* skel) { g_clear_object(&skel); });
+                    auto handle = g_signal_connect(G_OBJECT(skel.get()), "handle-get-mir-socket",
+                                                   G_CALLBACK(staticProxyCb), this);
+
+                    /* Find a path to export on */
+                    auto dbusAppid = dbusSafe(std::string{appid});
+                    std::string path;
+
+                    while (path.empty())
+                    {
+                        GError* error = nullptr;
+                        std::string tryname =
+                            "/com/canonical/UbuntuAppLaunch/" + dbusAppid + "/" + std::to_string(rand());
+
+                        g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(skel.get()), reg->impl->_dbus.get(),
+                                                         tryname.c_str(), &error);
+
+                        if (error == nullptr)
+                        {
+                            path = tryname;
+                        }
+                        else
+                        {
+                            if (!g_error_matches(error, G_DBUS_ERROR, G_DBUS_ERROR_OBJECT_PATH_IN_USE))
+                            {
+                                std::string message =
+                                    "Unable to export Mir trusted proxy: " + std::string{error->message};
+                                g_clear_error(&error);
+                                throw std::runtime_error{message};
+                            }
+                            g_clear_error(&error);
+                        }
+                    }
+
+                    return std::make_tuple(skel, handle, path);
+                });
+    }
+
+    ~MirFDProxy()
+    {
+        if (mirfd != 0)
+        {
+            close(mirfd);
+        }
+
+        if (handle != 0)
+        {
+            g_signal_handler_disconnect(skel.get(), handle);
+        }
+
+        g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(skel.get()));
+    }
+
+    static std::string dbusSafe(const std::string& in)
+    {
+        std::string out = in;
+        std::transform(out.begin(), out.end(), out.begin(), [](char in) { return std::isalpha(in) ? in : '_'; });
+        return out;
+    }
+
+    bool proxyCb(GDBusMethodInvocation* invocation)
+    {
+        if (mirfd == 0)
+        {
+            g_warning("Mir FD proxy called with no FDs!");
+            return false;
+        }
+
+        /* Index into fds */
+        auto handle = g_variant_new_handle(0);
+        auto tuple = g_variant_new_tuple(&handle, 1);
+
+        GError* error = nullptr;
+        GUnixFDList* list = g_unix_fd_list_new();
+        g_unix_fd_list_append(list, mirfd, &error);
+
+        if (error == nullptr)
+        {
+            g_dbus_method_invocation_return_value_with_unix_fd_list(invocation, tuple, list);
+        }
+        else
+        {
+            g_variant_ref_sink(tuple);
+            g_variant_unref(tuple);
+        }
+
+        g_object_unref(list);
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to pass FD %d: %s", mirfd, error->message);
+            g_error_free(error);
+            return false;
+        }
+
+        mirfd = 0;
+        return true;
+    }
+
+    static gboolean staticProxyCb(GObject* obj, GDBusMethodInvocation* invocation, gpointer user_data)
+    {
+        return static_cast<MirFDProxy*>(user_data)->proxyCb(invocation) ? TRUE : FALSE;
+    }
+
+    std::string getPath()
+    {
+        return path;
+    }
+
+    std::string getName()
+    {
+        return name;
+    }
+};
+
+std::shared_ptr<Helper::Instance> Base::launch(MirPromptSession* session, std::vector<Helper::URL> urls)
+{
+    std::shared_ptr<MirFDProxy> proxy;
+    try
+    {
+        proxy = std::make_shared<MirFDProxy>(session, _appid, _registry);
+    }
+    catch (std::runtime_error& e)
+    {
+        g_warning("Error setting up Mir FD Proxy: %s", e.what());
+        return {};
+    }
+
+    auto defaultenvs = defaultEnv();
+    std::function<std::list<std::pair<std::string, std::string>>()> envfunc = [defaultenvs, proxy]() {
+        auto envs = defaultenvs;
+
+        envs.emplace_back(std::make_pair("UBUNTU_APP_LAUNCH_DEMANGLE_PATH", proxy->getPath()));
+        envs.emplace_back(std::make_pair("UBUNTU_APP_LAUNCH_DEMANGLE_NAME", proxy->getName()));
+
+        return envs;
+    };
+
+    /* This will maintain a reference to the proxy for two
+       seconds. And then it'll be dropped. */
+    _registry->impl->thread.timeout(std::chrono::seconds{2}, [proxy]() { g_debug("Mir Proxy Timeout"); });
+
+    return std::make_shared<BaseInstance>(_registry->impl->jobs->launch(
+        _appid, _type.value(), genInstanceId(), appURL(urls), jobs::manager::launchMode::STANDARD, envfunc));
+}
+
+}  // namespace helper_impl
+
+/***************************/
+/* Helper Public Functions */
+/***************************/
+
+std::shared_ptr<Helper> Helper::create(Type type, AppID appid, std::shared_ptr<Registry> registry)
+{
+    /* Only one type today */
+    return std::make_shared<helper_impls::Base>(type, appid, registry);
+}
+
+/* Hardcore socket stuff */
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+
+void Helper::setExec(std::vector<std::string> exec)
+{
+    auto cenv = getenv("UBUNTU_APP_LAUNCH_HELPER_EXECTOOL_SETEXEC_SOCKET");
+    if (cenv == nullptr)
+    {
+        throw std::runtime_error{"Unable to find a socket to write exec information to."};
+    }
+
+    class SmartSocket
+    {
+    public:
+        int fd;
+        SmartSocket()
+            : fd(socket(AF_UNIX, SOCK_STREAM, 0))
+        {
+        }
+        ~SmartSocket()
+        {
+            close(fd);
+        }
+    };
+
+    SmartSocket sock;
+    if (sock.fd <= 0)
+    {
+        throw std::runtime_error{"Unable to create socket to systemd-helper-helper"};
+    }
+
+    struct sockaddr_un socketaddr = {0};
+    socketaddr.sun_family = AF_UNIX;
+    strncpy(socketaddr.sun_path, cenv, sizeof(socketaddr.sun_path) - 1);
+    socketaddr.sun_path[0] = 0;
+
+    if (connect(sock.fd, (const struct sockaddr*)&socketaddr, sizeof(struct sockaddr_un)) < 0)
+    {
+        throw std::runtime_error{"Unable to connecto to socket of systemd-helper-helper"};
+    }
+
+    for (const auto& item : exec)
+    {
+        auto citem = item.c_str();
+        int writesize = write(sock.fd, citem, strlen(citem) + 1);
+
+        if (writesize <= 0)
+        {
+            throw std::runtime_error{"Error writing to systemd-helper-helper socket"};
+        }
+    }
+}
+
+}  // namespace app_launch
+}  // namespace ubuntu

=== modified file 'libubuntu-app-launch/jobs-base.cpp'
--- libubuntu-app-launch/jobs-base.cpp	2017-03-21 03:20:55 +0000
+++ libubuntu-app-launch/jobs-base.cpp	2017-03-21 03:20:55 +0000
@@ -26,7 +26,6 @@
 #include "helper-impl.h"
 #include "jobs-base.h"
 #include "jobs-systemd.h"
-#include "jobs-upstart.h"
 #include "registry-impl.h"
 
 namespace ubuntu
@@ -62,22 +61,12 @@
     dohandle(handle_appResumed);
 }
 
+/** Should determine which jobs backend to use, but we only have
+    one right now. */
 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))
-    {
-        g_debug("Building a systemd jobs manager");
-        return std::make_shared<jobs::manager::SystemD>(registry);
-    }
-    else
-    {
-        g_debug("Building an Upstart jobs manager");
-        return std::make_shared<jobs::manager::Upstart>(registry);
-    }
+    g_debug("Building a systemd jobs manager");
+    return std::make_shared<jobs::manager::SystemD>(registry);
 }
 
 const std::list<std::string>& Base::getAllApplicationJobs() const

=== removed file 'libubuntu-app-launch/jobs-upstart.cpp'
--- libubuntu-app-launch/jobs-upstart.cpp	2017-03-21 03:20:55 +0000
+++ libubuntu-app-launch/jobs-upstart.cpp	1970-01-01 00:00:00 +0000
@@ -1,1178 +0,0 @@
-/*
- * 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 "application-impl-base.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::vector<pid_t> pids() override;
-
-    /* Manage lifecycle */
-    void stop() override;
-    void pause() override;
-    void resume() override;
-
-    /* C Callback */
-    static void application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data);
-
-private:
-    std::string upstartJobPath();
-    std::string upstartName();
-
-    static std::vector<pid_t> pids(const std::shared_ptr<Registry>& reg,
-                                   const AppID& appid,
-                                   const std::string& jobpath);
-    static std::vector<pid_t> forAllPids(const std::shared_ptr<Registry>& reg,
-                                         const AppID& appid,
-                                         const std::string& jobpath,
-                                         std::function<void(pid_t)> eachPid);
-};
-
-/** Uses Upstart to get the primary PID of the instance using Upstart's
-    DBus interface */
-pid_t Upstart::primaryPid()
-{
-    auto jobpath = upstartJobPath();
-    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());
-        auto 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;
-        }
-
-        auto 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;
-        }
-
-        auto props_dict = g_variant_get_child_value(props_tuple, 0);
-
-        pid_t retval = 0;
-        auto processes = g_variant_lookup_value(props_dict, "processes", G_VARIANT_TYPE("a(si)"));
-        if (processes != nullptr && g_variant_n_children(processes) > 0)
-        {
-
-            auto first_entry = g_variant_get_child_value(processes, 0);
-            auto 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;
-}
-
-/** 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 = upstartJobPath();
-            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;
-            auto 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 */
-                            std::string(data->ptr->instance_).c_str(),                 /* instance */
-                            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()
-{
-    auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry_->impl->jobs);
-    return manager->upstartJobPath(job_);
-}
-
-/** 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> Upstart::forAllPids(const std::shared_ptr<Registry>& reg,
-                                       const AppID& appid,
-                                       const std::string& jobpath,
-                                       std::function<void(pid_t)> eachPid)
-{
-    std::set<pid_t> seenPids;
-    bool added = true;
-
-    while (added)
-    {
-        added = false;
-        auto pidlist = pids(reg, appid, jobpath);
-        for (auto pid : pidlist)
-        {
-            if (seenPids.insert(pid).second)
-            {
-                eachPid(pid);
-                added = true;
-            }
-        }
-    }
-
-    return std::vector<pid_t>(seenPids.begin(), seenPids.end());
-}
-
-/** Pauses this application by sending SIGSTOP to all the PIDs in the
-    cgroup and tells Zeitgeist that we've left the application. */
-void Upstart::pause()
-{
-    g_debug("Pausing application: %s", std::string(appId_).c_str());
-
-    auto registry = registry_;
-    auto appid = appId_;
-    auto instance = instance_;
-    auto jobpath = upstartJobPath();
-
-    registry->impl->thread.executeOnThread([registry, appid, instance, jobpath] {
-        auto pids = forAllPids(registry, appid, jobpath, [](pid_t pid) {
-            auto oomval = oom::paused();
-            g_debug("Pausing PID: %d (%d)", pid, int(oomval));
-            signalToPid(pid, SIGSTOP);
-            oomValueToPid(pid, oomval);
-        });
-
-        pidListToDbus(registry, appid, instance, pids, "ApplicationPaused");
-    });
-
-    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_LEAVE_EVENT);
-}
-
-/** Resumes this application by sending SIGCONT to all the PIDs in the
-    cgroup and tells Zeitgeist that we're accessing the application. */
-void Upstart::resume()
-{
-    g_debug("Resuming application: %s", std::string(appId_).c_str());
-
-    auto registry = registry_;
-    auto appid = appId_;
-    auto instance = instance_;
-    auto jobpath = upstartJobPath();
-
-    registry->impl->thread.executeOnThread([registry, appid, instance, jobpath] {
-        auto pids = forAllPids(registry, appid, jobpath, [](pid_t pid) {
-            auto oomval = oom::focused();
-            g_debug("Resuming PID: %d (%d)", pid, int(oomval));
-            signalToPid(pid, SIGCONT);
-            oomValueToPid(pid, oomval);
-        });
-
-        pidListToDbus(registry, appid, instance, pids, "ApplicationResumed");
-    });
-
-    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_ACCESS_EVENT);
-}
-
-std::vector<pid_t> Upstart::pids(const std::shared_ptr<Registry>& reg, const AppID& appid, const std::string& jobpath)
-{
-    auto manager = std::dynamic_pointer_cast<manager::Upstart>(reg->impl->jobs);
-    auto pids = manager->pidsFromCgroup(jobpath);
-    g_debug("Got %d PIDs for AppID '%s'", int(pids.size()), std::string(appid).c_str());
-    return pids;
-}
-
-}  // namespace instances
-
-namespace manager
-{
-
-Upstart::Upstart(std::shared_ptr<Registry> registry)
-    : Base(registry)
-{
-}
-
-Upstart::~Upstart()
-{
-    auto dohandle = [&](guint& handle) {
-        if (handle != 0)
-        {
-            g_dbus_connection_signal_unsubscribe(dbus_.get(), handle);
-            handle = 0;
-        }
-    };
-
-    dohandle(handle_jobStarted);
-    dohandle(handle_jobStopped);
-    dohandle(handle_jobFailed);
-}
-
-/** 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();
-
-    if (!registry)
-    {
-        g_warning("Registry object invalid!");
-        return {};
-    }
-
-    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(), instance.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;
-}
-
-/** Structure to track the data needed for upstart events. This cleans
-    up the lifecycle as we're passing this as a pointer through the
-    GLib calls. */
-struct upstartEventData
-{
-    /** Keeping a weak pointer because the handle is held by
-        the registry implementation. */
-    std::weak_ptr<Registry> weakReg;
-};
-
-/** Regex to parse the JOB environment variable from Upstart */
-const std::regex jobenv_regex{"^JOB=(application\\-(?:click|snap|legacy))$"};
-/** Regex to parse the INSTANCE environment variable from Upstart */
-const std::regex instanceenv_regex{"^INSTANCE=(.*?)(?:\\-([0-9]*))?+$"};
-
-/** Core of most of the events that come from Upstart directly. Includes parsing of the
-    Upstart event environment and calling the appropriate signal with the right Application
-    object and eventually its instance */
-void Upstart::upstartEventEmitted(core::Signal<const std::string&, const std::string&, const std::string&>& signal,
-                                  std::shared_ptr<GVariant> params,
-                                  const std::shared_ptr<Registry>& reg)
-{
-    std::string jobname;
-    std::string sappid;
-    std::string instance;
-
-    gchar* env = nullptr;
-    auto envs = g_variant_get_child_value(params.get(), 1);
-    GVariantIter iter;
-    g_variant_iter_init(&iter, envs);
-
-    while (g_variant_iter_loop(&iter, "s", &env))
-    {
-        std::smatch match;
-        std::string senv = env;
-
-        if (std::regex_match(senv, match, jobenv_regex))
-        {
-            jobname = match[1].str();
-        }
-        else if (std::regex_match(senv, match, instanceenv_regex))
-        {
-            sappid = match[1].str();
-            instance = match[2].str();
-        }
-    }
-
-    g_variant_unref(envs);
-
-    if (jobname.empty())
-    {
-        return;
-    }
-
-    g_debug("Upstart Event for job '%s' appid '%s' instance '%s'", jobname.c_str(), sappid.c_str(), instance.c_str());
-
-    signal(jobname, sappid, instance);
-}
-
-/** Grab the signal object for application startup. If we're not already listing for
-    those signals this sets up a listener for them. */
-core::Signal<const std::string&, const std::string&, const std::string&>& Upstart::jobStarted()
-{
-    std::call_once(flag_jobStarted, [this]() {
-        auto reg = registry_.lock();
-
-        reg->impl->thread.executeOnThread<bool>([this, reg]() {
-            upstartEventData* data = new upstartEventData{reg};
-
-            handle_jobStarted = g_dbus_connection_signal_subscribe(
-                reg->impl->_dbus.get(), /* bus */
-                nullptr,                /* sender */
-                DBUS_INTERFACE_UPSTART, /* interface */
-                "EventEmitted",         /* signal */
-                DBUS_PATH_UPSTART,      /* path */
-                "started",              /* arg0 */
-                G_DBUS_SIGNAL_FLAGS_NONE,
-                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
-                   gpointer user_data) {
-                    auto data = static_cast<upstartEventData*>(user_data);
-                    auto reg = data->weakReg.lock();
-
-                    if (!reg)
-                    {
-                        g_warning("Registry object invalid!");
-                        return;
-                    }
-
-                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
-                    auto upstart = std::dynamic_pointer_cast<Upstart>(reg->impl->jobs);
-                    upstart->upstartEventEmitted(upstart->sig_jobStarted, sparams, reg);
-                },    /* callback */
-                data, /* user data */
-                [](gpointer user_data) {
-                    auto data = static_cast<upstartEventData*>(user_data);
-                    delete data;
-                }); /* user data destroy */
-
-            return true;
-        });
-    });
-
-    return sig_jobStarted;
-}
-
-/** Grab the signal object for application stopping. If we're not already listing for
-    those signals this sets up a listener for them. */
-core::Signal<const std::string&, const std::string&, const std::string&>& Upstart::jobStopped()
-{
-    std::call_once(flag_jobStopped, [this]() {
-        auto reg = registry_.lock();
-
-        reg->impl->thread.executeOnThread<bool>([this, reg]() {
-            upstartEventData* data = new upstartEventData{reg};
-
-            handle_jobStopped = g_dbus_connection_signal_subscribe(
-                reg->impl->_dbus.get(), /* bus */
-                nullptr,                /* sender */
-                DBUS_INTERFACE_UPSTART, /* interface */
-                "EventEmitted",         /* signal */
-                DBUS_PATH_UPSTART,      /* path */
-                "stopped",              /* arg0 */
-                G_DBUS_SIGNAL_FLAGS_NONE,
-                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
-                   gpointer user_data) {
-                    auto data = static_cast<upstartEventData*>(user_data);
-                    auto reg = data->weakReg.lock();
-
-                    if (!reg)
-                    {
-                        g_warning("Registry object invalid!");
-                        return;
-                    }
-
-                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
-                    auto upstart = std::dynamic_pointer_cast<Upstart>(reg->impl->jobs);
-                    upstart->upstartEventEmitted(upstart->sig_jobStopped, sparams, reg);
-                },    /* callback */
-                data, /* user data */
-                [](gpointer user_data) {
-                    auto data = static_cast<upstartEventData*>(user_data);
-                    delete data;
-                }); /* user data destroy */
-
-            return true;
-        });
-    });
-
-    return sig_jobStopped;
-}
-
-/** Grab the signal object for application failing. If we're not already listing for
-    those signals this sets up a listener for them. */
-core::Signal<const std::string&, const std::string&, const std::string&, Registry::FailureType>& Upstart::jobFailed()
-{
-    std::call_once(flag_jobFailed, [this]() {
-        auto reg = registry_.lock();
-
-        reg->impl->thread.executeOnThread<bool>([this, reg]() {
-            upstartEventData* data = new upstartEventData{reg};
-
-            handle_jobFailed = g_dbus_connection_signal_subscribe(
-                reg->impl->_dbus.get(),          /* bus */
-                nullptr,                         /* sender */
-                "com.canonical.UbuntuAppLaunch", /* interface */
-                "ApplicationFailed",             /* signal */
-                "/",                             /* path */
-                nullptr,                         /* arg0 */
-                G_DBUS_SIGNAL_FLAGS_NONE,
-                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
-                   gpointer user_data) {
-                    auto data = static_cast<upstartEventData*>(user_data);
-                    auto reg = data->weakReg.lock();
-
-                    if (!reg)
-                    {
-                        g_warning("Registry object invalid!");
-                        return;
-                    }
-
-                    const gchar* sappid = nullptr;
-                    const gchar* sinstid = nullptr;
-                    const gchar* typestr = nullptr;
-
-                    Registry::FailureType type = Registry::FailureType::CRASH;
-                    g_variant_get(params, "(&s&s&s)", &sappid, &sinstid, &typestr);
-
-                    if (g_strcmp0("crash", typestr) == 0)
-                    {
-                        type = Registry::FailureType::CRASH;
-                    }
-                    else if (g_strcmp0("start-failure", typestr) == 0)
-                    {
-                        type = Registry::FailureType::START_FAILURE;
-                    }
-                    else
-                    {
-                        g_warning("Application failure type '%s' unknown, reporting as a crash", typestr);
-                    }
-
-                    auto upstart = std::dynamic_pointer_cast<Upstart>(reg->impl->jobs);
-                    upstart->sig_jobFailed("application-snap", sappid, sinstid, type);
-                },    /* callback */
-                data, /* user data */
-                [](gpointer user_data) {
-                    auto data = static_cast<upstartEventData*>(user_data);
-                    delete data;
-                }); /* user data destroy */
-
-            return true;
-        });
-    });
-
-    return sig_jobFailed;
-}
-
-/** 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;
-
-    auto registry = registry_.lock();
-
-    cgManager_ = registry->impl->thread.executeOnThread<std::shared_ptr<GDBusConnection>>([this, 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");
-            return registry->impl->_dbus;
-        }
-
-        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()); });
-
-        GError* error = nullptr;
-        auto retval = std::shared_ptr<GDBusConnection>(
-            g_dbus_connection_new_for_address_sync(CGMANAGER_DBUS_PATH,                           /* cgmanager path */
-                                                   G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, /* flags */
-                                                   nullptr,                                       /* Auth Observer */
-                                                   cancel.get(),                                  /* Cancellable */
-                                                   &error),
-            [](GDBusConnection* con) { g_clear_object(&con); });
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to get CGManager connection: %s", error->message);
-            g_error_free(error);
-        }
-
-        return retval;
-    });
-
-    /* NOTE: This will execute on the thread */
-    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());
-
-        auto vtpids = g_dbus_connection_call_sync(
-            lmanager.get(),                     /* connection */
-            name,                               /* bus name for direct connection is nullptr */
-            "/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 {};
-        }
-
-        auto 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;
-            auto 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;
-            auto 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 {};
-            }
-
-            auto 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))
-            {
-                auto 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;
-                }
-
-                auto props_dict = g_variant_get_child_value(props_tuple, 0);
-
-                auto namev = g_variant_lookup_value(props_dict, "name", G_VARIANT_TYPE_STRING);
-                if (namev != nullptr)
-                {
-                    auto name = g_variant_get_string(namev, nullptr);
-                    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::string> Upstart::runningAppIds(const std::list<std::string>& jobs)
-{
-    std::list<std::string> instances;
-
-    for (const auto& job : jobs)
-    {
-        auto jobinst = upstartInstancesForJob(job);
-
-        if (job != "application-click")
-        {
-            /* Remove the instance ID */
-            std::transform(jobinst.begin(), jobinst.end(), jobinst.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 {};
-                               }
-                           });
-        }
-
-        instances.splice(instances.begin(), jobinst);
-    }
-
-    /* Deduplicate Set */
-    std::set<std::string> instanceset;
-    for (auto instance : instances)
-    {
-        if (!instance.empty())
-            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());
-
-    return {instanceset.begin(), instanceset.end()};
-}
-
-}  // namespace manager
-}  // namespace jobs
-}  // namespace app_launch
-}  // namespace ubuntu

=== removed file 'libubuntu-app-launch/jobs-upstart.h'
--- libubuntu-app-launch/jobs-upstart.h	2017-03-21 03:20:55 +0000
+++ libubuntu-app-launch/jobs-upstart.h	1970-01-01 00:00:00 +0000
@@ -1,100 +0,0 @@
-/*
- * 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::string> runningAppIds(const std::list<std::string>& jobs) override;
-
-    virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) override;
-
-    /* Signals to apps */
-    virtual core::Signal<const std::string&, const std::string&, const std::string&>& jobStarted() override;
-    virtual core::Signal<const std::string&, const std::string&, const std::string&>& jobStopped() override;
-    virtual core::Signal<const std::string&, const std::string&, const std::string&, Registry::FailureType>& jobFailed()
-        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_;
-
-    core::Signal<const std::string&, const std::string&, const std::string&> sig_jobStarted;
-    core::Signal<const std::string&, const std::string&, const std::string&> sig_jobStopped;
-    core::Signal<const std::string&, const std::string&, const std::string&, Registry::FailureType> sig_jobFailed;
-
-    guint handle_jobStarted{0}; /**< GDBus signal watcher handle for app started signal */
-    guint handle_jobStopped{0}; /**< GDBus signal watcher handle for app stopped signal */
-    guint handle_jobFailed{0};  /**< GDBus signal watcher handle for app failed signal */
-
-    std::once_flag flag_jobStarted; /**< Variable to track to see if signal handlers are installed for application
-                                       started */
-    std::once_flag flag_jobStopped; /**< Variable to track to see if signal handlers are installed for application
-                                       stopped */
-    std::once_flag
-        flag_jobFailed; /**< Variable to track to see if signal handlers are installed for application failed */
-
-    void upstartEventEmitted(core::Signal<const std::string&, const std::string&, const std::string&>& signal,
-                             std::shared_ptr<GVariant> params,
-                             const std::shared_ptr<Registry>& reg);
-};
-
-}  // namespace manager
-}  // namespace jobs
-}  // namespace app_launch
-}  // namespace ubuntu

=== modified file 'libubuntu-app-launch/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2017-03-21 03:20:55 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2017-03-21 03:20:55 +0000
@@ -21,7 +21,6 @@
 #include "application-icon-finder.h"
 #include "application-impl-base.h"
 #include <regex>
-#include <upstart.h>
 
 namespace ubuntu
 {

=== modified file 'libubuntu-app-launch/second-exec-core.c'
--- libubuntu-app-launch/second-exec-core.c	2016-12-14 23:03:15 +0000
+++ libubuntu-app-launch/second-exec-core.c	2017-03-21 03:20:55 +0000
@@ -18,8 +18,6 @@
  */
 
 #include <gio/gio.h>
-#include <nih/alloc.h>
-#include <libnih-dbus.h>
 #include "libubuntu-app-launch/ubuntu-app-launch.h"
 #include "helpers.h"
 #include "second-exec-core.h"

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.cpp'
--- libubuntu-app-launch/ubuntu-app-launch.cpp	2017-03-21 03:20:55 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.cpp	2017-03-21 03:20:55 +0000
@@ -19,7 +19,6 @@
 
 extern "C" {
 #include "ubuntu-app-launch.h"
-#include <upstart.h>
 #include <gio/gio.h>
 #include <gio/gunixfdlist.h>
 #include <string.h>

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2017-02-15 15:10:07 +0000
+++ tests/CMakeLists.txt	2017-03-21 03:20:55 +0000
@@ -41,13 +41,12 @@
 add_executable (libual-test
 	libual-test.cc
 	mir-mock.cpp)
-target_link_libraries (libual-test gtest_main ${GTEST_MAIN_LIBRARIES} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} ubuntu-launcher)
+target_link_libraries (libual-test gtest_main ${GTEST_MAIN_LIBRARIES} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} launcher-static)
 
 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_main ${GTEST_MAIN_LIBRARIES} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} ubuntu-launcher)
+target_link_libraries (libual-cpp-test gtest_main ${GTEST_MAIN_LIBRARIES} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} launcher-static)
 
 add_executable (data-spew
 	data-spew.c)
@@ -123,45 +122,6 @@
 
 file(COPY data DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 
-# Failure Test
-
-add_definitions ( -DAPP_FAILED_TOOL="${CMAKE_BINARY_DIR}/application-failed" )
-
-add_executable (failure-test
-	failure-test.cc)
-target_link_libraries (failure-test gtest_main ${GTEST_MAIN_LIBRARIES} ubuntu-launcher)
-add_test (failure-test failure-test)
-
-# ZG Test
-
-add_definitions ( -DZG_EVENT_TOOL="${CMAKE_BINARY_DIR}/zg-report-app" )
-
-add_executable (zg-test
-	zg-test.cc)
-target_link_libraries (zg-test gtest_main ${GTEST_MAIN_LIBRARIES} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
-add_test (zg-test zg-test)
-
-# Exec Line Exec Test
-
-configure_file("exec-test.sh.in" "${CMAKE_CURRENT_BINARY_DIR}/exec-test.sh" @ONLY) 
-add_test (exec-test "${CMAKE_CURRENT_BINARY_DIR}/exec-test.sh")
-
-# Exec Utils
-
-add_executable (exec-util-test
-	exec-util-test.cc)
-target_link_libraries (exec-util-test gtest_main ubuntu-launcher ${GTEST_MAIN_LIBRARIES} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
-add_test (exec-util-test exec-util-test)
-
-# CGroup Reap Test
-
-add_definitions ( -DCG_REAP_TOOL="${CMAKE_BINARY_DIR}/cgroup-reap-all" )
-
-add_executable (cgroup-reap-test
-	cgroup-reap-test.cc)
-target_link_libraries (cgroup-reap-test gtest_main ${GTEST_MAIN_LIBRARIES} ${DBUSTEST_LIBRARIES} ${GIO2_LIBRARIES})
-add_test (cgroup-reap-test cgroup-reap-test)
-
 # Desktop Hook Test
 
 configure_file ("click-desktop-hook-db/test.conf.in" "${CMAKE_CURRENT_BINARY_DIR}/click-desktop-hook-db/test.conf" @ONLY)
@@ -182,7 +142,6 @@
 
 add_custom_target(format-tests
 	COMMAND clang-format -i -style=file
-	failure-test.cc
 	application-info-desktop.cpp
 	libual-cpp-test.cc
 	list-apps.cpp
@@ -197,4 +156,5 @@
 	spew-master.h
 	systemd-mock.h
 	zg-test.cc
+	zg-mock.h
 )

=== removed file 'tests/cgroup-reap-test.cc'
--- tests/cgroup-reap-test.cc	2017-01-11 23:22:52 +0000
+++ tests/cgroup-reap-test.cc	1970-01-01 00:00:00 +0000
@@ -1,145 +0,0 @@
-/*
- * Copyright 2014 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 <gtest/gtest.h>
-#include <gio/gio.h>
-#include <libdbustest/dbus-test.h>
-
-class CGroupReap : public ::testing::Test
-{
-	protected:
-		DbusTestService * service = NULL;
-		DbusTestDbusMock * cgmock = NULL;
-		GDBusConnection * bus = NULL;
-		GPid sleeppid = 0;
-
-		virtual void SetUp() {
-			const gchar * argv[] = { "sleep", "30", NULL };
-			g_spawn_async(NULL,
-			              (gchar **)argv,
-			              NULL, /* env */
-			              G_SPAWN_SEARCH_PATH,
-			              NULL, NULL, /* child setup */
-			              &sleeppid,
-			              NULL); /* error */
-			ASSERT_NE(0, sleeppid);
-
-			service = dbus_test_service_new(NULL);
-
-			/* Create the cgroup manager mock */
-			cgmock = dbus_test_dbus_mock_new("org.test.cgmock");
-			g_setenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME", "org.test.cgmock", TRUE);
-
-			DbusTestDbusMockObject * cgobject = dbus_test_dbus_mock_get_object(cgmock, "/org/linuxcontainers/cgmanager", "org.linuxcontainers.cgmanager0_0", NULL);
-			/* This Python code executes in dbusmock and checks to see if the sleeping
-			   process is running. If it is, it returns its PID in the list of PIDs, if
-			   not it doesn't return any PIDs. */
-			gchar * pythoncode = g_strdup_printf(
-				"if os.spawnlp(os.P_WAIT, 'ps', 'ps', '%d') == 0 :\n"
-				"  ret = [ %d ]\n"
-				"else:\n"
-				"  ret = [ ]",
-				sleeppid, sleeppid);
-			dbus_test_dbus_mock_object_add_method(cgmock, cgobject,
-				"GetTasksRecursive",
-				G_VARIANT_TYPE("(ss)"),
-				G_VARIANT_TYPE("ai"),
-				pythoncode,
-				NULL);
-			g_free(pythoncode);
-
-			/* Put it together */
-			dbus_test_service_add_task(service, DBUS_TEST_TASK(cgmock));
-			dbus_test_service_start_tasks(service);
-
-			bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-			g_dbus_connection_set_exit_on_close(bus, FALSE);
-			g_object_add_weak_pointer(G_OBJECT(bus), (gpointer *)&bus);
-
-			/* Make sure we pretend the CG manager is just on our bus */
-			g_setenv("UBUNTU_APP_LAUNCH_CG_MANAGER_SESSION_BUS", "YES", TRUE);
-		}
-
-		virtual void TearDown() {
-			g_clear_object(&cgmock);
-			g_clear_object(&service);
-
-			g_object_unref(bus);
-
-			unsigned int cleartry = 0;
-			while (bus != NULL && cleartry < 100) {
-				pause(100);
-				cleartry++;
-			}
-			ASSERT_EQ(bus, nullptr);
-
-			g_debug("Killing the sleeper: %d", sleeppid);
-			kill(sleeppid, SIGKILL);
-		}
-
-		static gboolean pause_helper (gpointer pmainloop) {
-			g_main_loop_quit(static_cast<GMainLoop *>(pmainloop));
-			return G_SOURCE_REMOVE;
-		}
-
-		void pause (guint time) {
-			if (time > 0) {
-				GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
-				g_timeout_add(time, pause_helper, mainloop);
-
-				g_main_loop_run(mainloop);
-
-				g_main_loop_unref(mainloop);
-			}
-
-			while (g_main_pending()) {
-				g_main_iteration(TRUE);
-			}
-		}
-
-		bool sleepRunning (void) {
-			gint status = 1;
-			gchar * cmdline = g_strdup_printf("ps %d", sleeppid);
-
-			g_spawn_command_line_sync(cmdline, NULL, NULL, &status, NULL);
-			g_free(cmdline);
-
-			return status == 0;
-		}
-};
-
-TEST_F(CGroupReap, KillSleep)
-{
-	g_setenv("UPSTART_JOB", "foo", TRUE);
-	g_setenv("UPSTART_INSTANCE", "bar", TRUE);
-
-	ASSERT_TRUE(g_spawn_command_line_sync(CG_REAP_TOOL, NULL, NULL, NULL, NULL));
-	EXPECT_FALSE(sleepRunning());
-
-	DbusTestDbusMockObject * cgobject = dbus_test_dbus_mock_get_object(cgmock, "/org/linuxcontainers/cgmanager", "org.linuxcontainers.cgmanager0_0", NULL);
-	const DbusTestDbusMockCall * calls = NULL;
-	guint len = 0;
-
-	calls = dbus_test_dbus_mock_object_get_method_calls(cgmock, cgobject, "GetTasksRecursive", &len, NULL);
-	EXPECT_EQ(2u, len);
-	EXPECT_STREQ("GetTasksRecursive", calls->name);
-	EXPECT_TRUE(g_variant_equal(calls->params, g_variant_new("(ss)", "freezer", "")));
-	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(cgmock, cgobject, NULL));
-}
-

=== removed file 'tests/exec-test-archcolon.sh'
--- tests/exec-test-archcolon.sh	2014-04-30 21:43:28 +0000
+++ tests/exec-test-archcolon.sh	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-#!/bin/bash -e
-
-if [ "$PATH" != "$APP_DIR:/path" ] ; then
-	echo "Bad PATH: $PATH"
-	exit 1
-fi
-
-if [ "$LD_LIBRARY_PATH" != "$APP_DIR/lib:/lib" ] ; then
-	echo "Bad LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
-	exit 1
-fi
-
-if [ "$QML2_IMPORT_PATH" != "/bar/qml/import" ] ; then
-	echo "Bad QML import path: $QML2_IMPORT_PATH"
-	exit 1
-fi
-
-exit 0

=== removed file 'tests/exec-test-colon.sh'
--- tests/exec-test-colon.sh	2014-04-30 21:43:28 +0000
+++ tests/exec-test-colon.sh	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-#!/bin/bash -e
-
-if [ "$PATH" != "/path" ] ; then
-	echo "Bad PATH: $PATH"
-	exit 1
-fi
-
-if [ "$LD_LIBRARY_PATH" != "/lib" ] ; then
-	echo "Bad LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
-	exit 1
-fi
-
-if [ "$QML2_IMPORT_PATH" != "/bar/qml/import" ] ; then
-	echo "Bad QML import path: $QML2_IMPORT_PATH"
-	exit 1
-fi
-
-exit 0

=== removed file 'tests/exec-test-full.sh'
--- tests/exec-test-full.sh	2014-04-30 21:43:28 +0000
+++ tests/exec-test-full.sh	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-#!/bin/bash -e
-
-if [ "$PATH" != "$APP_DIR/lib/64bit-amazing/bin:$APP_DIR:/path" ] ; then
-	echo "Bad PATH: $PATH"
-	exit 1
-fi
-
-if [ "$LD_LIBRARY_PATH" != "$APP_DIR/lib/64bit-amazing:$APP_DIR/lib:/lib" ] ; then
-	echo "Bad LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
-	exit 1
-fi
-
-if [ "$QML2_IMPORT_PATH" != "/bar/qml/import:$APP_DIR/lib/64bit-amazing" ] ; then
-	echo "Bad QML import path: $QML2_IMPORT_PATH"
-	exit 1
-fi
-
-exit 0

=== removed file 'tests/exec-test-noarch.sh'
--- tests/exec-test-noarch.sh	2014-04-30 21:43:28 +0000
+++ tests/exec-test-noarch.sh	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-#!/bin/bash -e
-
-if [ "$PATH" != "$APP_DIR:/path" ] ; then
-	echo "Bad PATH: $PATH"
-	exit 1
-fi
-
-if [ "$LD_LIBRARY_PATH" != "$APP_DIR/lib:/lib" ] ; then
-	echo "Bad LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
-	exit 1
-fi
-
-if [ "$QML2_IMPORT_PATH" != "/bar/qml/import" ] ; then
-	echo "Bad QML import path: $QML2_IMPORT_PATH"
-	exit 1
-fi
-
-exit 0

=== removed file 'tests/exec-test-noinit.sh'
--- tests/exec-test-noinit.sh	2014-04-30 21:43:28 +0000
+++ tests/exec-test-noinit.sh	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-#!/bin/bash -e
-
-if [ "$PATH" != "$APP_DIR/lib/64bit-amazing/bin:$APP_DIR" ] ; then
-	echo "Bad PATH: $PATH"
-	exit 1
-fi
-
-if [ "$LD_LIBRARY_PATH" != "$APP_DIR/lib/64bit-amazing:$APP_DIR/lib" ] ; then
-	echo "Bad LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
-	exit 1
-fi
-
-if [ "$QML2_IMPORT_PATH" != "$APP_DIR/lib/64bit-amazing" ] ; then
-	echo "Bad QML import path: $QML2_IMPORT_PATH"
-	exit 1
-fi
-
-exit 0

=== removed file 'tests/exec-test-nullstr.sh'
--- tests/exec-test-nullstr.sh	2014-05-01 15:04:19 +0000
+++ tests/exec-test-nullstr.sh	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-#!/bin/bash -e
-
-if [ "$PATH" != "$APP_DIR/lib/64bit-amazing/bin:$APP_DIR" ] ; then
-	echo "Bad PATH: $PATH"
-	exit 1
-fi
-
-if [ "$LD_LIBRARY_PATH" != "$APP_DIR/lib/64bit-amazing:$APP_DIR/lib" ] ; then
-	echo "Bad LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
-	exit 1
-fi
-
-if [ "$QML2_IMPORT_PATH" != "$APP_DIR/lib/64bit-amazing" ] ; then
-	echo "Bad QML import path: $QML2_IMPORT_PATH"
-	exit 1
-fi
-
-exit 0

=== removed file 'tests/exec-test.sh.in'
--- tests/exec-test.sh.in	2014-06-05 03:21:12 +0000
+++ tests/exec-test.sh.in	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-#!/bin/bash -e
-
-export PATH=/path
-export LD_LIBRARY_PATH=/lib
-export APP_EXEC=@CMAKE_CURRENT_SOURCE_DIR@/exec-test-full.sh
-export APP_DIR=@CMAKE_CURRENT_BINARY_DIR@
-export QML2_IMPORT_PATH=/bar/qml/import
-export UBUNTU_APP_LAUNCH_ARCH=64bit-amazing
-
-echo "Testing Full Test"
-@CMAKE_BINARY_DIR@/exec-line-exec
-
-export PATH=/path
-export LD_LIBRARY_PATH=/lib
-export APP_EXEC=@CMAKE_CURRENT_SOURCE_DIR@/exec-test-noarch.sh
-export APP_DIR=@CMAKE_CURRENT_BINARY_DIR@
-export QML2_IMPORT_PATH=/bar/qml/import
-unset UBUNTU_APP_LAUNCH_ARCH
-
-echo "Testing Noarch Test"
-@CMAKE_BINARY_DIR@/exec-line-exec
-
-unset PATH
-unset LD_LIBRARY_PATH
-export APP_EXEC=@CMAKE_CURRENT_SOURCE_DIR@/exec-test-noinit.sh
-export APP_DIR=@CMAKE_CURRENT_BINARY_DIR@
-unset QML2_IMPORT_PATH
-export UBUNTU_APP_LAUNCH_ARCH=64bit-amazing
-
-echo "Testing Uninitialized Test"
-@CMAKE_BINARY_DIR@/exec-line-exec
-
-export PATH=/path
-export LD_LIBRARY_PATH=/lib
-export APP_EXEC=@CMAKE_CURRENT_SOURCE_DIR@/exec-test-colon.sh
-export APP_DIR=@CMAKE_CURRENT_BINARY_DIR@/foo:bar
-export QML2_IMPORT_PATH=/bar/qml/import
-export UBUNTU_APP_LAUNCH_ARCH=64bit-amazing
-
-echo "Testing Colon Test"
-@CMAKE_BINARY_DIR@/exec-line-exec
-
-export PATH=/path
-export LD_LIBRARY_PATH=/lib
-export APP_EXEC=@CMAKE_CURRENT_SOURCE_DIR@/exec-test-archcolon.sh
-export APP_DIR=@CMAKE_CURRENT_BINARY_DIR@
-export QML2_IMPORT_PATH=/bar/qml/import
-export UBUNTU_APP_LAUNCH_ARCH=64bit-amazing:amazinger
-
-echo "Testing Arch Colon Test"
-@CMAKE_BINARY_DIR@/exec-line-exec
-
-export PATH=""
-export LD_LIBRARY_PATH=""
-export APP_EXEC=@CMAKE_CURRENT_SOURCE_DIR@/exec-test-nullstr.sh
-export APP_DIR=@CMAKE_CURRENT_BINARY_DIR@
-export QML2_IMPORT_PATH=""
-export UBUNTU_APP_LAUNCH_ARCH=64bit-amazing
-
-echo "Testing Null string Test"
-@CMAKE_BINARY_DIR@/exec-line-exec
-

=== removed file 'tests/exec-util-test.cc'
--- tests/exec-util-test.cc	2017-03-06 19:38:17 +0000
+++ tests/exec-util-test.cc	1970-01-01 00:00:00 +0000
@@ -1,349 +0,0 @@
-/*
- * Copyright 2013 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 <map>
-#include <functional>
-
-#include <gtest/gtest.h>
-#include <libdbustest/dbus-test.h>
-#include <gio/gio.h>
-#include <libubuntu-app-launch/ubuntu-app-launch.h>
-#include <libubuntu-app-launch/registry.h>
-
-#include "eventually-fixture.h"
-#include "libertine-service.h"
-
-class ExecUtil : public EventuallyFixture
-{
-	protected:
-		DbusTestService * service = NULL;
-		DbusTestDbusMock * mock = NULL;
-		std::shared_ptr<LibertineService> libertine;
-		GDBusConnection * bus = NULL;
-		std::string laststarted;
-
-	protected:
-		static void starting_cb (const gchar * appid, gpointer user_data) {
-			g_debug("I'm too sexy to callback");
-			auto pthis = static_cast<ExecUtil*>(user_data);
-			pthis->laststarted = appid;
-		}
-
-		virtual void SetUp() {
-			g_setenv("UPSTART_JOB", "made-up-job", TRUE);
-			g_setenv("XDG_DATA_DIRS", CMAKE_SOURCE_DIR, TRUE);
-			g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
-			g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
-			g_setenv("UBUNTU_APP_LAUNCH_LIBERTINE_LAUNCH", "libertine-launch", TRUE);
-			g_setenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET", "/this/should/not/exist", TRUE);
-			g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
-
-			service = dbus_test_service_new(NULL);
-
-			mock = dbus_test_dbus_mock_new("com.ubuntu.Upstart");
-
-			DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", NULL);
-
-			dbus_test_dbus_mock_object_add_method(mock, obj,
-				"GetJobByName",
-				G_VARIANT_TYPE("s"),
-				G_VARIANT_TYPE("o"),
-				"ret = dbus.ObjectPath('/com/test/job')",
-				NULL);
-
-			DbusTestDbusMockObject * jobobj = dbus_test_dbus_mock_get_object(mock, "/com/test/job", "com.ubuntu.Upstart0_6.Job", NULL);
-
-			dbus_test_dbus_mock_object_add_method(mock, jobobj,
-				"Start",
-				G_VARIANT_TYPE("(asb)"),
-				NULL,
-				"",
-				NULL);
-
-			dbus_test_service_add_task(service, DBUS_TEST_TASK(mock));
-
-			libertine = std::make_shared<LibertineService>();
-			dbus_test_service_add_task(service, *libertine);
-			dbus_test_service_add_task(service, libertine->waitTask());
-
-			dbus_test_service_start_tasks(service);
-
-			bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-			g_dbus_connection_set_exit_on_close(bus, FALSE);
-			g_object_add_weak_pointer(G_OBJECT(bus), (gpointer *)&bus);
-
-			/* Make the handshake clear faster */
-			ubuntu_app_launch_observer_add_app_starting(starting_cb, this);
-		}
-
-		virtual void TearDown() {
-			ubuntu_app_launch_observer_delete_app_starting(starting_cb, this);
-			ubuntu::app_launch::Registry::clearDefault();
-
-			libertine.reset();
-			g_clear_object(&mock);
-			g_clear_object(&service);
-
-			g_object_unref(bus);
-
-			ASSERT_EVENTUALLY_EQ(nullptr, bus);
-		}
-
-		inline void StartCheckEnv (const std::string& appid, std::map<std::string, std::function<void(const gchar *)>> enums) {
-			std::map<std::string, bool> env_found;
-			DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/test/job", "com.ubuntu.Upstart0_6.Job", nullptr);
-
-			g_setenv("TEST_CLICK_DB", "click-db-dir", TRUE);
-			g_setenv("TEST_CLICK_USER", "test-user", TRUE);
-			g_setenv("UBUNTU_APP_LAUNCH_LINK_FARM", CMAKE_SOURCE_DIR "/link-farm", TRUE);
-
-			laststarted.clear();
-			ASSERT_TRUE(ubuntu_app_launch_start_application(appid.c_str(), nullptr));
-			ASSERT_EVENTUALLY_EQ(appid, laststarted);
-
-			guint len = 0;
-			const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, nullptr);
-
-			ASSERT_EQ(1u, len);
-			ASSERT_NE(nullptr, calls);
-			ASSERT_STREQ("Start", calls[0].name);
-
-			GVariant * envarray = g_variant_get_child_value(calls[0].params, 0);
-			GVariantIter iter;
-			g_variant_iter_init(&iter, envarray);
-			gchar * envvar = NULL;
-
-			while (g_variant_iter_loop(&iter, "s", &envvar)) {
-				g_debug("Looking at variable: %s", envvar);
-				gchar * var = g_strdup(envvar);
-
-				gchar * equal = g_strstr_len(var, -1, "=");
-				ASSERT_NE(equal, nullptr);
-
-				equal[0] = '\0';
-				gchar * value = &(equal[1]);
-
-				/* Test the variable */
-				auto varfunc = enums[var];
-				EXPECT_NE(nullptr, varfunc);
-				if (varfunc) {
-					varfunc(value);
-				} else {
-					g_warning("Unable to find function for '%s'", var);
-				}
-
-				/* Mark it as found */
-				env_found[var] = true;
-
-				g_free(var);
-			}
-
-			g_variant_unref(envarray);
-
-			for(auto enumval : enums) {
-				EXPECT_TRUE(env_found[enumval.first]);
-				if (!env_found[enumval.first]) {
-					g_warning("Unable to find enum %s", enumval.first.c_str());
-				}
-			}
-		}
-};
-
-static void
-nocheck (const gchar *)
-{
-}
-
-TEST_F(ExecUtil, ClickExec)
-{
-#define APP_DIR CMAKE_SOURCE_DIR "/click-root-dir/.click/users/test-user/com.test.good"
-
-	StartCheckEnv("com.test.good_application_1.2.3", {
-		{"UBUNTU_APPLICATION_ISOLATION", [](const gchar * value) {
-			EXPECT_STREQ("1", value); }},
-		{"XDG_CACHE_HOME", nocheck},
-		{"XDG_CONFIG_HOME", nocheck},
-		{"XDG_DATA_HOME", nocheck},
-		{"XDG_RUNTIME_DIR", nocheck},
-		{"XDG_DATA_DIRS", [](const gchar * value) {
-			EXPECT_TRUE(g_str_has_prefix(value, APP_DIR ":")); }},
-		{"TMPDIR", [](const gchar * value) {
-			EXPECT_TRUE(g_str_has_suffix(value, "com.test.good")); }},
-		{"__GL_SHADER_DISK_CACHE_PATH", [](const gchar * value) {
-			EXPECT_TRUE(g_str_has_suffix(value, "com.test.good")); }},
-		{"APP_DIR", [](const gchar * value) {
-			EXPECT_STREQ(APP_DIR, value); }},
-		{"APP_EXEC", [](const gchar * value) {
-			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
-}
-
-TEST_F(ExecUtil, DesktopExec)
-{
-	StartCheckEnv("foo", {
-		{"APP_EXEC", [](const gchar * value) {
-			EXPECT_STREQ("libertine-launch foo", value); }},
-		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
-			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/foo.desktop", value); }},
-		{"APP_EXEC_POLICY", [](const gchar * value) {
-			EXPECT_STREQ("unconfined", value); }},
-		{"APP_ID", [](const gchar * value) {
-			EXPECT_STREQ("foo", value); }},
-		{"INSTANCE_ID", nocheck},
-		{"APP_LAUNCHER_PID", [](const gchar * value) {
-			EXPECT_EQ(getpid(), atoi(value)); }},
-		{"APP_XMIR_ENABLE", [](const gchar * value) {
-			EXPECT_STREQ("1", value); }},
-	});
-}
-
-TEST_F(ExecUtil, DesktopMir)
-{
-	StartCheckEnv("xmir", {
-		{"APP_EXEC", [](const gchar * value) {
-			EXPECT_STREQ("libertine-launch xfoo", value); }},
-		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
-			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/xmir.desktop", value); }},
-		{"APP_EXEC_POLICY", [](const gchar * value) {
-			EXPECT_STREQ("unconfined", value); }},
-		{"APP_ID", [](const gchar * value) {
-			EXPECT_STREQ("xmir", value); }},
-		{"INSTANCE_ID", nocheck},
-		{"APP_LAUNCHER_PID", [](const gchar * value) {
-			EXPECT_EQ(getpid(), atoi(value)); }},
-		{"APP_XMIR_ENABLE", [](const gchar * value) {
-			EXPECT_STREQ("1", value); }},
-	});
-}
-
-TEST_F(ExecUtil, DesktopNoMir)
-{
-	StartCheckEnv("noxmir", {
-		{"APP_EXEC", [](const gchar * value) {
-			EXPECT_STREQ("noxmir", value); }},
-		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
-			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/noxmir.desktop", value); }},
-		{"APP_EXEC_POLICY", [](const gchar * value) {
-			EXPECT_STREQ("unconfined", value); }},
-		{"APP_ID", [](const gchar * value) {
-			EXPECT_STREQ("noxmir", value); }},
-		{"INSTANCE_ID", nocheck},
-		{"APP_LAUNCHER_PID", [](const gchar * value) {
-			EXPECT_EQ(getpid(), atoi(value)); }},
-		{"APP_XMIR_ENABLE", [](const gchar * value) {
-			EXPECT_STREQ("0", value); }},
-	});
-}
-
-TEST_F(ExecUtil, ClickMir)
-{
-	StartCheckEnv("com.test.mir_mir_1", {
-		{"UBUNTU_APPLICATION_ISOLATION", nocheck},
-		{"XDG_CACHE_HOME", nocheck},
-		{"XDG_CONFIG_HOME", nocheck},
-		{"XDG_DATA_HOME", nocheck},
-		{"XDG_RUNTIME_DIR", nocheck},
-		{"XDG_DATA_DIRS", nocheck},
-		{"TMPDIR", nocheck},
-		{"__GL_SHADER_DISK_CACHE_PATH", nocheck},
-		{"APP_DIR", nocheck},
-		{"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},
-	});
-}
-
-TEST_F(ExecUtil, ClickNoMir)
-{
-	StartCheckEnv("com.test.mir_nomir_1", {
-		{"UBUNTU_APPLICATION_ISOLATION", nocheck},
-		{"XDG_CACHE_HOME", nocheck},
-		{"XDG_CONFIG_HOME", nocheck},
-		{"XDG_DATA_HOME", nocheck},
-		{"XDG_RUNTIME_DIR", nocheck},
-		{"XDG_DATA_DIRS", nocheck},
-		{"TMPDIR", nocheck},
-		{"__GL_SHADER_DISK_CACHE_PATH", nocheck},
-		{"APP_DIR", nocheck},
-		{"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},
-	});
-}
-
-TEST_F(ExecUtil, LibertineExec)
-{
-	StartCheckEnv("container-name_test_0.0", {
-		{"APP_EXEC", [](const gchar * value) {
-			EXPECT_STREQ("libertine-launch \"--id=container-name\" test", value); }},
-		{"APP_EXEC_POLICY", [](const gchar * value) {
-			EXPECT_STREQ("unconfined", value); }},
-		{"APP_ID", [](const gchar * value) {
-			EXPECT_STREQ("container-name_test_0.0", value); }},
-		{"APP_LAUNCHER_PID", [](const gchar * value) {
-			EXPECT_EQ(getpid(), atoi(value)); }},
-		{"INSTANCE_ID", nocheck},
-		{"APP_XMIR_ENABLE", [](const gchar * value) {
-			EXPECT_STREQ("1", value); }},
-	});
-}
-
-TEST_F(ExecUtil, LibertineExecUser)
-{
-	StartCheckEnv("container-name_user-app_0.0", {
-		{"APP_EXEC", [](const gchar * value) {
-			EXPECT_STREQ("libertine-launch \"--id=container-name\" user-app", value); }},
-		{"APP_EXEC_POLICY", [](const gchar * value) {
-			EXPECT_STREQ("unconfined", value); }},
-		{"APP_ID", [](const gchar * value) {
-			EXPECT_STREQ("container-name_user-app_0.0", value); }},
-		{"APP_LAUNCHER_PID", [](const gchar * value) {
-			EXPECT_EQ(getpid(), atoi(value)); }},
-		{"INSTANCE_ID", nocheck},
-		{"APP_XMIR_ENABLE", [](const gchar * value) {
-			EXPECT_STREQ("1", value); }},
-	});
-}

=== removed file 'tests/failure-test.cc'
--- tests/failure-test.cc	2017-01-11 23:48:12 +0000
+++ tests/failure-test.cc	1970-01-01 00:00:00 +0000
@@ -1,165 +0,0 @@
-/*
- * Copyright 2013 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 "eventually-fixture.h"
-#include "registry.h"
-#include <gio/gio.h>
-#include <glib/gstdio.h>
-#include <gtest/gtest.h>
-
-class FailureTest : public EventuallyFixture
-{
-private:
-    GTestDBus* testbus = NULL;
-
-protected:
-    std::shared_ptr<ubuntu::app_launch::Registry> registry;
-
-    virtual void SetUp() override
-    {
-        /* Click DB test mode */
-        g_setenv("TEST_CLICK_DB", "click-db-dir", TRUE);
-        g_setenv("TEST_CLICK_USER", "test-user", TRUE);
-
-        gchar* linkfarmpath = g_build_filename(CMAKE_SOURCE_DIR, "link-farm", NULL);
-        g_setenv("UBUNTU_APP_LAUNCH_LINK_FARM", linkfarmpath, TRUE);
-        g_free(linkfarmpath);
-
-        g_setenv("XDG_DATA_DIRS", CMAKE_SOURCE_DIR, TRUE);
-        g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
-        g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
-
-        g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
-
-        testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
-        g_test_dbus_up(testbus);
-
-        registry = std::make_shared<ubuntu::app_launch::Registry>();
-    }
-
-    virtual void TearDown() override
-    {
-        registry.reset();
-
-        g_test_dbus_down(testbus);
-        g_clear_object(&testbus);
-    }
-};
-
-TEST_F(FailureTest, CrashTest)
-{
-    g_setenv("EXIT_STATUS", "-100", TRUE);
-    g_setenv("JOB", "application-click", TRUE);
-    g_setenv("INSTANCE", "foo", TRUE);
-
-    std::string last_observer;
-    ubuntu::app_launch::Registry::appFailed(registry).connect(
-        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
-                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
-                         ubuntu::app_launch::Registry::FailureType type) {
-            if (type == ubuntu::app_launch::Registry::FailureType::CRASH)
-            {
-                last_observer = app->appId();
-            }
-        });
-
-    /* Status based */
-    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-    EXPECT_EVENTUALLY_EQ("foo", last_observer);
-
-    last_observer.clear();
-    g_unsetenv("EXIT_STATUS");
-    g_setenv("EXIT_SIGNAL", "KILL", TRUE);
-
-    /* Signal based */
-    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-    EXPECT_EVENTUALLY_EQ("foo", last_observer);
-}
-
-TEST_F(FailureTest, LegacyTest)
-{
-    g_setenv("EXIT_STATUS", "-100", TRUE);
-    g_setenv("JOB", "application-legacy", TRUE);
-    g_setenv("INSTANCE", "foo-1234", TRUE);
-
-    std::string last_observer;
-    ubuntu::app_launch::Registry::appFailed(registry).connect(
-        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
-                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
-                         ubuntu::app_launch::Registry::FailureType type) {
-            g_debug("Signal handler called");
-            if (type == ubuntu::app_launch::Registry::FailureType::CRASH)
-            {
-                last_observer = app->appId();
-            }
-        });
-
-    /* Status based */
-    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-    EXPECT_EVENTUALLY_EQ("foo", last_observer);
-}
-
-TEST_F(FailureTest, SnapTest)
-{
-    g_setenv("EXIT_STATUS", "-100", TRUE);
-    g_setenv("JOB", "application-snap", TRUE);
-    g_setenv("INSTANCE", "com.test.good_application_1.2.3-1234", TRUE);
-
-    std::string last_observer;
-    ubuntu::app_launch::Registry::appFailed(registry).connect(
-        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
-                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
-                         ubuntu::app_launch::Registry::FailureType type) {
-            if (type == ubuntu::app_launch::Registry::FailureType::CRASH)
-            {
-                last_observer = app->appId();
-            }
-        });
-
-    /* Status based */
-    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", last_observer);
-}
-
-TEST_F(FailureTest, StartTest)
-{
-    g_setenv("JOB", "application-click", TRUE);
-    g_setenv("INSTANCE", "foo", TRUE);
-    g_unsetenv("EXIT_STATUS");
-    g_unsetenv("EXIT_SIGNAL");
-
-    std::string last_observer;
-    ubuntu::app_launch::Registry::appFailed(registry).connect(
-        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
-                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
-                         ubuntu::app_launch::Registry::FailureType type) {
-            if (type == ubuntu::app_launch::Registry::FailureType::START_FAILURE)
-            {
-                last_observer = app->appId();
-            }
-        });
-
-    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-    EXPECT_EVENTUALLY_EQ("foo", last_observer);
-}

=== modified file 'tests/helper-test.cc'
--- tests/helper-test.cc	2017-01-11 23:22:52 +0000
+++ tests/helper-test.cc	2017-03-21 03:20:55 +0000
@@ -264,111 +264,6 @@
 	return;
 }
 
-TEST_F(HelperTest, SetConfinedEnvvars)
-{
-	g_unsetenv("XDG_DATA_DIRS");
-
-	DbusTestService * service = dbus_test_service_new(NULL);
-	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("com.ubuntu.Upstart");
-
-	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", NULL);
-
-	dbus_test_dbus_mock_object_add_method(mock, obj,
-		"SetEnvList",
-		G_VARIANT_TYPE("(asasb)"),
-		NULL,
-		"",
-		NULL);
-
-	dbus_test_service_add_task(service, DBUS_TEST_TASK(mock));
-	dbus_test_service_start_tasks(service);
-
-	GDBusConnection * bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-	g_dbus_connection_set_exit_on_close(bus, FALSE);
-	g_object_add_weak_pointer(G_OBJECT(bus), (gpointer *)&bus);
-
-	/* Not a test other than "don't crash" */
-	EnvHandle * handle = env_handle_start();
-	set_confined_envvars(handle, "foo-app-pkg", "/foo/bar");
-	env_handle_finish(handle);
-
-	guint len = 0;
-	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "SetEnvList", &len, NULL);
-
-	ASSERT_EQ(guint(1), len);
-	ASSERT_NE(calls, nullptr);
-	ASSERT_STREQ("SetEnvList", calls[0].name);
-
-	bool got_app_isolation = false;
-	bool got_cache_home = false;
-	bool got_config_home = false;
-	bool got_data_home = false;
-	bool got_runtime_dir = false;
-	bool got_data_dirs = false;
-	bool got_temp_dir = false;
-	bool got_shader_dir = false;
-
-	GVariant * envarray = g_variant_get_child_value(calls[0].params, 1);
-	GVariantIter iter;
-	g_variant_iter_init(&iter, envarray);
-	gchar * envvar = NULL;
-
-	while (g_variant_iter_loop(&iter, "s", &envvar)) {
-		gchar * var = g_strdup(envvar);
-
-		gchar * equal = g_strstr_len(var, -1, "=");
-		ASSERT_NE(equal, nullptr);
-
-		equal[0] = '\0';
-		gchar * value = &(equal[1]);
-
-		if (g_strcmp0(var, "UBUNTU_APPLICATION_ISOLATION") == 0) {
-			ASSERT_STREQ(value, "1");
-			got_app_isolation = true;
-		} else if (g_strcmp0(var, "XDG_CACHE_HOME") == 0) {
-			got_cache_home = true;
-		} else if (g_strcmp0(var, "XDG_CONFIG_HOME") == 0) {
-			got_config_home = true;
-		} else if (g_strcmp0(var, "XDG_DATA_HOME") == 0) {
-			got_data_home = true;
-		} else if (g_strcmp0(var, "XDG_RUNTIME_DIR") == 0) {
-			got_runtime_dir = true;
-		} else if (g_strcmp0(var, "XDG_DATA_DIRS") == 0) {
-			ASSERT_TRUE(g_str_has_prefix(value, "/foo/bar:"));
-			ASSERT_TRUE(g_strstr_len(value, -1, "/usr/share") != NULL);
-			got_data_dirs = true;
-		} else if (g_strcmp0(var, "TMPDIR") == 0) {
-			ASSERT_TRUE(g_str_has_suffix(value, "foo-app-pkg"));
-			got_temp_dir = true;
-		} else if (g_strcmp0(var, "__GL_SHADER_DISK_CACHE_PATH") == 0) {
-			ASSERT_TRUE(g_str_has_suffix(value, "foo-app-pkg"));
-			got_shader_dir = true;
-		} else {
-			g_warning("Unknown variable! %s", var);
-			ASSERT_TRUE(false);
-		}
-
-		g_free(var);
-	}
-
-	g_variant_unref(envarray);
-
-	ASSERT_TRUE(got_app_isolation);
-	ASSERT_TRUE(got_cache_home);
-	ASSERT_TRUE(got_config_home);
-	ASSERT_TRUE(got_data_home);
-	ASSERT_TRUE(got_runtime_dir);
-	ASSERT_TRUE(got_data_dirs);
-	ASSERT_TRUE(got_temp_dir);
-	ASSERT_TRUE(got_shader_dir);
-
-	g_object_unref(bus);
-	g_object_unref(mock);
-	g_object_unref(service);
-
-	return;
-}
-
 TEST_F(HelperTest, DesktopToExec)
 {
 	GKeyFile * keyfile = NULL;

=== modified file 'tests/libual-cpp-test.cc'
--- tests/libual-cpp-test.cc	2017-03-09 16:05:36 +0000
+++ tests/libual-cpp-test.cc	2017-03-21 03:20:55 +0000
@@ -32,6 +32,7 @@
 #include "application.h"
 #include "glib-thread.h"
 #include "helper.h"
+#include "jobs-base.h"
 #include "registry.h"
 #include "ubuntu-app-launch.h"
 
@@ -39,6 +40,8 @@
 #include "libertine-service.h"
 #include "mir-mock.h"
 #include "spew-master.h"
+#include "systemd-mock.h"
+#include "zg-mock.h"
 
 #ifdef ENABLE_SNAPPY
 #include "snapd-mock.h"
@@ -46,6 +49,8 @@
 #define LOCAL_SNAPD_TEST_SOCKET (SNAPD_TEST_SOCKET "-libual-cpp-test")
 #endif
 
+#define CGROUP_DIR (CMAKE_BINARY_DIR "/systemd-cgroups")
+
 class LibUAL : public EventuallyFixture
 {
 protected:
@@ -53,6 +58,7 @@
     DbusTestDbusMock* mock = NULL;
     DbusTestDbusMock* cgmock = NULL;
     std::shared_ptr<LibertineService> libertine;
+    std::shared_ptr<SystemdMock> systemd;
     GDBusConnection* bus = NULL;
     guint resume_timeout = 0;
     std::shared_ptr<ubuntu::app_launch::Registry> registry;
@@ -160,156 +166,25 @@
         g_unlink(LOCAL_SNAPD_TEST_SOCKET);
 #endif
         g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
+        /* Setting the cgroup temp directory */
+        g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_CGROUP_ROOT", CGROUP_DIR, TRUE);
 
         service = dbus_test_service_new(NULL);
 
         debugConnection();
 
-        mock = dbus_test_dbus_mock_new("com.ubuntu.Upstart");
-
-        DbusTestDbusMockObject* obj =
-            dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, obj, "EmitEvent", G_VARIANT_TYPE("(sasb)"), NULL, "", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, obj, "GetJobByName", G_VARIANT_TYPE("s"), G_VARIANT_TYPE("o"),
-                                              "if args[0] == 'application-click':\n"
-                                              "    ret = dbus.ObjectPath('/com/test/application_click')\n"
-                                              "elif args[0] == 'application-snap':\n"
-                                              "    ret = dbus.ObjectPath('/com/test/application_snap')\n"
-                                              "elif args[0] == 'application-legacy':\n"
-                                              "    ret = dbus.ObjectPath('/com/test/application_legacy')\n"
-                                              "elif args[0] == 'untrusted-helper':\n"
-                                              "    ret = dbus.ObjectPath('/com/test/untrusted/helper')\n",
-                                              NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, obj, "SetEnv", G_VARIANT_TYPE("(assb)"), NULL, "", NULL);
-
-        /* Click App */
-        DbusTestDbusMockObject* jobobj =
-            dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
-
-        dbus_test_dbus_mock_object_add_method(
-            mock, jobobj, "Start", G_VARIANT_TYPE("(asb)"), NULL,
-            "if 'APP_ID=com.test.good_application_1.2.3' in args[0]:"
-            "    raise dbus.exceptions.DBusException('Foo running', name='com.ubuntu.Upstart0_6.Error.AlreadyStarted')",
-            NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, jobobj, "Stop", G_VARIANT_TYPE("(asb)"), NULL, "", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, jobobj, "GetAllInstances", NULL, G_VARIANT_TYPE("ao"),
-                                              "ret = [ dbus.ObjectPath('/com/test/app_instance') ]", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, jobobj, "GetInstanceByName", G_VARIANT_TYPE_STRING,
-                                              G_VARIANT_TYPE("o"), "ret = dbus.ObjectPath('/com/test/app_instance')",
-                                              NULL);
-
-        DbusTestDbusMockObject* instobj =
-            dbus_test_dbus_mock_get_object(mock, "/com/test/app_instance", "com.ubuntu.Upstart0_6.Instance", NULL);
-        dbus_test_dbus_mock_object_add_property(mock, instobj, "name", G_VARIANT_TYPE_STRING,
-                                                g_variant_new_string("com.test.good_application_1.2.3"), NULL);
-        gchar* process_var = g_strdup_printf("[('main', %d)]", getpid());
-        dbus_test_dbus_mock_object_add_property(mock, instobj, "processes", G_VARIANT_TYPE("a(si)"),
-                                                g_variant_new_parsed(process_var), NULL);
-        g_free(process_var);
-
-#ifdef ENABLE_SNAPPY
-        /* Snap App */
-        auto snapjobobj =
-            dbus_test_dbus_mock_get_object(mock, "/com/test/application_snap", "com.ubuntu.Upstart0_6.Job", NULL);
-
-        dbus_test_dbus_mock_object_add_method(
-            mock, snapjobobj, "Start", G_VARIANT_TYPE("(asb)"), NULL,
-            "if args[0][0] == 'APP_ID=unity8-package_foo_x123':"
-            "    raise dbus.exceptions.DBusException('Foo running', name='com.ubuntu.Upstart0_6.Error.AlreadyStarted')",
-            NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, snapjobobj, "Stop", G_VARIANT_TYPE("(asb)"), NULL, "", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, snapjobobj, "GetAllInstances", NULL, G_VARIANT_TYPE("ao"),
-                                              "ret = [ dbus.ObjectPath('/com/test/snapp_instance') ]", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, snapjobobj, "GetInstanceByName", G_VARIANT_TYPE_STRING,
-                                              G_VARIANT_TYPE("o"), "ret = dbus.ObjectPath('/com/test/snapp_instance')",
-                                              NULL);
-
-        auto snapinstobj =
-            dbus_test_dbus_mock_get_object(mock, "/com/test/snapp_instance", "com.ubuntu.Upstart0_6.Instance", NULL);
-        dbus_test_dbus_mock_object_add_property(mock, snapinstobj, "name", G_VARIANT_TYPE_STRING,
-                                                g_variant_new_string("unity8-package_foo_x123-"), NULL);
-        gchar* snapprocess_var = g_strdup_printf("[('main', %d)]", getpid());
-        dbus_test_dbus_mock_object_add_property(mock, snapinstobj, "processes", G_VARIANT_TYPE("a(si)"),
-                                                g_variant_new_parsed(snapprocess_var), NULL);
-        g_free(snapprocess_var);
-#endif
-
-        /*  Legacy App */
-        DbusTestDbusMockObject* ljobobj =
-            dbus_test_dbus_mock_get_object(mock, "/com/test/application_legacy", "com.ubuntu.Upstart0_6.Job", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, ljobobj, "Start", G_VARIANT_TYPE("(asb)"), NULL, "", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, ljobobj, "Stop", G_VARIANT_TYPE("(asb)"), NULL, "", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, ljobobj, "GetAllInstances", NULL, G_VARIANT_TYPE("ao"),
-                                              "ret = [ dbus.ObjectPath('/com/test/legacy_app_instance'), "
-                                              "dbus.ObjectPath('/com/test/legacy_app_instance2') ]",
-                                              NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, ljobobj, "GetInstanceByName", G_VARIANT_TYPE_STRING,
-                                              G_VARIANT_TYPE("o"),
-                                              "ret = dbus.ObjectPath('/com/test/legacy_app_instance')", NULL);
-
-        DbusTestDbusMockObject* linstobj = dbus_test_dbus_mock_get_object(mock, "/com/test/legacy_app_instance",
-                                                                          "com.ubuntu.Upstart0_6.Instance", NULL);
-        dbus_test_dbus_mock_object_add_property(mock, linstobj, "name", G_VARIANT_TYPE_STRING,
-                                                g_variant_new_string("multiple-2342345"), NULL);
-        dbus_test_dbus_mock_object_add_property(mock, linstobj, "processes", G_VARIANT_TYPE("a(si)"),
-                                                g_variant_new_parsed("[('main', 5678)]"), NULL);
-
-        DbusTestDbusMockObject* linstobj2 = dbus_test_dbus_mock_get_object(mock, "/com/test/legacy_app_instance2",
-                                                                           "com.ubuntu.Upstart0_6.Instance", NULL);
-        dbus_test_dbus_mock_object_add_property(mock, linstobj2, "name", G_VARIANT_TYPE_STRING,
-                                                g_variant_new_string("single-"), NULL);
-        dbus_test_dbus_mock_object_add_property(mock, linstobj2, "processes", G_VARIANT_TYPE("a(si)"),
-                                                g_variant_new_parsed("[('main', 5678)]"), NULL);
-
-        /*  Untrusted Helper */
-        DbusTestDbusMockObject* uhelperobj =
-            dbus_test_dbus_mock_get_object(mock, "/com/test/untrusted/helper", "com.ubuntu.Upstart0_6.Job", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, uhelperobj, "Start", G_VARIANT_TYPE("(asb)"), NULL, "", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, uhelperobj, "Stop", G_VARIANT_TYPE("(asb)"), NULL, "", NULL);
-
-        dbus_test_dbus_mock_object_add_method(mock, uhelperobj, "GetAllInstances", NULL, G_VARIANT_TYPE("ao"),
-                                              "ret = [ dbus.ObjectPath('/com/test/untrusted/helper/instance'), "
-                                              "dbus.ObjectPath('/com/test/untrusted/helper/multi_instance') ]",
-                                              NULL);
-
-        DbusTestDbusMockObject* uhelperinstance = dbus_test_dbus_mock_get_object(
-            mock, "/com/test/untrusted/helper/instance", "com.ubuntu.Upstart0_6.Instance", NULL);
-        dbus_test_dbus_mock_object_add_property(mock, uhelperinstance, "name", G_VARIANT_TYPE_STRING,
-                                                g_variant_new_string("untrusted-type::com.foo_bar_43.23.12"), NULL);
-
-        DbusTestDbusMockObject* unhelpermulti = dbus_test_dbus_mock_get_object(
-            mock, "/com/test/untrusted/helper/multi_instance", "com.ubuntu.Upstart0_6.Instance", NULL);
-        dbus_test_dbus_mock_object_add_property(
-            mock, unhelpermulti, "name", G_VARIANT_TYPE_STRING,
-            g_variant_new_string("untrusted-type:24034582324132:com.bar_foo_8432.13.1"), NULL);
-
-        /* Create the cgroup manager mock */
-        cgmock = dbus_test_dbus_mock_new("org.test.cgmock");
-        g_setenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME", "org.test.cgmock", TRUE);
-
-        DbusTestDbusMockObject* cgobject = dbus_test_dbus_mock_get_object(cgmock, "/org/linuxcontainers/cgmanager",
-                                                                          "org.linuxcontainers.cgmanager0_0", NULL);
-        dbus_test_dbus_mock_object_add_method(cgmock, cgobject, "GetTasksRecursive", G_VARIANT_TYPE("(ss)"),
-                                              G_VARIANT_TYPE("ai"), "ret = [100, 200, 300]", NULL);
+        systemd = std::make_shared<SystemdMock>(
+            std::list<SystemdMock::Instance>{
+                {"application-click", "com.test.good_application_1.2.3", {}, getpid(), {100, 200, 300}},
+                {"application-snap", "unity8-package_foo_x123", {}, getpid(), {100, 200, 300}},
+                {"application-legacy", "multiple", "2342345", 5678, {100, 200, 300}},
+                {"application-legacy", "single", {}, 5678, {100, 200, 300}},
+                {"helper", "com.foo_bar_43.23.12", {}, 1, {100, 200, 300}},
+                {"helper", "com.bar_foo_8432.13.1", "24034582324132", 1, {100, 200, 300}}},
+            CGROUP_DIR);
 
         /* Put it together */
-        dbus_test_service_add_task(service, DBUS_TEST_TASK(mock));
-        dbus_test_service_add_task(service, DBUS_TEST_TASK(cgmock));
+        dbus_test_service_add_task(service, *systemd);
 
         /* Add in Libertine */
         libertine = std::make_shared<LibertineService>();
@@ -343,9 +218,8 @@
         //
         // ubuntu::app_launch::Registry::clearDefault();
 
+        systemd.reset();
         libertine.reset();
-        g_clear_object(&mock);
-        g_clear_object(&cgmock);
         g_clear_object(&service);
 
         g_object_unref(bus);
@@ -357,63 +231,40 @@
 #endif
     }
 
-    GVariant* find_env(GVariant* env_array, const gchar* var)
-    {
-        unsigned int i;
-        GVariant* retval = nullptr;
-
-        for (i = 0; i < g_variant_n_children(env_array); i++)
-        {
-            GVariant* child = g_variant_get_child_value(env_array, i);
-            const gchar* envvar = g_variant_get_string(child, nullptr);
-
-            if (g_str_has_prefix(envvar, var))
-            {
-                if (retval != nullptr)
-                {
-                    g_warning("Found the env var more than once!");
-                    g_variant_unref(retval);
-                    return nullptr;
-                }
-
-                retval = child;
-            }
-            else
-            {
-                g_variant_unref(child);
-            }
-        }
-
-        if (!retval)
-        {
-            gchar* envstr = g_variant_print(env_array, FALSE);
-            g_warning("Unable to find '%s' in '%s'", var, envstr);
-            g_free(envstr);
-        }
-
-        return retval;
-    }
-
-    bool check_env(GVariant* env_array, const gchar* var, const gchar* value)
-    {
-        bool found = false;
-        GVariant* val = find_env(env_array, var);
-        if (val == nullptr)
+    static std::string find_env(std::set<std::string>& envs, std::string var)
+    {
+        auto iter =
+            std::find_if(envs.begin(), envs.end(), [var](std::string value) { return split_env(value).first == var; });
+
+        if (iter == envs.end())
+        {
+            return {};
+        }
+        else
+        {
+            return *iter;
+        }
+    }
+
+    static std::pair<std::string, std::string> split_env(const std::string& env)
+    {
+        auto eq = std::find(env.begin(), env.end(), '=');
+        if (eq == env.end())
+        {
+            throw std::runtime_error{"Environment value is invalid: " + env};
+        }
+
+        return std::make_pair(std::string(env.begin(), eq), std::string(eq + 1, env.end()));
+    }
+
+    static bool check_env(std::set<std::string>& envs, const std::string& key, const std::string& value)
+    {
+        auto val = find_env(envs, key);
+        if (val.empty())
         {
             return false;
         }
-
-        const gchar* envvar = g_variant_get_string(val, nullptr);
-
-        gchar* combined = g_strdup_printf("%s=%s", var, value);
-        if (g_strcmp0(envvar, combined) == 0)
-        {
-            found = true;
-        }
-
-        g_variant_unref(val);
-
-        return found;
+        return split_env(val).second == value;
     }
 };
 
@@ -423,107 +274,6 @@
         [&task] { return dbus_test_task_get_state(DBUS_TEST_TASK(task)); } \
     }
 
-TEST_F(LibUAL, StartClickApplication)
-{
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
-
-    /* Basic make sure we can send the event */
-    auto appid = ubuntu::app_launch::AppID::parse("com.test.multiple_first_1.2.3");
-    auto app = ubuntu::app_launch::Application::create(appid, registry);
-    app->launch();
-
-    EXPECT_EQ(1, dbus_test_dbus_mock_object_check_method_call(mock, obj, "Start", NULL, NULL));
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
-
-    /* Now look at the details of the call */
-    app->launch();
-
-    guint len = 0;
-    const DbusTestDbusMockCall* calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    EXPECT_STREQ("Start", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    GVariant* block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
-
-    GVariant* env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "com.test.multiple_first_1.2.3"));
-    g_variant_unref(env);
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
-
-    /* Let's pass some URLs */
-    std::vector<ubuntu::app_launch::Application::URL> urls{
-        ubuntu::app_launch::Application::URL::from_raw("http://ubuntu.com/"),
-        ubuntu::app_launch::Application::URL::from_raw("https://ubuntu.com/"),
-        ubuntu::app_launch::Application::URL::from_raw("file:///home/phablet/test.txt")};
-
-    app->launch(urls);
-
-    len = 0;
-    calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "com.test.multiple_first_1.2.3"));
-    EXPECT_TRUE(
-        check_env(env, "APP_URIS", "'http://ubuntu.com/' 'https://ubuntu.com/' 'file:///home/phablet/test.txt'"));
-    g_variant_unref(env);
-
-    return;
-}
-
-TEST_F(LibUAL, StartClickApplicationTest)
-{
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
-
-    /* Basic make sure we can send the event */
-    auto appid = ubuntu::app_launch::AppID::parse("com.test.multiple_first_1.2.3");
-    auto app = ubuntu::app_launch::Application::create(appid, registry);
-    app->launchTest();
-
-    guint len = 0;
-    const DbusTestDbusMockCall* calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    EXPECT_STREQ("Start", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    GVariant* block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
-
-    GVariant* env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "com.test.multiple_first_1.2.3"));
-    EXPECT_TRUE(check_env(env, "QT_LOAD_TESTABILITY", "1"));
-    g_variant_unref(env);
-}
-
-TEST_F(LibUAL, StopClickApplication)
-{
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
-
-    auto appid = ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3");
-    auto app = ubuntu::app_launch::Application::create(appid, registry);
-
-    ASSERT_TRUE(app->hasInstances());
-    ASSERT_EQ(1, int(app->instances().size()));
-
-    app->instances()[0]->stop();
-
-    ASSERT_EQ(dbus_test_dbus_mock_object_check_method_call(mock, obj, "Stop", NULL, NULL), 1);
-}
-
 #ifdef ENABLE_SNAPPY
 /* Snapd mock data */
 static std::pair<std::string, std::string> interfaces{
@@ -617,113 +367,6 @@
         FAIL() << "Expected std::runtime_error";
     }
 }
-
-TEST_F(LibUAL, StartSnapApplication)
-{
-    SnapdMock snapd{LOCAL_SNAPD_TEST_SOCKET, {u8Package, interfaces, u8Package}};
-    registry = std::make_shared<ubuntu::app_launch::Registry>();
-
-    auto obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_snap", "com.ubuntu.Upstart0_6.Job", NULL);
-
-    /* Basic make sure we can send the event */
-    auto appid = ubuntu::app_launch::AppID::parse("unity8-package_single_x123");
-    auto app = ubuntu::app_launch::Application::create(appid, registry);
-    app->launch();
-
-    EXPECT_EQ(1, dbus_test_dbus_mock_object_check_method_call(mock, obj, "Start", NULL, NULL));
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
-
-    /* Now look at the details of the call */
-    app->launch();
-
-    guint len = 0;
-    const DbusTestDbusMockCall* calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    EXPECT_EQ(1u, len);
-
-    EXPECT_STREQ("Start", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    GVariant* block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
-
-    GVariant* env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "unity8-package_single_x123"));
-    g_variant_unref(env);
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
-
-    /* Let's pass some URLs */
-    std::vector<ubuntu::app_launch::Application::URL> urls{
-        ubuntu::app_launch::Application::URL::from_raw("http://ubuntu.com/"),
-        ubuntu::app_launch::Application::URL::from_raw("https://ubuntu.com/"),
-        ubuntu::app_launch::Application::URL::from_raw("file:///home/phablet/test.txt")};
-
-    app->launch(urls);
-
-    len = 0;
-    calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    EXPECT_EQ(1u, len);
-
-    env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "unity8-package_single_x123"));
-    EXPECT_TRUE(
-        check_env(env, "APP_URIS", "'http://ubuntu.com/' 'https://ubuntu.com/' 'file:///home/phablet/test.txt'"));
-    g_variant_unref(env);
-
-    return;
-}
-
-TEST_F(LibUAL, StartSnapApplicationTest)
-{
-    SnapdMock snapd{LOCAL_SNAPD_TEST_SOCKET, {u8Package, interfaces, u8Package}};
-    registry = std::make_shared<ubuntu::app_launch::Registry>();
-
-    auto obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_snap", "com.ubuntu.Upstart0_6.Job", NULL);
-
-    /* Basic make sure we can send the event */
-    auto appid = ubuntu::app_launch::AppID::parse("unity8-package_single_x123");
-    auto app = ubuntu::app_launch::Application::create(appid, registry);
-    app->launchTest();
-
-    guint len = 0;
-    auto calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    EXPECT_EQ(1u, len);
-
-    EXPECT_STREQ("Start", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    GVariant* block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
-
-    GVariant* env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "unity8-package_single_x123"));
-    EXPECT_TRUE(check_env(env, "QT_LOAD_TESTABILITY", "1"));
-    g_variant_unref(env);
-}
-
-TEST_F(LibUAL, StopSnapApplication)
-{
-    SnapdMock snapd{LOCAL_SNAPD_TEST_SOCKET, {u8Package, interfaces, u8Package}};
-    registry = std::make_shared<ubuntu::app_launch::Registry>();
-
-    auto obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_snap", "com.ubuntu.Upstart0_6.Job", NULL);
-
-    auto appid = ubuntu::app_launch::AppID::parse("unity8-package_foo_x123");
-    auto app = ubuntu::app_launch::Application::create(appid, registry);
-
-    ASSERT_TRUE(app->hasInstances());
-    EXPECT_EQ(1, int(app->instances().size()));
-
-    app->instances()[0]->stop();
-
-    ASSERT_EQ(dbus_test_dbus_mock_object_check_method_call(mock, obj, "Stop", NULL, NULL), 1);
-}
 #endif
 
 TEST_F(LibUAL, ApplicationPid)
@@ -892,107 +535,6 @@
 #endif
 }
 
-TEST_F(LibUAL, StartStopObserver)
-{
-    int start_count = 0;
-    int stop_count = 0;
-    ubuntu::app_launch::AppID start_appid;
-    ubuntu::app_launch::AppID stop_appid;
-
-    ubuntu::app_launch::Registry::appStarted(registry).connect(
-        [&start_count, &start_appid](std::shared_ptr<ubuntu::app_launch::Application> app,
-                                     std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
-            if (!start_appid.empty() && !(start_appid == app->appId()))
-                return;
-
-            start_count++;
-        });
-
-    ubuntu::app_launch::Registry::appStopped(registry).connect(
-        [&stop_count, &stop_appid](std::shared_ptr<ubuntu::app_launch::Application> app,
-                                   std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
-            if (!stop_appid.empty() && !(stop_appid == app->appId()))
-                return;
-
-            stop_count++;
-        });
-
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", NULL);
-
-    /* Basic start */
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('started', ['JOB=application-click', 'INSTANCE=com.test.good_application_1.2.3'])"),
-        NULL);
-
-    EXPECT_EVENTUALLY_EQ(1, start_count);
-
-    /* Basic stop */
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('stopped', ['JOB=application-click', 'INSTANCE=com.test.good_application_1.2.3'])"),
-        NULL);
-
-    EXPECT_EVENTUALLY_EQ(1, stop_count);
-
-    /* Start legacy */
-    start_count = 0;
-    start_appid = ubuntu::app_launch::AppID{ubuntu::app_launch::AppID::Package::from_raw({}),
-                                            ubuntu::app_launch::AppID::AppName::from_raw("multiple"),
-                                            ubuntu::app_launch::AppID::Version::from_raw({})};
-
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('started', ['JOB=application-legacy', 'INSTANCE=multiple-234235'])"), NULL);
-
-    EXPECT_EVENTUALLY_EQ(1, start_count);
-
-    /* Legacy stop */
-    stop_count = 0;
-    stop_appid = ubuntu::app_launch::AppID{ubuntu::app_launch::AppID::Package::from_raw({}),
-                                           ubuntu::app_launch::AppID::AppName::from_raw("foo"),
-                                           ubuntu::app_launch::AppID::Version::from_raw({})};
-
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('stopped', ['JOB=application-legacy', 'INSTANCE=foo-9344321'])"), NULL);
-
-    EXPECT_EVENTUALLY_EQ(1, stop_count);
-
-    /* Test Noise Start */
-    start_count = 0;
-    start_appid = ubuntu::app_launch::AppID{ubuntu::app_launch::AppID::Package::from_raw("com.test.good"),
-                                            ubuntu::app_launch::AppID::AppName::from_raw("application"),
-                                            ubuntu::app_launch::AppID::Version::from_raw("1.2.3")};
-    stop_count = 0;
-    stop_appid = ubuntu::app_launch::AppID{ubuntu::app_launch::AppID::Package::from_raw("com.test.good"),
-                                           ubuntu::app_launch::AppID::AppName::from_raw("application"),
-                                           ubuntu::app_launch::AppID::Version::from_raw("1.2.3")};
-
-    /* A full lifecycle */
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('starting', ['JOB=application-click', 'INSTANCE=com.test.good_application_1.2.3'])"),
-        NULL);
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('started', ['JOB=application-click', 'INSTANCE=com.test.good_application_1.2.3'])"),
-        NULL);
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('stopping', ['JOB=application-click', 'INSTANCE=com.test.good_application_1.2.3'])"),
-        NULL);
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('stopped', ['JOB=application-click', 'INSTANCE=com.test.good_application_1.2.3'])"),
-        NULL);
-
-    /* Ensure we just signaled once for each */
-    EXPECT_EVENTUALLY_EQ(1, start_count);
-    EXPECT_EVENTUALLY_EQ(1, stop_count);
-}
-
 TEST_F(LibUAL, StartingResponses)
 {
     /* Get Bus */
@@ -1195,186 +737,100 @@
 
 TEST_F(LibUAL, LegacySingleInstance)
 {
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/test/application_legacy", "com.ubuntu.Upstart0_6.Job", NULL);
-
     /* Check for a single-instance app */
     auto singleappid = ubuntu::app_launch::AppID::find(registry, "single");
     auto singleapp = ubuntu::app_launch::Application::create(singleappid, registry);
 
     singleapp->launch();
 
-    guint len = 0;
-    const DbusTestDbusMockCall* calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    EXPECT_STREQ("Start", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    GVariant* block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
-
-    GVariant* env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "single"));
-    EXPECT_TRUE(check_env(env, "INSTANCE_ID", ""));
-    g_variant_unref(env);
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+    auto singleStart = systemd->unitCalls();
+    ASSERT_EQ(1u, singleStart.size());
+    EXPECT_EQ(SystemdMock::instanceName({"application-legacy", "single", "", 0, {}}), singleStart.begin()->name);
+
+    systemd->managerClear();
 
     /* Check for a multi-instance app */
     auto multipleappid = ubuntu::app_launch::AppID::find(registry, "multiple");
     auto multipleapp = ubuntu::app_launch::Application::create(multipleappid, registry);
 
-    multipleapp->launch();
-
-    len = 0;
-    calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    EXPECT_STREQ("Start", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
-
-    env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "multiple"));
-    EXPECT_FALSE(check_env(env, "INSTANCE_ID", ""));
-    g_variant_unref(env);
-}
-
-TEST_F(LibUAL, FailingObserver)
-{
-    ubuntu::app_launch::AppID lastFailedApp;
-    ubuntu::app_launch::Registry::FailureType lastFailedType;
-
-    ubuntu::app_launch::Registry::appFailed(registry).connect(
-        [&lastFailedApp, &lastFailedType](std::shared_ptr<ubuntu::app_launch::Application> app,
-                                          std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
-                                          ubuntu::app_launch::Registry::FailureType type) {
-            lastFailedApp = app->appId();
-            lastFailedType = type;
-        });
-
-    GDBusConnection* session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-
-    g_dbus_connection_emit_signal(
-        session, NULL,                                                                      /* destination */
-        "/",                                                                                /* path */
-        "com.canonical.UbuntuAppLaunch",                                                    /* interface */
-        "ApplicationFailed",                                                                /* signal */
-        g_variant_new("(sss)", "com.test.good_application_1.2.3", "goodinstance", "crash"), /* params, the same */
-        NULL);
-
-    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"), lastFailedApp);
-    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::Registry::FailureType::CRASH, lastFailedType);
-
-    lastFailedApp = ubuntu::app_launch::AppID();
-
-    g_dbus_connection_emit_signal(
-        session, NULL,                                                                         /* destination */
-        "/",                                                                                   /* path */
-        "com.canonical.UbuntuAppLaunch",                                                       /* interface */
-        "ApplicationFailed",                                                                   /* signal */
-        g_variant_new("(sss)", "com.test.good_application_1.2.3", "goodinstance", "blahblah"), /* params, the same */
-        NULL);
-
-    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"), lastFailedApp);
-
-    lastFailedApp = ubuntu::app_launch::AppID();
-
-    g_dbus_connection_emit_signal(session, NULL,                   /* destination */
-                                  "/",                             /* path */
-                                  "com.canonical.UbuntuAppLaunch", /* interface */
-                                  "ApplicationFailed",             /* signal */
-                                  g_variant_new("(sss)", "com.test.good_application_1.2.3", "goodinstance",
-                                                "start-failure"), /* params, the same */
-                                  NULL);
-
-    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::Registry::FailureType::START_FAILURE, lastFailedType);
-
-    g_object_unref(session);
+    auto inst = multipleapp->launch();
+
+    auto multiStart = systemd->unitCalls();
+    ASSERT_EQ(1u, multiStart.size());
+    EXPECT_EQ(SystemdMock::instanceName(
+                  {"application-legacy",
+                   "multiple",
+                   std::dynamic_pointer_cast<ubuntu::app_launch::jobs::instance::Base>(inst)->getInstanceId(),
+                   0,
+                   {}}),
+              multiStart.begin()->name);
 }
 
 TEST_F(LibUAL, StartHelper)
 {
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/test/untrusted/helper", "com.ubuntu.Upstart0_6.Job", NULL);
-
     auto untrusted = ubuntu::app_launch::Helper::Type::from_raw("untrusted-type");
 
     /* Basic make sure we can send the event */
     auto appid = ubuntu::app_launch::AppID::parse("com.test.multiple_first_1.2.3");
     auto helper = ubuntu::app_launch::Helper::create(untrusted, appid, registry);
 
-    helper->launch();
-
-    EXPECT_EQ(1, dbus_test_dbus_mock_object_check_method_call(mock, obj, "Start", NULL, NULL));
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+    auto inst = helper->launch();
+
+    auto helperStart = systemd->unitCalls();
+
+    ASSERT_EQ(1u, helperStart.size());
+    EXPECT_EQ(SystemdMock::instanceName(
+                  {"untrusted-type",
+                   "com.test.multiple_first_1.2.3",
+                   std::dynamic_pointer_cast<ubuntu::app_launch::jobs::instance::Base>(inst)->getInstanceId(),
+                   0,
+                   {}}),
+              helperStart.begin()->name);
+
+    systemd->managerClear();
 
     /* Now check a multi out */
-    helper->launch();
-
-    guint len = 0;
-    auto calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    EXPECT_STREQ("Start", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    auto block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
-
-    auto env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "com.test.multiple_first_1.2.3"));
-    EXPECT_TRUE(check_env(env, "HELPER_TYPE", "untrusted-type"));
-    g_variant_unref(env);
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+    auto inst2 = helper->launch();
+
+    auto helperStart2 = systemd->unitCalls();
+
+    ASSERT_EQ(1u, helperStart2.size());
+    EXPECT_EQ(SystemdMock::instanceName(
+                  {"untrusted-type",
+                   "com.test.multiple_first_1.2.3",
+                   std::dynamic_pointer_cast<ubuntu::app_launch::jobs::instance::Base>(inst2)->getInstanceId(),
+                   0,
+                   {}}),
+              helperStart2.begin()->name);
+
+    systemd->managerClear();
 
     /* Let's pass some URLs */
     std::vector<ubuntu::app_launch::Helper::URL> urls = {
         ubuntu::app_launch::Helper::URL::from_raw("http://ubuntu.com/"),
         ubuntu::app_launch::Helper::URL::from_raw("https://ubuntu.com/"),
         ubuntu::app_launch::Helper::URL::from_raw("file:///home/phablet/test.txt")};
-    helper->launch(urls);
-
-    len = 0;
-    calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "com.test.multiple_first_1.2.3"));
-    EXPECT_TRUE(
-        check_env(env, "APP_URIS", "'http://ubuntu.com/' 'https://ubuntu.com/' 'file:///home/phablet/test.txt'"));
-    EXPECT_TRUE(check_env(env, "HELPER_TYPE", "untrusted-type"));
-    EXPECT_FALSE(check_env(env, "INSTANCE_ID", NULL));
-    g_variant_unref(env);
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
-
-    /* Needed as we still haven't ported second-exec.c to use the registry
-       thread and inherit its cancellable, we need to ensure all the extra
-       DBus messages error out before ending the test, or otherwise they'll
-       keep a reference to the DBus bus object. */
-    pause(100);
+
+    auto inst3 = helper->launch(urls);
+
+    auto helperStart3 = systemd->unitCalls();
+
+    ASSERT_EQ(1u, helperStart3.size());
+    EXPECT_EQ(SystemdMock::instanceName(
+                  {"untrusted-type",
+                   "com.test.multiple_first_1.2.3",
+                   std::dynamic_pointer_cast<ubuntu::app_launch::jobs::instance::Base>(inst3)->getInstanceId(),
+                   0,
+                   {}}),
+              helperStart3.begin()->name);
+
+    /* TODO: Check URLS in exec */
 
     return;
 }
 
 TEST_F(LibUAL, StopHelper)
 {
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/test/untrusted/helper", "com.ubuntu.Upstart0_6.Job", NULL);
-
     /* Multi helper */
     auto untrusted = ubuntu::app_launch::Helper::Type::from_raw("untrusted-type");
 
@@ -1389,33 +845,12 @@
 
     instances[0]->stop();
 
-    ASSERT_EQ(dbus_test_dbus_mock_object_check_method_call(mock, obj, "Stop", NULL, NULL), 1);
-
-    guint len = 0;
-    auto calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Stop", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    EXPECT_STREQ("Stop", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    auto block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
-
-    auto env = g_variant_get_child_value(calls->params, 0);
-    EXPECT_TRUE(check_env(env, "APP_ID", "com.bar_foo_8432.13.1"));
-    EXPECT_TRUE(check_env(env, "HELPER_TYPE", "untrusted-type"));
-    EXPECT_TRUE(check_env(env, "INSTANCE_ID", "24034582324132"));
-    g_variant_unref(env);
-
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
-
-    /* Needed as we still haven't ported second-exec.c to use the registry
-       thread and inherit its cancellable, we need to ensure all the extra
-       DBus messages error out before ending the test, or otherwise they'll
-       keep a reference to the DBus bus object. */
-    pause(100);
+    auto calls = systemd->stopCalls();
+
+    ASSERT_EQ(1u, calls.size());
+
+    EXPECT_EQ(SystemdMock::instanceName({"untrusted-type", "com.bar_foo_8432.13.1", "24034582324132", 0, {}}),
+              *calls.begin());
 
     return;
 }
@@ -1482,23 +917,13 @@
     ASSERT_TRUE(ubuntu_app_launch_observer_add_helper_started(helper_observer_cb, "my-type-is-scorpio", &start_data));
     ASSERT_TRUE(ubuntu_app_launch_observer_add_helper_stop(helper_observer_cb, "my-type-is-libra", &stop_data));
 
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", NULL);
-
     /* Basic start */
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('started', ['JOB=untrusted-helper', 'INSTANCE=my-type-is-scorpio::com.foo_foo_1.2.3'])"),
-        NULL);
+    systemd->managerEmitNew(SystemdMock::instanceName({"my-type-is-scorpio", "com.foo_foo_1.2.3", "", 0, {}}), "/");
 
     EXPECT_EVENTUALLY_EQ(1, start_data.count);
 
     /* Basic stop */
-    dbus_test_dbus_mock_object_emit_signal(
-        mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed(
-            "('stopped', ['JOB=untrusted-helper', 'INSTANCE=my-type-is-libra:1234:com.bar_bar_44.32'])"),
-        NULL);
+    systemd->managerEmitRemoved(SystemdMock::instanceName({"my-type-is-scorpio", "com.foo_foo_1.2.3", "", 0, {}}), "/");
 
     EXPECT_EVENTUALLY_EQ(1, stop_data.count);
 
@@ -1516,35 +941,20 @@
     /* Setup some spew */
     SpewMaster spew;
 
-    /* Setup the cgroup */
-    g_setenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME", "org.test.cgmock2", TRUE);
-    DbusTestDbusMock* cgmock2 = dbus_test_dbus_mock_new("org.test.cgmock2");
-    DbusTestDbusMockObject* cgobject = dbus_test_dbus_mock_get_object(cgmock2, "/org/linuxcontainers/cgmanager",
-                                                                      "org.linuxcontainers.cgmanager0_0", NULL);
-    gchar* pypids = g_strdup_printf("ret = [%d]", spew.pid());
-    dbus_test_dbus_mock_object_add_method(cgmock, cgobject, "GetTasksRecursive", G_VARIANT_TYPE("(ss)"),
-                                          G_VARIANT_TYPE("ai"), pypids, NULL);
-    g_free(pypids);
-
-    dbus_test_service_add_task(service, DBUS_TEST_TASK(cgmock2));
-    dbus_test_task_run(DBUS_TEST_TASK(cgmock2));
-    g_object_unref(G_OBJECT(cgmock2));
-
     /* Setup ZG Mock */
-    DbusTestDbusMock* zgmock = dbus_test_dbus_mock_new("org.gnome.zeitgeist.Engine");
-    DbusTestDbusMockObject* zgobj =
-        dbus_test_dbus_mock_get_object(zgmock, "/org/gnome/zeitgeist/log/activity", "org.gnome.zeitgeist.Log", NULL);
-
-    dbus_test_dbus_mock_object_add_method(zgmock, zgobj, "InsertEvents", G_VARIANT_TYPE("a(asaasay)"),
-                                          G_VARIANT_TYPE("au"), "ret = [ 0 ]", NULL);
-
-    dbus_test_service_add_task(service, DBUS_TEST_TASK(zgmock));
-    dbus_test_task_run(DBUS_TEST_TASK(zgmock));
-    g_object_unref(G_OBJECT(zgmock));
+    auto zgmock = std::make_shared<ZeitgeistMock>();
+
+    /* New Systemd Mock */
+    dbus_test_service_remove_task(service, *systemd);
+    systemd.reset();
+    auto systemd2 = std::make_shared<SystemdMock>(
+        std::list<SystemdMock::Instance>{
+            {"application-click", "com.test.good_application_1.2.3", {}, spew.pid(), {spew.pid()}}},
+        CGROUP_DIR);
 
     /* Give things a chance to start */
-    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, TASK_STATE(cgmock2));
-    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, TASK_STATE(zgmock));
+    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, systemd2->stateFunc());
+    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, zgmock->stateFunc());
 
     /* Setup signal handling */
     guint paused_count = 0;
@@ -1592,14 +1002,10 @@
     EXPECT_EQ(0u, spew.dataCnt());
 
     /* Check to make sure we sent the event to ZG */
-    guint numcalls = 0;
-    const DbusTestDbusMockCall* calls =
-        dbus_test_dbus_mock_object_get_method_calls(zgmock, zgobj, "InsertEvents", &numcalls, NULL);
-
-    EXPECT_NE(nullptr, calls);
-    EXPECT_EQ(1u, numcalls);
-
-    dbus_test_dbus_mock_object_clear_method_calls(zgmock, zgobj, NULL);
+    auto inserts = zgmock->insertCalls();
+    EXPECT_EQ(1u, inserts.size());
+
+    zgmock->clear();
 
     /* Check to ensure we set the OOM score */
     EXPECT_EQ("900", spew.oomScore());
@@ -1613,11 +1019,10 @@
     EXPECT_NE(0u, spew.dataCnt());
 
     /* Check to make sure we sent the event to ZG */
-    numcalls = 0;
-    calls = dbus_test_dbus_mock_object_get_method_calls(zgmock, zgobj, "InsertEvents", &numcalls, NULL);
+    auto inserts2 = zgmock->insertCalls();
+    EXPECT_EQ(1u, inserts2.size());
 
-    EXPECT_NE(nullptr, calls);
-    EXPECT_EQ(1u, numcalls);
+    zgmock->clear();
 
     /* Check to ensure we set the OOM score */
     EXPECT_EQ("100", spew.oomScore());
@@ -1632,41 +1037,22 @@
     /* Setup A TON OF spew */
     std::array<SpewMaster, 50> spews;
 
-    /* Setup the cgroup */
-    g_setenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME", "org.test.cgmock2", TRUE);
-    DbusTestDbusMock* cgmock2 = dbus_test_dbus_mock_new("org.test.cgmock2");
-    DbusTestDbusMockObject* cgobject = dbus_test_dbus_mock_get_object(cgmock2, "/org/linuxcontainers/cgmanager",
-                                                                      "org.linuxcontainers.cgmanager0_0", NULL);
-
-    std::string pypids = "ret = [ " + std::accumulate(spews.begin(), spews.end(), std::string{},
-                                                      [](const std::string& accum, SpewMaster& spew) {
-                                                          return accum.empty() ?
-                                                                     std::to_string(spew.pid()) :
-                                                                     accum + ", " + std::to_string(spew.pid());
-                                                      }) +
-                         "]";
-    dbus_test_dbus_mock_object_add_method(cgmock, cgobject, "GetTasksRecursive", G_VARIANT_TYPE("(ss)"),
-                                          G_VARIANT_TYPE("ai"), pypids.c_str(), NULL);
-
-    dbus_test_service_add_task(service, DBUS_TEST_TASK(cgmock2));
-    dbus_test_task_run(DBUS_TEST_TASK(cgmock2));
-    g_object_unref(G_OBJECT(cgmock2));
-
     /* Setup ZG Mock */
-    DbusTestDbusMock* zgmock = dbus_test_dbus_mock_new("org.gnome.zeitgeist.Engine");
-    DbusTestDbusMockObject* zgobj =
-        dbus_test_dbus_mock_get_object(zgmock, "/org/gnome/zeitgeist/log/activity", "org.gnome.zeitgeist.Log", NULL);
-
-    dbus_test_dbus_mock_object_add_method(zgmock, zgobj, "InsertEvents", G_VARIANT_TYPE("a(asaasay)"),
-                                          G_VARIANT_TYPE("au"), "ret = [ 0 ]", NULL);
-
-    dbus_test_service_add_task(service, DBUS_TEST_TASK(zgmock));
-    dbus_test_task_run(DBUS_TEST_TASK(zgmock));
-    g_object_unref(G_OBJECT(zgmock));
+    auto zgmock = std::make_shared<ZeitgeistMock>();
+
+    /* New Systemd Mock */
+    dbus_test_service_remove_task(service, *systemd);
+    systemd.reset();
+    std::vector<pid_t> spewpids;
+    std::transform(spews.begin(), spews.end(), spewpids.begin(), [](SpewMaster& spew) { return spew.pid(); });
+    auto systemd2 = std::make_shared<SystemdMock>(
+        std::list<SystemdMock::Instance>{
+            {"application-click", "com.test.good_application_1.2.3", {}, spews.begin()->pid(), spewpids}},
+        CGROUP_DIR);
 
     /* Give things a chance to start */
-    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, TASK_STATE(cgmock2));
-    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, TASK_STATE(zgmock));
+    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, systemd2->stateFunc());
+    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, zgmock->stateFunc());
 
     /* Setup signal handling */
     guint paused_count = 0;
@@ -1763,23 +1149,6 @@
     g_free(procdir);
     ASSERT_TRUE(g_file_set_contents(oomadjfile, "0", -1, NULL));
 
-    /* Setup the cgroup */
-    g_setenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME", "org.test.cgmock2", TRUE);
-    DbusTestDbusMock* cgmock2 = dbus_test_dbus_mock_new("org.test.cgmock2");
-    DbusTestDbusMockObject* cgobject = dbus_test_dbus_mock_get_object(cgmock2, "/org/linuxcontainers/cgmanager",
-                                                                      "org.linuxcontainers.cgmanager0_0", NULL);
-    gchar* pypids = g_strdup_printf("ret = [%d]", testpid);
-    dbus_test_dbus_mock_object_add_method(cgmock, cgobject, "GetTasksRecursive", G_VARIANT_TYPE("(ss)"),
-                                          G_VARIANT_TYPE("ai"), pypids, NULL);
-    g_free(pypids);
-
-    dbus_test_service_add_task(service, DBUS_TEST_TASK(cgmock2));
-    dbus_test_task_run(DBUS_TEST_TASK(cgmock2));
-    g_object_unref(G_OBJECT(cgmock2));
-
-    /* Give things a chance to start */
-    EXPECT_EVENTUALLY_FUNC_EQ(DBUS_TEST_TASK_STATE_RUNNING, TASK_STATE(cgmock2));
-
     /* Get our app object */
     auto appid = ubuntu::app_launch::AppID::find(registry, "com.test.good_application_1.2.3");
     auto app = ubuntu::app_launch::Application::create(appid, registry);
@@ -1833,8 +1202,6 @@
 
 TEST_F(LibUAL, StartSessionHelper)
 {
-    DbusTestDbusMockObject* obj =
-        dbus_test_dbus_mock_get_object(mock, "/com/test/untrusted/helper", "com.ubuntu.Upstart0_6.Job", NULL);
     MirConnection* conn = mir_connect_sync("libual-test", "start-session-helper");  // Mocked, doesn't need cleaning up
     MirPromptSession* msession = mir_connection_create_prompt_session_sync(conn, 5, nullptr, nullptr);
 
@@ -1851,42 +1218,23 @@
 
     helper->launch(msession);
 
-    guint len = 0;
-    const DbusTestDbusMockCall* calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
-    EXPECT_NE(nullptr, calls);
-    ASSERT_EQ(1u, len);
-
-    EXPECT_STREQ("Start", calls->name);
-    EXPECT_EQ(2u, g_variant_n_children(calls->params));
-
-    GVariant* block = g_variant_get_child_value(calls->params, 1);
-    EXPECT_TRUE(g_variant_get_boolean(block));
-    g_variant_unref(block);
+    auto calls = systemd->unitCalls();
+    ASSERT_EQ(1u, calls.size());
 
     /* Check the environment */
-    GVariant* env = g_variant_get_child_value(calls->params, 0);
+    auto& env = calls.begin()->environment;
     EXPECT_TRUE(check_env(env, "APP_ID", "com.test.multiple_first_1.2.3"));
     EXPECT_TRUE(check_env(env, "HELPER_TYPE", "untrusted-type"));
 
-    GVariant* mnamev = find_env(env, "UBUNTU_APP_LAUNCH_DEMANGLE_NAME");
-    ASSERT_NE(nullptr, mnamev); /* Have to assert because, eh, GVariant */
-    EXPECT_STREQ(g_dbus_connection_get_unique_name(bus),
-                 g_variant_get_string(mnamev, nullptr) + strlen("UBUNTU_APP_LAUNCH_DEMANGLE_NAME="));
-    GVariant* mpathv = find_env(env, "UBUNTU_APP_LAUNCH_DEMANGLE_PATH");
-    ASSERT_NE(nullptr, mpathv); /* Have to assert because, eh, GVariant */
-
-    g_variant_unref(env);
+    auto demanglename = find_env(env, "UBUNTU_APP_LAUNCH_DEMANGLE_NAME");
+    ASSERT_FALSE(demanglename.empty());
+    EXPECT_EQ(g_dbus_connection_get_unique_name(bus), split_env(demanglename).second);
+    auto demanglepath = find_env(env, "UBUNTU_APP_LAUNCH_DEMANGLE_PATH");
+    ASSERT_FALSE(demanglepath.empty());
 
     /* Setup environment for call */
-    const gchar* mname = g_variant_get_string(mnamev, nullptr);
-    mname += strlen("UBUNTU_APP_LAUNCH_DEMANGLE_NAME=");
-    g_setenv("UBUNTU_APP_LAUNCH_DEMANGLE_NAME", mname, TRUE);
-    g_variant_unref(mnamev);
-
-    const gchar* mpath = g_variant_get_string(mpathv, nullptr);
-    mpath += strlen("UBUNTU_APP_LAUNCH_DEMANGLE_PATH=");
-    g_setenv("UBUNTU_APP_LAUNCH_DEMANGLE_PATH", mpath, TRUE);
-    g_variant_unref(mpathv);
+    g_setenv("UBUNTU_APP_LAUNCH_DEMANGLE_NAME", split_env(demanglename).second.c_str(), TRUE);
+    g_setenv("UBUNTU_APP_LAUNCH_DEMANGLE_PATH", split_env(demanglepath).second.c_str(), TRUE);
 
     /* Exec our tool */
     std::promise<std::string> outputpromise;
@@ -1919,11 +1267,11 @@
 
     ASSERT_STREQ(filedata, outputfuture.get().c_str());
 
-    ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
-
     return;
 }
 
+#if 0
+/* Need to change as helpers change to not use Upstart features */
 TEST_F(LibUAL, SetExec)
 {
     DbusTestDbusMockObject* obj =
@@ -1978,6 +1326,7 @@
 
     ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
 }
+#endif
 
 TEST_F(LibUAL, AppInfo)
 {

=== modified file 'tests/systemd-mock.h'
--- tests/systemd-mock.h	2017-02-04 03:53:34 +0000
+++ tests/systemd-mock.h	2017-03-21 03:20:55 +0000
@@ -551,4 +551,9 @@
             throw std::runtime_error{"Mock disfunctional"};
         }
     }
+
+    std::function<DbusTestTaskState()> stateFunc()
+    {
+        return [this] { return dbus_test_task_get_state(DBUS_TEST_TASK(mock)); };
+    }
 };

=== added file 'tests/zg-mock.h'
--- tests/zg-mock.h	1970-01-01 00:00:00 +0000
+++ tests/zg-mock.h	2017-03-21 03:20:55 +0000
@@ -0,0 +1,117 @@
+/*
+ * Copyright © 2017 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *