Ubuntu Application Launcher

Merge lp:~ted/ubuntu-app-launch/jobs-systemd into lp:ubuntu-app-launch

jobs-systemd
Merge into trunk.17.04

Proposed by Ted Gould on 2016-11-10

Status:	Merged
Approved by:	Ted Gould on 2017-02-02
Approved revision:	403
Merged at revision:	281
Proposed branch:	lp:~ted/ubuntu-app-launch/jobs-systemd
Merge into:	lp:ubuntu-app-launch
Prerequisite:	lp:~ted/ubuntu-app-launch/jobs-tests
Diff against target:	3215 lines (+2555/-102) 31 files modified debian/rules (+4/-1) libubuntu-app-launch/CMakeLists.txt (+4/-0) libubuntu-app-launch/application-impl-base.cpp (+26/-0) libubuntu-app-launch/application-impl-base.h (+3/-0) libubuntu-app-launch/application-impl-click.cpp (+6/-0) libubuntu-app-launch/application-impl-legacy.cpp (+4/-17) libubuntu-app-launch/application-impl-legacy.h (+0/-1) libubuntu-app-launch/application-impl-libertine.cpp (+11/-8) libubuntu-app-launch/application-impl-snap.cpp (+8/-4) libubuntu-app-launch/application-info-desktop.cpp (+1/-0) libubuntu-app-launch/application-info-desktop.h (+8/-0) libubuntu-app-launch/helper.h (+10/-10) libubuntu-app-launch/jobs-base.cpp (+47/-2) libubuntu-app-launch/jobs-base.h (+7/-0) libubuntu-app-launch/jobs-systemd.cpp (+1329/-0) libubuntu-app-launch/jobs-systemd.h (+136/-0) libubuntu-app-launch/jobs-upstart.cpp (+0/-25) libubuntu-app-launch/registry-impl.cpp (+1/-1) libubuntu-app-launch/snapd-info.cpp (+1/-1) tests/CMakeLists.txt (+11/-0) tests/eventually-fixture.h (+9/-0) tests/exec-util-test.cc (+10/-0) tests/failure-test.cc (+2/-0) tests/jobs-base-test.cpp (+1/-22) tests/jobs-systemd.cpp (+362/-0) tests/libual-cpp-test.cc (+11/-10) tests/libual-test.cc (+1/-0) tests/registry-mock.h (+57/-0) tests/spew-master.h (+2/-0) tests/systemd-mock.h (+481/-0) xmir-helper.c (+2/-0)
To merge this branch:	bzr merge lp:~ted/ubuntu-app-launch/jobs-systemd
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
unity-api-1-bot	continuous-integration		Needs Fixing on 2017-02-01
Charles Kerr (community)		2016-11-10	Approve on 2017-01-31
Review via email: mp+310590@code.launchpad.net

This proposal supersedes a proposal from 2016-10-26.

Commit message

SystemD backend added

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2017-01-24:

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

review: Needs Fixing (continuous-integration)

lp:~ted/ubuntu-app-launch/jobs-systemd updated on 2017-01-26

373. By Ted Gould on 2017-01-26: Update to trunk

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2017-01-26:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Charles Kerr (charlesk) wrote on 2017-01-26:

Comments inline.

As usual, mostly questions & minor. A few NF but nothing requiring major surgery.

review: Needs Fixing

lp:~ted/ubuntu-app-launch/jobs-systemd updated on 2017-01-27

374. By Ted Gould on 2017-01-26: Make getInstance a const method
375. By Ted Gould on 2017-01-26: Const getAllJobs()
376. By Ted Gould on 2017-01-26: Comment formatting, whatevs
377. By Ted Gould on 2017-01-26: Header reshuffle
378. By Ted Gould on 2017-01-26: Charles hates returns on void functions
379. By Ted Gould on 2017-01-27: We don't need no stinkin' std::string object
380. By Ted Gould on 2017-01-27: Remove some printouts when we cancel
381. By Ted Gould on 2017-01-27: Protect more against null GVariant pointers
382. By Ted Gould on 2017-01-27: Make the signal handlers safer
383. By Ted Gould on 2017-01-27: Make parseUnit and unitName const
384. By Ted Gould on 2017-01-27: Name lamba better
385. By Ted Gould on 2017-01-27: Use std::vector<> constructor instead of a loop
386. By Ted Gould on 2017-01-27: Be louder about not having an exec line
387. By Ted Gould on 2017-01-27: Getting rid of a TODO
388. By Ted Gould on 2017-01-27: Move declarations
389. By Ted Gould on 2017-01-27: Avoid calling getenv() twice
390. By Charles Kerr on 2017-01-27: Cleaner name finding
391. By Ted Gould on 2017-01-27: Make lists into real lists
392. By Ted Gould on 2017-01-27: Make sure we don't copy commands
393. By Ted Gould on 2017-01-27: Making sure we calculate the string once
394. By Ted Gould on 2017-01-27: Don't get all the jobs until we're sure we have a registry
395. By Ted Gould on 2017-01-27: Remove try/catch that isn't needed
396. By Ted Gould on 2017-01-27: Switching to static_cast<>
397. By Ted Gould on 2017-01-27: Fixing up the failure signals
398. By Charles Kerr on 2017-01-27: Clearer sorting
399. By Ted Gould on 2017-01-27: Overrides

Revision history for this message

Ted Gould (ted) on 2017-01-27:

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2017-01-27:

FAILED: Continuous integration, rev:399
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/184/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1528/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1535
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1313
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1313/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1313
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1313/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1313
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1313/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1313
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1313/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1313/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1313
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1313/artifact/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

lp:~ted/ubuntu-app-launch/jobs-systemd updated on 2017-01-28

400. By Ted Gould on 2017-01-28: Test the exec line and ensure it doesn't fail

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2017-01-28:

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

review: Needs Fixing (continuous-integration)

lp:~ted/ubuntu-app-launch/jobs-systemd updated on 2017-01-28

401. By Ted Gould on 2017-01-28: Don't crash free memory, works but is odd
402. By Ted Gould on 2017-01-28: Use the g_array functions to avoid some casts

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2017-01-28:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Charles Kerr (charlesk) wrote on 2017-01-31:

I'm happy with these changes, feel free to top-approve once the Jenkins issue is resolved (or if it's a false issue)

review: Approve

lp:~ted/ubuntu-app-launch/jobs-systemd updated on 2017-02-01

403. By Ted Gould on 2017-02-01: Making sure everything is on the right bus

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2017-02-01:

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

review: Needs Fixing (continuous-integration)

Preview Diff

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

Subscribers

People subscribed via source and target branches

to all changes:

Indicator Applet Developers

Ted Gould

 === modified file 'debian/rules'
 --- debian/rules	2016-07-11 13:46:43 +0000
 +++ debian/rules	2017-02-01 20:34:54 +0000
@@ -4,12 +4,15 @@
  # Get full logs in tests
  export G_MESSAGES_DEBUG=all
++# Ensure tests fail with criticals
++#export G_DEBUG=fatal_criticals
++
  # Uncomment this to turn on verbose mode.
  #export DH_VERBOSE=1
  export DPKG_GENSYMBOLS_CHECK_LEVEL=4
  %:
--	dh $@ --with click,gir --parallel --fail-missing
++	dh $@ --with click,gir --fail-missing
  override_dh_click:
  	dh_click --name ubuntu-app-launch-desktop
 === modified file 'libubuntu-app-launch/CMakeLists.txt'
 --- libubuntu-app-launch/CMakeLists.txt	2016-11-17 16:31:47 +0000
 +++ libubuntu-app-launch/CMakeLists.txt	2017-02-01 20:34:54 +0000
@@ -17,6 +17,8 @@
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wpedantic")
  add_definitions ( -DOOM_HELPER="${pkglibexecdir}/oom-adjust-setuid-helper" -DDEMANGLER_PATH="${pkglibexecdir}/socket-demangler" )
  add_definitions ( -DLIBERTINE_LAUNCH="${CMAKE_INSTALL_FULL_BINDIR}/libertine-launch" )
++add_definitions ( -DG_LOG_DOMAIN="ubuntu-app-launch" )
++add_definitions ( -DUBUNTU_APP_LAUNCH_ARCH="${UBUNTU_APP_LAUNCH_ARCH}" )
  set(LAUNCHER_HEADERS
  ubuntu-app-launch.h
@@ -54,6 +56,8 @@
  glib-thread.cpp
  jobs-base.h
  jobs-base.cpp
++jobs-systemd.h
++jobs-systemd.cpp
  jobs-upstart.h
  jobs-upstart.cpp
+ )
 === modified file 'libubuntu-app-launch/application-impl-base.cpp'
 --- libubuntu-app-launch/application-impl-base.cpp	2017-01-11 21:31:59 +0000
 +++ libubuntu-app-launch/application-impl-base.cpp	2017-02-01 20:34:54 +0000
@@ -42,6 +42,12 @@
  Base::Base(const std::shared_ptr<Registry>& registry)
      : _registry(registry)
+ {
++    g_debug("Application construction:   %p", static_cast<void*>(this));
++}
++
++Base::~Base()
++{
++    g_debug("Application deconstruction: %p", static_cast<void*>(this));
+ }
  bool Base::hasInstances()
@@ -95,6 +101,26 @@
      return retval;
+ }
++/** Generates an instance string based on the clock if we're a multi-instance
++    application. */
++std::string Base::getInstance(const std::shared_ptr<app_info::Desktop>& desktop) const
++{
++    if (!desktop)
++    {
++        g_warning("Invalid desktop file passed to getInstance");
++        return {};
++    }
++
++    if (desktop->singleInstance())
++    {
++        return {};
++    }
++    else
++    {
++        return std::to_string(g_get_real_time());
++    }
++}
++
  }  // namespace app_impls
  }  // namespace app_launch
  }  // namespace ubuntu
 === modified file 'libubuntu-app-launch/application-impl-base.h'
 --- libubuntu-app-launch/application-impl-base.h	2016-12-14 22:49:35 +0000
 +++ libubuntu-app-launch/application-impl-base.h	2017-02-01 20:34:54 +0000
@@ -17,6 +17,7 @@
   *     Ted Gould <ted.gould@canonical.com>
   */
++#include "application-info-desktop.h"
  #include "application.h"
  extern "C" {
@@ -40,9 +41,11 @@
+ {
  public:
      Base(const std::shared_ptr<Registry>& registry);
++    virtual ~Base();
      bool hasInstances() override;
++    std::string getInstance(const std::shared_ptr<app_info::Desktop>& desktop) const;
      virtual std::shared_ptr<Application::Instance> findInstance(const std::string& instanceid) = 0;
  protected:
 === modified file 'libubuntu-app-launch/application-impl-click.cpp'
 --- libubuntu-app-launch/application-impl-click.cpp	2016-12-14 22:49:35 +0000
 +++ libubuntu-app-launch/application-impl-click.cpp	2017-02-01 20:34:54 +0000
@@ -51,6 +51,8 @@
      std::tie(_keyfile, desktopPath_) = manifestAppDesktop(_manifest, appid.package, appid.appname, _clickDir);
      if (!_keyfile)
          throw std::runtime_error{"No keyfile found for click application: " + std::string(appid)};
++
++    g_debug("Application Click object for appid '%s'", std::string(appid).c_str());
+ }
  AppID Click::appId()
@@ -337,11 +339,15 @@
      retval.emplace_back(std::make_pair("APP_DIR", _clickDir));
      retval.emplace_back(std::make_pair("APP_DESKTOP_FILE_PATH", desktopPath_));
++    retval.emplace_back(std::make_pair("QML2_IMPORT_PATH", _clickDir + "/lib/" + UBUNTU_APP_LAUNCH_ARCH + "/qml"));
++
      info();
      retval.emplace_back(std::make_pair("APP_XMIR_ENABLE", _info->xMirEnable().value() ? "1" : "0"));
      retval.emplace_back(std::make_pair("APP_EXEC", _info->execLine().value()));
++    retval.emplace_back(std::make_pair("APP_EXEC_POLICY", std::string(appId())));
++
      return retval;
+ }
 === modified file 'libubuntu-app-launch/application-impl-legacy.cpp'
 --- libubuntu-app-launch/application-impl-legacy.cpp	2016-12-14 22:49:35 +0000
 +++ libubuntu-app-launch/application-impl-legacy.cpp	2017-02-01 20:34:54 +0000
@@ -74,6 +74,8 @@
+     {
          throw std::runtime_error{"Looking like a legacy app, but should be a Snap: " + appname.value()};
+     }
++
++    g_debug("Application Legacy object for app '%s'", appname.value().c_str());
+ }
  std::tuple<std::string, std::shared_ptr<GKeyFile>, std::string> keyfileForApp(const AppID::AppName& name)
@@ -342,21 +344,6 @@
      return retval;
+ }
--/** Generates an instance string based on the clock if we're a multi-instance
--    application. */
--std::string Legacy::getInstance()
--{
--    auto single = g_key_file_get_boolean(_keyfile.get(), "Desktop Entry", "X-Ubuntu-Single-Instance", nullptr);
--    if (single)
--    {
--        return {};
--    }
--    else
--    {
--        return std::to_string(g_get_real_time());
--    }
--}
--
  /** Create an UpstartInstance for this AppID using the UpstartInstance launch
      function.
@@ -364,7 +351,7 @@
  */
  std::shared_ptr<Application::Instance> Legacy::launch(const std::vector<Application::URL>& urls)
+ {
--    std::string instance = getInstance();
++    auto instance = getInstance(appinfo_);
      std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this, instance]() {
          return launchEnv(instance);
      };
@@ -379,7 +366,7 @@
  */
  std::shared_ptr<Application::Instance> Legacy::launchTest(const std::vector<Application::URL>& urls)
+ {
--    std::string instance = getInstance();
++    auto instance = getInstance(appinfo_);
      std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this, instance]() {
          return launchEnv(instance);
      };
 === modified file 'libubuntu-app-launch/application-impl-legacy.h'
 --- libubuntu-app-launch/application-impl-legacy.h	2016-12-14 22:49:35 +0000
 +++ libubuntu-app-launch/application-impl-legacy.h	2017-02-01 20:34:54 +0000
@@ -88,7 +88,6 @@
      std::regex instanceRegex_;
      std::list<std::pair<std::string, std::string>> launchEnv(const std::string& instance);
--    std::string getInstance();
  };
  }  // namespace app_impls
 === modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
 --- libubuntu-app-launch/application-impl-libertine.cpp	2017-01-06 17:53:21 +0000
 +++ libubuntu-app-launch/application-impl-libertine.cpp	2017-02-01 20:34:54 +0000
@@ -65,6 +65,12 @@
      if (!_keyfile)
          throw std::runtime_error{"Unable to find a keyfile for application '" + appname.value() + "' in container '" +
                                   container.value() + "'"};
++
++    appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, _container_path,
++                                                   app_info::DesktopFlags::XMIR_DEFAULT, _registry);
++
++    g_debug("Application Libertine object for container '%s' app '%s'", container.value().c_str(),
++            appname.value().c_str());
+ }
  std::shared_ptr<GKeyFile> Libertine::keyfileFromPath(const std::string& pathname)
@@ -265,11 +271,6 @@
  std::shared_ptr<Application::Info> Libertine::info()
+ {
--    if (!appinfo_)
--    {
--        appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, _container_path,
--                                                       app_info::DesktopFlags::XMIR_DEFAULT, _registry);
--    }
      return appinfo_;
+ }
@@ -317,15 +318,17 @@
  std::shared_ptr<Application::Instance> Libertine::launch(const std::vector<Application::URL>& urls)
+ {
++    auto instance = getInstance(appinfo_);
      std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
--    return _registry->impl->jobs->launch(appId(), "application-legacy", {}, urls, jobs::manager::launchMode::STANDARD,
--                                         envfunc);
++    return _registry->impl->jobs->launch(appId(), "application-legacy", instance, urls,
++                                         jobs::manager::launchMode::STANDARD, envfunc);
+ }
  std::shared_ptr<Application::Instance> Libertine::launchTest(const std::vector<Application::URL>& urls)
+ {
++    auto instance = getInstance(appinfo_);
      std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
--    return _registry->impl->jobs->launch(appId(), "application-legacy", {}, urls, jobs::manager::launchMode::TEST,
++    return _registry->impl->jobs->launch(appId(), "application-legacy", instance, urls, jobs::manager::launchMode::TEST,
                                           envfunc);
+ }
 === modified file 'libubuntu-app-launch/application-impl-snap.cpp'
 --- libubuntu-app-launch/application-impl-snap.cpp	2017-01-19 03:22:56 +0000
 +++ libubuntu-app-launch/application-impl-snap.cpp	2017-02-01 20:34:54 +0000
@@ -226,6 +226,8 @@
+     }
      info_ = std::make_shared<SnapInfo>(appid_, _registry, interface_, pkgInfo_->directory);
++
++    g_debug("Application Snap object for AppID '%s'", std::string(appid).c_str());
+ }
  /** Uses the findInterface() function to find the interface if we don't
@@ -259,7 +261,7 @@
+             }
              catch (std::runtime_error& e)
+             {
--                g_warning("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
++                g_debug("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
+             }
+         }
+     }
@@ -466,9 +468,10 @@
  */
  std::shared_ptr<Application::Instance> Snap::launch(const std::vector<Application::URL>& urls)
+ {
++    auto instance = getInstance(info_);
      std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
--    return _registry->impl->jobs->launch(appid_, "application-snap", {}, urls, jobs::manager::launchMode::STANDARD,
--                                         envfunc);
++    return _registry->impl->jobs->launch(appid_, "application-snap", instance, urls,
++                                         jobs::manager::launchMode::STANDARD, envfunc);
+ }
  /** Create a new instance of this Snap with a testing environment
@@ -478,8 +481,9 @@
  */
  std::shared_ptr<Application::Instance> Snap::launchTest(const std::vector<Application::URL>& urls)
+ {
++    auto instance = getInstance(info_);
      std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
--    return _registry->impl->jobs->launch(appid_, "application-snap", {}, urls, jobs::manager::launchMode::TEST,
++    return _registry->impl->jobs->launch(appid_, "application-snap", instance, urls, jobs::manager::launchMode::TEST,
                                           envfunc);
+ }
 === modified file 'libubuntu-app-launch/application-info-desktop.cpp'
 --- libubuntu-app-launch/application-info-desktop.cpp	2017-01-12 23:00:08 +0000
 +++ libubuntu-app-launch/application-info-desktop.cpp	2017-02-01 20:34:54 +0000
@@ -396,6 +396,7 @@
      , _xMirEnable(
            boolFromKeyfile<XMirEnable>(keyfile, "X-Ubuntu-XMir-Enable", (flags & DesktopFlags::XMIR_DEFAULT).any()))
      , _exec(stringFromKeyfile<Exec>(keyfile, "Exec"))
++    , _singleInstance(boolFromKeyfile<SingleInstance>(keyfile, "X-Ubuntu-Single-Instance", false))
+ {
+ }
 === modified file 'libubuntu-app-launch/application-info-desktop.h'
 --- libubuntu-app-launch/application-info-desktop.h	2016-09-14 16:38:42 +0000
 +++ libubuntu-app-launch/application-info-desktop.h	2017-02-01 20:34:54 +0000
@@ -106,6 +106,13 @@
          return _exec;
+     }
++    struct SingleInstanceTag;
++    typedef TypeTagger<SingleInstanceTag, bool> SingleInstance;
++    virtual SingleInstance singleInstance()
++    {
++        return _singleInstance;
++    }
++
  protected:
      std::shared_ptr<GKeyFile> _keyfile;
      std::string _basePath;
@@ -125,6 +132,7 @@
      XMirEnable _xMirEnable;
      Exec _exec;
++    SingleInstance _singleInstance;
  };
  }  // namespace AppInfo
 === modified file 'libubuntu-app-launch/helper.h'
 --- libubuntu-app-launch/helper.h	2017-01-24 04:21:06 +0000
 +++ libubuntu-app-launch/helper.h	2017-02-01 20:34:54 +0000
@@ -62,11 +62,11 @@
  */
  class Helper
+ {
--/*
--protected:
--    Helper() = default;
--    virtual ~Helper() = default;
--       TODO: Next ABI break */
++    /*
++    protected:
++        Helper() = default;
++        virtual ~Helper() = default;
++           TODO: Next ABI break */
  public:
      /** \private */
@@ -93,11 +93,11 @@
      /** Running instance of a a Helper */
      class Instance
+     {
--/*
--    protected:
--        Instance() = default;
--        virtual ~Instance() = default;
--           TODO: Next ABI break */
++        /*
++            protected:
++                Instance() = default;
++                virtual ~Instance() = default;
++                   TODO: Next ABI break */
      public:
          /** Check to see if this instance is running */
 === modified file 'libubuntu-app-launch/jobs-base.cpp'
 --- libubuntu-app-launch/jobs-base.cpp	2017-01-11 22:28:11 +0000
 +++ libubuntu-app-launch/jobs-base.cpp	2017-02-01 20:34:54 +0000
@@ -24,6 +24,7 @@
  #include "application-impl-base.h"
  #include "jobs-base.h"
++#include "jobs-systemd.h"
  #include "jobs-upstart.h"
  #include "registry-impl.h"
@@ -38,6 +39,7 @@
  Base::Base(const std::shared_ptr<Registry>& registry)
      : registry_(registry)
++    , allJobs_{"application-click", "application-legacy", "application-snap"}
      , dbus_(registry->impl->_dbus)
+ {
+ }
@@ -61,7 +63,25 @@
  std::shared_ptr<Base> Base::determineFactory(std::shared_ptr<Registry> registry)
+ {
--    return std::make_shared<jobs::manager::Upstart>(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);
++    }
++}
++
++const std::set<std::string>& Base::getAllJobs() const
++{
++    return allJobs_;
+ }
  /** Structure to track the data needed for upstart events. This cleans
@@ -438,7 +458,9 @@
  bool Base::hasPid(pid_t pid)
+ {
      auto vpids = pids();
--    return std::find(vpids.begin(), vpids.end(), pid) != vpids.end();
++    bool hasit = std::find(vpids.begin(), vpids.end(), pid) != vpids.end();
++    g_debug("Checking for PID %d on AppID '%s' result: %s", pid, std::string(appId_).c_str(), hasit ? "YES" : "NO");
++    return hasit;
+ }
  /** Pauses this application by sending SIGSTOP to all the PIDs in the
@@ -745,6 +767,29 @@
+     }
+ }
++/** Reformat a C++ vector of URLs into a C GStrv of strings
++
++    \param urls Vector of URLs to make into C strings
++*/
++std::shared_ptr<gchar*> Base::urlsToStrv(const std::vector<Application::URL>& urls)
++{
++    if (urls.empty())
++    {
++        return {};
++    }
++
++    auto array = g_array_new(TRUE, FALSE, sizeof(gchar*));
++
++    for (auto url : urls)
++    {
++        auto str = g_strdup(url.value().c_str());
++        g_debug("Converting URL: %s", str);
++        g_array_append_val(array, str);
++    }
++
++    return std::shared_ptr<gchar*>((gchar**)g_array_free(array, FALSE), g_strfreev);
++}
++
  }  // namespace instance
  }  // namespace jobs
 === modified file 'libubuntu-app-launch/jobs-base.h'
 --- libubuntu-app-launch/jobs-base.h	2017-01-11 22:28:11 +0000
 +++ libubuntu-app-launch/jobs-base.h	2017-02-01 20:34:54 +0000
@@ -24,6 +24,7 @@
  #include <core/signal.h>
  #include <gio/gio.h>
++#include <set>
  namespace ubuntu
+ {
@@ -76,6 +77,7 @@
      static void oomValueToPid(pid_t pid, const oom::Score oomvalue);
      static void oomValueToPidHelper(pid_t pid, const oom::Score oomvalue);
      static std::string pidToOomPath(pid_t pid);
++    static std::shared_ptr<gchar*> urlsToStrv(const std::vector<Application::URL>& urls);
  };
  }  // namespace instance
@@ -113,6 +115,8 @@
      virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) = 0;
++    const std::set<std::string>& getAllJobs() const;
++
      static std::shared_ptr<Base> determineFactory(std::shared_ptr<Registry> registry);
      /* Signals to apps */
@@ -141,6 +145,9 @@
      /** A link to the registry */
      std::weak_ptr<Registry> registry_;
++    /** A set of all the job names */
++    std::set<std::string> allJobs_;
++
      /** The DBus connection we're connecting to */
      std::shared_ptr<GDBusConnection> dbus_;
 === added file 'libubuntu-app-launch/jobs-systemd.cpp'
 --- libubuntu-app-launch/jobs-systemd.cpp	1970-01-01 00:00:00 +0000
 +++ libubuntu-app-launch/jobs-systemd.cpp	2017-02-01 20:34:54 +0000
@@ -0,0 +1,1329 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#include "jobs-systemd.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 <gio/gio.h>
++#include <sys/types.h>
++#include <unistd.h>
++
++#include <algorithm>
++#include <numeric>
++#include <regex>
++
++namespace ubuntu
++{
++namespace app_launch
++{
++namespace jobs
++{
++namespace instance
++{
++
++class SystemD : public instance::Base
++{
++    friend class manager::SystemD;
++
++public:
++    explicit SystemD(const AppID& appId,
++                     const std::string& job,
++                     const std::string& instance,
++                     const std::vector<Application::URL>& urls,
++                     const std::shared_ptr<Registry>& registry);
++    virtual ~SystemD()
++    {
++        g_debug("Destroying a SystemD for '%s' instance '%s'", std::string(appId_).c_str(), instance_.c_str());
++    }
++
++    /* Query lifecycle */
++    pid_t primaryPid() override;
++    std::string logPath() override;
++    std::vector<pid_t> pids() override;
++
++    /* Manage lifecycle */
++    void stop() override;
++
++};  // class SystemD
++
++SystemD::SystemD(const AppID& appId,
++                 const std::string& job,
++                 const std::string& instance,
++                 const std::vector<Application::URL>& urls,
++                 const std::shared_ptr<Registry>& registry)
++    : Base(appId, job, instance, urls, registry)
++{
++    g_debug("Creating a new SystemD for '%s' instance '%s'", std::string(appId).c_str(), instance.c_str());
++}
++
++pid_t SystemD::primaryPid()
++{
++    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
++    return manager->unitPrimaryPid(appId_, job_, instance_);
++}
++
++std::string SystemD::logPath()
++{
++    /* NOTE: We can never get this for systemd */
++    g_warning("Log paths aren't available for systemd");
++    return {};
++}
++
++std::vector<pid_t> SystemD::pids()
++{
++    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
++    return manager->unitPids(appId_, job_, instance_);
++}
++
++void SystemD::stop()
++{
++    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
++    manager->stopUnit(appId_, job_, instance_);
++}
++
++}  // namespace instance
++
++namespace manager
++{
++
++static const char* SYSTEMD_DBUS_ADDRESS{"org.freedesktop.systemd1"};
++static const char* SYSTEMD_DBUS_IFACE_MANAGER{"org.freedesktop.systemd1.Manager"};
++static const char* SYSTEMD_DBUS_PATH_MANAGER{"/org/freedesktop/systemd1"};
++// static const char * SYSTEMD_DBUS_IFACE_UNIT{"org.freedesktop.systemd1.Unit"};
++static const char* SYSTEMD_DBUS_IFACE_SERVICE{"org.freedesktop.systemd1.Service"};
++
++SystemD::SystemD(std::shared_ptr<Registry> registry)
++    : Base(registry)
++{
++    auto gcgroup_root = getenv("UBUNTU_APP_LAUNCH_SYSTEMD_CGROUP_ROOT");
++    if (gcgroup_root == nullptr)
++    {
++        auto cpath = g_build_filename("/sys", "fs", "cgroup", "systemd", nullptr);
++        cgroup_root_ = cpath;
++        g_free(cpath);
++    }
++    else
++    {
++        cgroup_root_ = gcgroup_root;
++    }
++
++    auto cancel = registry->impl->thread.getCancellable();
++    userbus_ = registry->impl->thread.executeOnThread<std::shared_ptr<GDBusConnection>>([this, cancel]() {
++        GError* error = nullptr;
++        auto bus = std::shared_ptr<GDBusConnection>(
++            [&]() -> GDBusConnection* {
++                if (g_file_test(SystemD::userBusPath().c_str(), G_FILE_TEST_EXISTS))
++                {
++                    return g_dbus_connection_new_for_address_sync(
++                        ("unix:path=" + userBusPath()).c_str(), /* path to the user bus */
++                        (GDBusConnectionFlags)(
++                            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
++                            G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION), /* It is a message bus */
++                        nullptr,                                             /* observer */
++                        cancel.get(),                                        /* cancellable from the thread */
++                        &error);                                             /* error */
++                }
++                else
++                {
++                    /* Fallback mostly for testing */
++                    g_debug("Using session bus for systemd user bus");
++                    return g_bus_get_sync(G_BUS_TYPE_SESSION, /* type */
++                                          cancel.get(),       /* thread cancellable */
++                                          &error);            /* error */
++                }
++            }(),
++            [](GDBusConnection* bus) { g_clear_object(&bus); });
++
++        if (error != nullptr)
++        {
++            std::string message = std::string("Unable to connect to user bus: ") + error->message;
++            g_error_free(error);
++            throw std::runtime_error(message);
++        }
++
++        /* If we don't subscribe, it doesn't send us signals :-( */
++        g_dbus_connection_call(bus.get(),                  /* user bus */
++                               SYSTEMD_DBUS_ADDRESS,       /* bus name */
++                               SYSTEMD_DBUS_PATH_MANAGER,  /* path */
++                               SYSTEMD_DBUS_IFACE_MANAGER, /* interface */
++                               "Subscribe",                /* method */
++                               nullptr,                    /* params */
++                               nullptr,                    /* ret type */
++                               G_DBUS_CALL_FLAGS_NONE,     /* flags */
++                               -1,                         /* timeout */
++                               cancel.get(),               /* cancellable */
++                               [](GObject* obj, GAsyncResult* res, gpointer user_data) {
++                                   GError* error{nullptr};
++                                   GVariant* callt = g_dbus_connection_call_finish(G_DBUS_CONNECTION(obj), res, &error);
++
++                                   if (error != nullptr)
++                                   {
++                                       if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++                                       {
++                                           g_warning("Unable to subscribe to SystemD: %s", error->message);
++                                       }
++                                       g_error_free(error);
++                                       return;
++                                   }
++
++                                   g_clear_pointer(&callt, g_variant_unref);
++                                   g_debug("Subscribed to Systemd");
++                               },
++                               nullptr);
++
++        /* Setup Unit add/remove signals */
++        handle_unitNew = g_dbus_connection_signal_subscribe(
++            bus.get(),                  /* bus */
++            nullptr,                    /* sender */
++            SYSTEMD_DBUS_IFACE_MANAGER, /* interface */
++            "UnitNew",                  /* signal */
++            SYSTEMD_DBUS_PATH_MANAGER,  /* path */
++            nullptr,                    /* arg0 */
++            G_DBUS_SIGNAL_FLAGS_NONE,
++            [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
++               gpointer user_data) -> void {
++                auto pthis = static_cast<SystemD*>(user_data);
++
++                if (!g_variant_check_format_string(params, "(so)", FALSE))
++                {
++                    g_warning("Got 'UnitNew' signal with unknown parameter type: %s",
++                              g_variant_get_type_string(params));
++                    return;
++                }
++
++                const gchar* unitname{nullptr};
++                const gchar* unitpath{nullptr};
++
++                g_variant_get(params, "(&s&o)", &unitname, &unitpath);
++
++                if (unitname == nullptr || unitpath == nullptr)
++                {
++                    g_warning("Got 'UnitNew' signal with funky params %p, %p", unitname, unitpath);
++                    return;
++                }
++
++                try
++                {
++                    pthis->parseUnit(unitname);
++                }
++                catch (std::runtime_error& e)
++                {
++                    /* Not for UAL */
++                    g_debug("Unable to parse unit: %s", unitname);
++                    return;
++                }
++
++                try
++                {
++                    auto info = pthis->unitNew(unitname, unitpath, pthis->userbus_);
++                    pthis->emitSignal(pthis->sig_appStarted, info);
++                }
++                catch (std::runtime_error& e)
++                {
++                    g_warning("%s", e.what());
++                }
++            },        /* callback */
++            this,     /* user data */
++            nullptr); /* user data destroy */
++
++        handle_unitRemoved = g_dbus_connection_signal_subscribe(
++            bus.get(),                  /* bus */
++            nullptr,                    /* sender */
++            SYSTEMD_DBUS_IFACE_MANAGER, /* interface */
++            "UnitRemoved",              /* signal */
++            SYSTEMD_DBUS_PATH_MANAGER,  /* path */
++            nullptr,                    /* arg0 */
++            G_DBUS_SIGNAL_FLAGS_NONE,
++            [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
++               gpointer user_data) -> void {
++                auto pthis = static_cast<SystemD*>(user_data);
++
++                if (!g_variant_check_format_string(params, "(so)", FALSE))
++                {
++                    g_warning("Got 'UnitRemoved' signal with unknown parameter type: %s",
++                              g_variant_get_type_string(params));
++                    return;
++                }
++
++                const gchar* unitname{nullptr};
++                const gchar* unitpath{nullptr};
++
++                g_variant_get(params, "(&s&o)", &unitname, &unitpath);
++
++                if (unitname == nullptr || unitpath == nullptr)
++                {
++                    g_warning("Got 'UnitRemoved' signal with funky params %p, %p", unitname, unitpath);
++                    return;
++                }
++
++                try
++                {
++                    pthis->parseUnit(unitname);
++                }
++                catch (std::runtime_error& e)
++                {
++                    /* Not for UAL */
++                    g_debug("Unable to parse unit: %s", unitname);
++                    return;
++                }
++
++                pthis->unitRemoved(unitname, unitpath);
++            },        /* callback */
++            this,     /* user data */
++            nullptr); /* user data destroy */
++
++        getInitialUnits(bus, cancel);
++
++        return bus;
++    });
++}
++
++SystemD::~SystemD()
++{
++    auto unsub = [&](guint& handle) {
++        if (handle != 0)
++        {
++            g_dbus_connection_signal_unsubscribe(userbus_.get(), handle);
++            handle = 0;
++        }
++    };
++
++    unsub(handle_unitNew);
++    unsub(handle_unitRemoved);
++    unsub(handle_appFailed);
++}
++
++void SystemD::getInitialUnits(const std::shared_ptr<GDBusConnection>& bus, const std::shared_ptr<GCancellable>& cancel)
++{
++    GError* error = nullptr;
++
++    auto callt = g_dbus_connection_call_sync(bus.get(),                         /* user bus */
++                                             SYSTEMD_DBUS_ADDRESS,              /* bus name */
++                                             SYSTEMD_DBUS_PATH_MANAGER,         /* path */
++                                             SYSTEMD_DBUS_IFACE_MANAGER,        /* interface */
++                                             "ListUnits",                       /* method */
++                                             nullptr,                           /* params */
++                                             G_VARIANT_TYPE("(a(ssssssouso))"), /* ret type */
++                                             G_DBUS_CALL_FLAGS_NONE,            /* flags */
++                                             -1,                                /* timeout */
++                                             cancel.get(),                      /* cancellable */
++                                             &error);
++
++    if (error != nullptr)
++    {
++        if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++        {
++            g_warning("Unable to list SystemD units: %s", error->message);
++        }
++        g_error_free(error);
++        return;
++    }
++
++    GVariant* call = g_variant_get_child_value(callt, 0);
++    g_variant_unref(callt);
++
++    const gchar* id;
++    const gchar* description;
++    const gchar* loadState;
++    const gchar* activeState;
++    const gchar* subState;
++    const gchar* following;
++    const gchar* path;
++    guint32 jobId;
++    const gchar* jobType;
++    const gchar* jobPath;
++    auto iter = g_variant_iter_new(call);
++    while (g_variant_iter_loop(iter, "(&s&s&s&s&s&s&ou&s&o)", &id, &description, &loadState, &activeState, &subState,
++                               &following, &path, &jobId, &jobType, &jobPath))
++    {
++        g_debug("List Units: %s", id);
++        try
++        {
++            unitNew(id, jobPath, bus);
++        }
++        catch (std::runtime_error& e)
++        {
++            g_debug("%s", e.what());
++        }
++    }
++
++    g_variant_iter_free(iter);
++    g_variant_unref(call);
++}
++
++std::string SystemD::findEnv(const std::string& value, std::list<std::pair<std::string, std::string>>& env)
++{
++    std::string retval;
++    auto entry = std::find_if(env.begin(), env.end(),
++                              [&value](std::pair<std::string, std::string>& entry) { return entry.first == value; });
++
++    if (entry != env.end())
++    {
++        retval = entry->second;
++    }
++
++    return retval;
++}
++
++void SystemD::removeEnv(const std::string& value, std::list<std::pair<std::string, std::string>>& env)
++{
++    auto entry = std::find_if(env.begin(), env.end(),
++                              [&value](std::pair<std::string, std::string>& entry) { return entry.first == value; });
++
++    if (entry != env.end())
++    {
++        env.erase(entry);
++    }
++}
++
++int SystemD::envSize(std::list<std::pair<std::string, std::string>>& env)
++{
++    int len = std::string{"Environment="}.length();
++
++    for (const auto& entry : env)
++    {
++        len += 3; /* two quotes, one space */
++        len += entry.first.length();
++        len += entry.second.length();
++    }
++
++    len -= 1; /* We account for a space each time but the first doesn't have */
++
++    return len;
++}
++
++std::vector<std::string> SystemD::parseExec(std::list<std::pair<std::string, std::string>>& env)
++{
++    auto exec = findEnv("APP_EXEC", env);
++    if (exec.empty())
++    {
++        g_warning("Application exec line is empty?!?!?");
++        return {};
++    }
++    auto uris = findEnv("APP_URIS", env);
++
++    g_debug("Exec line: %s", exec.c_str());
++    g_debug("App URLS:  %s", uris.c_str());
++
++    auto execarray = desktop_exec_parse(exec.c_str(), uris.c_str());
++
++    std::vector<std::string> retval;
++    for (unsigned int i = 0; i < execarray->len; i++)
++    {
++        auto cstr = g_array_index(execarray, gchar*, i);
++        if (cstr != nullptr)
++        {
++            retval.emplace_back(cstr);
++        }
++    }
++
++    /* This seems to work better than array_free(), I can't figure out why */
++    auto strv = (gchar**)g_array_free(execarray, FALSE);
++    g_strfreev(strv);
++
++    if (retval.empty())
++    {
++        g_warning("After parsing 'APP_EXEC=%s' we ended up with no tokens", exec.c_str());
++    }
++
++    /* See if we need the xmir helper */
++    if (findEnv("APP_XMIR_ENABLE", env) == "1" && getenv("DISPLAY") == nullptr)
++    {
++        retval.emplace(retval.begin(), findEnv("APP_ID", env));
++        retval.emplace(retval.begin(), XMIR_HELPER);
++    }
++
++    /* See if we're doing apparmor by hand */
++    auto appexecpolicy = findEnv("APP_EXEC_POLICY", env);
++    if (!appexecpolicy.empty() && appexecpolicy != "unconfined")
++    {
++        retval.emplace(retval.begin(), appexecpolicy);
++        retval.emplace(retval.begin(), "-p");
++        retval.emplace(retval.begin(), "aa-exec");
++    }
++
++    return retval;
++}
++
++/** Small helper that we can new/delete to work better with C stuff */
++struct StartCHelper
++{
++    std::shared_ptr<instance::SystemD> ptr;
++    std::shared_ptr<GDBusConnection> bus;
++};
++
++void SystemD::application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data)
++{
++    auto data = static_cast<StartCHelper*>(user_data);
++
++    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());
++
++    GError* error{nullptr};
++    GVariant* result{nullptr};
++
++    result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(obj), res, &error);
++
++    /* We don't care about the result but we need to make sure we don't
++       have a leak. */
++    g_clear_pointer(&result, g_variant_unref);
++
++    if (error != nullptr)
++    {
++        if (g_dbus_error_is_remote_error(error))
++        {
++            gchar* remote_error = g_dbus_error_get_remote_error(error);
++            g_debug("Remote error: %s", remote_error);
++            if (g_strcmp0(remote_error, "org.freedesktop.systemd1.UnitExists") == 0)
++            {
++                auto urls = instance::SystemD::urlsToStrv(data->ptr->urls_);
++                second_exec(data->bus.get(),                                           /* DBus */
++                            data->ptr->registry_->impl->thread.getCancellable().get(), /* cancellable */
++                            data->ptr->primaryPid(),                                   /* primary pid */
++                            std::string(data->ptr->appId_).c_str(),                    /* appid */
++                            data->ptr->instance_.c_str(),                              /* instance */
++                            urls.get());                                               /* urls */
++            }
++
++            g_free(remote_error);
++        }
++        else
++        {
++            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++            {
++                g_warning("Unable to emit event to start application: %s", error->message);
++            }
++        }
++        g_error_free(error);
++    }
++
++    delete data;
++}
++
++void SystemD::copyEnv(const std::string& envname, std::list<std::pair<std::string, std::string>>& env)
++{
++    if (!findEnv(envname, env).empty())
++    {
++        g_debug("Already a value set for '%s' ignoring", envname.c_str());
++        return;
++    }
++
++    auto cvalue = getenv(envname.c_str());
++    g_debug("Copying Environment: %s", envname.c_str());
++    if (cvalue != nullptr)
++    {
++        std::string value{cvalue};
++        env.emplace_back(std::make_pair(envname, value));
++    }
++    else
++    {
++        g_debug("Unable to copy environment '%s'", envname.c_str());
++    }
++}
++
++void SystemD::copyEnvByPrefix(const std::string& prefix, std::list<std::pair<std::string, std::string>>& env)
++{
++    for (unsigned int i = 0; environ[i] != nullptr; i++)
++    {
++        if (g_str_has_prefix(environ[i], prefix.c_str()))
++        {
++            std::string envname = environ[i];
++            envname.erase(envname.find('='));
++            copyEnv(envname, env);
++        }
++    }
++}
++
++std::shared_ptr<Application::Instance> SystemD::launch(
++    const AppID& appId,
++    const std::string& job,
++    const std::string& instance,
++    const std::vector<Application::URL>& urls,
++    launchMode mode,
++    std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv)
++{
++    if (appId.empty())
++        return {};
++
++    auto registry = registry_.lock();
++    return registry->impl->thread.executeOnThread<std::shared_ptr<instance::SystemD>>(
++        [&]() -> std::shared_ptr<instance::SystemD> {
++            auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry->impl->jobs);
++            std::string appIdStr{appId};
++            g_debug("Initializing params for an new instance::SystemD for: %s", appIdStr.c_str());
++
++            tracepoint(ubuntu_app_launch, libual_start, appIdStr.c_str());
++
++            int timeout = 1;
++            if (ubuntu::app_launch::Registry::Impl::isWatchingAppStarting())
++            {
++                timeout = 0;
++            }
++
++            auto handshake = starting_handshake_start(appIdStr.c_str(), instance.c_str(), timeout);
++            if (handshake == nullptr)
++            {
++                g_warning("Unable to setup starting handshake");
++            }
++
++            /* Figure out the unit name for the job */
++            auto unitname = unitName(SystemD::UnitInfo{appIdStr, job, instance});
++
++            /* Build up our environment */
++            auto env = getenv();
++
++            env.emplace_back(std::make_pair("APP_ID", appIdStr));                           /* Application ID */
++            env.emplace_back(std::make_pair("APP_LAUNCHER_PID", std::to_string(getpid()))); /* Who we are, for bugs */
++
++            copyEnv("DISPLAY", env);
++            for (const auto prefix : {"DBUS_", "MIR_", "QT_", "UBUNTU_", "UNITY_", "XDG_"})
++            {
++                copyEnvByPrefix(prefix, env);
++            }
++
++            if (!urls.empty())
++            {
++                auto accumfunc = [](const std::string& prev, Application::URL thisurl) -> std::string {
++                    gchar* gescaped = g_shell_quote(thisurl.value().c_str());
++                    std::string escaped;
++                    if (gescaped != nullptr)
++                    {
++                        escaped = gescaped;
++                        g_free(gescaped);
++                    }
++                    else
++                    {
++                        g_warning("Unable to escape URL: %s", thisurl.value().c_str());
++                        return prev;
++                    }
++
++                    if (prev.empty())
++                    {
++                        return escaped;
++                    }
++                    else
++                    {
++                        return prev + " " + escaped;
++                    }
++                };
++                auto urlstring = std::accumulate(urls.begin(), urls.end(), std::string{}, accumfunc);
++                env.emplace_back(std::make_pair("APP_URIS", urlstring));
++            }
++
++            if (mode == launchMode::TEST)
++            {
++                env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
++            }
++
++            /* Convert to GVariant */
++            GVariantBuilder builder;
++            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
++
++            g_variant_builder_add_value(&builder, g_variant_new_string(unitname.c_str()));
++            g_variant_builder_add_value(&builder, g_variant_new_string("replace"));  // Job mode
++
++            /* Parameter Array */
++            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
++
++            /* ExecStart */
++            auto commands = parseExec(env);
++            if (!commands.empty())
++            {
++                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
++                g_variant_builder_add_value(&builder, g_variant_new_string("ExecStart"));
++                g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
++                g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
++
++                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
++
++                gchar* pathexec = g_find_program_in_path(commands[0].c_str());
++                if (pathexec != nullptr)
++                {
++                    g_variant_builder_add_value(&builder, g_variant_new_take_string(pathexec));
++                }
++                else
++                {
++                    g_debug("Unable to find '%s' in PATH=%s", commands[0].c_str(), g_getenv("PATH"));
++                    g_variant_builder_add_value(&builder, g_variant_new_string(commands[0].c_str()));
++                }
++
++                g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
++                for (const auto& param : commands)
++                {
++                    g_variant_builder_add_value(&builder, g_variant_new_string(param.c_str()));
++                }
++                g_variant_builder_close(&builder);
++
++                g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE));
++
++                g_variant_builder_close(&builder);
++                g_variant_builder_close(&builder);
++                g_variant_builder_close(&builder);
++                g_variant_builder_close(&builder);
++            }
++
++            /* RemainAfterExit */
++            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
++            g_variant_builder_add_value(&builder, g_variant_new_string("RemainAfterExit"));
++            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
++            g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE));
++            g_variant_builder_close(&builder);
++            g_variant_builder_close(&builder);
++
++            /* Type */
++            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
++            g_variant_builder_add_value(&builder, g_variant_new_string("Type"));
++            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
++            g_variant_builder_add_value(&builder, g_variant_new_string("oneshot"));
++            g_variant_builder_close(&builder);
++            g_variant_builder_close(&builder);
++
++            /* Working Directory */
++            if (!findEnv("APP_DIR", env).empty())
++            {
++                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
++                g_variant_builder_add_value(&builder, g_variant_new_string("WorkingDirectory"));
++                g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
++                g_variant_builder_add_value(&builder, g_variant_new_string(findEnv("APP_DIR", env).c_str()));
++                g_variant_builder_close(&builder);
++                g_variant_builder_close(&builder);
++            }
++
++            /* Clean up env before shipping it */
++            for (const auto rmenv :
++                 {"APP_XMIR_ENABLE", "APP_DIR", "APP_URIS", "APP_EXEC", "APP_EXEC_POLICY", "APP_LAUNCHER_PID",
++                  "INSTANCE_ID", "MIR_SERVER_PLATFORM_PATH", "MIR_SERVER_PROMPT_FILE", "MIR_SERVER_HOST_SOCKET",
++                  "UBUNTU_APP_LAUNCH_DEMANGLER", "UBUNTU_APP_LAUNCH_OOM_HELPER", "UBUNTU_APP_LAUNCH_LEGACY_ROOT",
++                  "UBUNTU_APP_LAUNCH_XMIR_HELPER"})
++            {
++                removeEnv(rmenv, env);
++            }
++
++            g_debug("Environment length: %d", envSize(env));
++
++            /* Environment */
++            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
++            g_variant_builder_add_value(&builder, g_variant_new_string("Environment"));
++            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
++            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
++            for (const auto& envvar : env)
++            {
++                if (!envvar.first.empty() && !envvar.second.empty())
++                {
++                    g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf(
++                                                              "%s=%s", envvar.first.c_str(), envvar.second.c_str())));
++                    // g_debug("Setting environment: %s=%s", envvar.first.c_str(), envvar.second.c_str());
++                }
++            }
++
++            g_variant_builder_close(&builder);
++            g_variant_builder_close(&builder);
++            g_variant_builder_close(&builder);
++
++            /* Parameter Array */
++            g_variant_builder_close(&builder);
++
++            /* Dependent Units (none) */
++            g_variant_builder_add_value(&builder, g_variant_new_array(G_VARIANT_TYPE("(sa(sv))"), nullptr, 0));
++
++            auto retval = std::make_shared<instance::SystemD>(appId, job, instance, urls, registry);
++            auto chelper = new StartCHelper{};
++            chelper->ptr = retval;
++            chelper->bus = registry->impl->_dbus;
++
++            tracepoint(ubuntu_app_launch, handshake_wait, appIdStr.c_str());
++            starting_handshake_wait(handshake);
++            tracepoint(ubuntu_app_launch, handshake_complete, appIdStr.c_str());
++
++            /* Call the job start function */
++            g_debug("Asking systemd to start task for: %s", appIdStr.c_str());
++            g_dbus_connection_call(manager->userbus_.get(),                       /* bus */
++                                   SYSTEMD_DBUS_ADDRESS,                          /* service name */
++                                   SYSTEMD_DBUS_PATH_MANAGER,                     /* Path */
++                                   SYSTEMD_DBUS_IFACE_MANAGER,                    /* interface */
++                                   "StartTransientUnit",                          /* method */
++                                   g_variant_builder_end(&builder),               /* params */
++                                   G_VARIANT_TYPE("(o)"),                         /* return */
++                                   G_DBUS_CALL_FLAGS_NONE,                        /* flags */
++                                   -1,                                            /* default timeout */
++                                   registry->impl->thread.getCancellable().get(), /* cancellable */
++                                   application_start_cb,                          /* callback */
++                                   chelper                                        /* object */
++                                   );
++
++            tracepoint(ubuntu_app_launch, libual_start_message_sent, appIdStr.c_str());
++
++            return retval;
++        });
++}
++
++std::shared_ptr<Application::Instance> SystemD::existing(const AppID& appId,
++                                                         const std::string& job,
++                                                         const std::string& instance,
++                                                         const std::vector<Application::URL>& urls)
++{
++    return std::make_shared<instance::SystemD>(appId, job, instance, urls, registry_.lock());
++}
++
++std::vector<std::shared_ptr<instance::Base>> SystemD::instances(const AppID& appID, const std::string& job)
++{
++    std::vector<std::shared_ptr<instance::Base>> instances;
++    std::vector<Application::URL> urls;
++    auto registry = registry_.lock();
++
++    if (!registry)
++    {
++        g_warning("Unable to list instances without a registry");
++        return {};
++    }
++
++    std::string sappid{appID};
++    for (const auto& unit : unitPaths)
++    {
++        const SystemD::UnitInfo& unitinfo = unit.first;
++
++        if (job != unitinfo.job)
++        {
++            continue;
++        }
++
++        if (sappid != unitinfo.appid)
++        {
++            continue;
++        }
++
++        instances.emplace_back(std::make_shared<instance::SystemD>(appID, job, unitinfo.inst, urls, registry));
++    }
++
++    g_debug("Found %d instances for AppID '%s'", int(instances.size()), std::string(appID).c_str());
++
++    return instances;
++}
++
++std::list<std::shared_ptr<Application>> SystemD::runningApps()
++{
++    auto registry = registry_.lock();
++
++    if (!registry)
++    {
++        g_warning("Unable to list instances without a registry");
++        return {};
++    }
++
++    auto allJobs = getAllJobs();
++    std::set<std::string> appids;
++
++    for (const auto& unit : unitPaths)
++    {
++        const SystemD::UnitInfo& unitinfo = unit.first;
++
++        if (allJobs.find(unitinfo.job) == allJobs.end())
++        {
++            continue;
++        }
++
++        appids.insert(unitinfo.appid);
++    }
++
++    std::list<std::shared_ptr<Application>> apps;
++    for (const auto& appid : appids)
++    {
++        auto id = AppID::find(registry, appid);
++        if (id.empty())
++        {
++            g_debug("Unable to handle AppID: %s", appid.c_str());
++            continue;
++        }
++
++        apps.emplace_back(Application::create(id, registry));
++    }
++
++    return apps;
++}
++
++std::string SystemD::userBusPath()
++{
++    auto cpath = getenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH");
++    if (cpath != nullptr)
++    {
++        return cpath;
++    }
++    return std::string{"/run/user/"} + std::to_string(getuid()) + std::string{"/bus"};
++}
++
++/* TODO: Application job names */
++const std::regex unitNaming{
++    "^ubuntu\\-app\\-launch\\-(application\\-(?:click|legacy|snap))\\-(.*)\\-([0-9]*)\\.service$"};
++
++SystemD::UnitInfo SystemD::parseUnit(const std::string& unit) const
++{
++    std::smatch match;
++    if (!std::regex_match(unit, match, unitNaming))
++    {
++        throw std::runtime_error{"Unable to parse unit name: " + unit};
++    }
++
++    return {match[2].str(), match[1].str(), match[3].str()};
++}
++
++std::string SystemD::unitName(const SystemD::UnitInfo& info) const
++{
++    return std::string{"ubuntu-app-launch-"} + info.job + "-" + info.appid + "-" + info.inst + ".service";
++}
++
++std::string SystemD::unitPath(const SystemD::UnitInfo& info)
++{
++    auto data = unitPaths[info];
++
++    if (!data)
++    {
++        return {};
++    }
++
++    auto registry = registry_.lock();
++
++    if (!registry)
++    {
++        g_warning("Unable to get registry to determine path");
++        return {};
++    }
++
++    /* Execute on the thread so that we're sure that we're not in
++       a dbus call to get the value. No racey for you! */
++    return registry->impl->thread.executeOnThread<std::string>([&data]() { return data->unitpath; });
++}
++
++SystemD::UnitInfo SystemD::unitNew(const std::string& name,
++                                   const std::string& path,
++                                   const std::shared_ptr<GDBusConnection>& bus)
++{
++    if (path == "/")
++    {
++        throw std::runtime_error{"Job path for unit is '/' so likely failed"};
++    }
++
++    g_debug("New Unit: %s", name.c_str());
++
++    auto info = parseUnit(name);
++
++    auto data = std::make_shared<UnitData>();
++    data->jobpath = path;
++
++    /* We already have this one, continue on */
++    if (!unitPaths.insert(std::make_pair(info, data)).second)
++    {
++        throw std::runtime_error{"Duplicate unit, not really new"};
++    }
++
++    /* We need to get the path, we're blocking everyone else on
++       this call if they try to get the path. But we're just locking
++       up the UAL thread so it should be a big deal. But if someone
++       comes an asking at this point we'll think that we have the
++       app, but not yet its path */
++    GError* error{nullptr};
++    auto reg = registry_.lock();
++
++    if (!reg)
++    {
++        g_warning("Unable to get SystemD unit path for '%s': Registry out of scope", name.c_str());
++        throw std::runtime_error{"Unable to get SystemD unit path for '" + name + "': Registry out of scope"};
++    }
++
++    GVariant* call = g_dbus_connection_call_sync(bus.get(),                                /* user bus */
++                                                 SYSTEMD_DBUS_ADDRESS,                     /* bus name */
++                                                 SYSTEMD_DBUS_PATH_MANAGER,                /* path */
++                                                 SYSTEMD_DBUS_IFACE_MANAGER,               /* interface */
++                                                 "GetUnit",                                /* method */
++                                                 g_variant_new("(s)", name.c_str()),       /* params */
++                                                 G_VARIANT_TYPE("(o)"),                    /* ret type */
++                                                 G_DBUS_CALL_FLAGS_NONE,                   /* flags */
++                                                 -1,                                       /* timeout */
++                                                 reg->impl->thread.getCancellable().get(), /* cancellable */
++                                                 &error);
++
++    if (error != nullptr)
++    {
++        std::string message = "Unable to get SystemD unit path for '" + name + "': " + error->message;
++        g_error_free(error);
++        throw std::runtime_error{message};
++    }
++
++    /* Parse variant */
++    gchar* gpath = nullptr;
++    g_variant_get(call, "(o)", &gpath);
++    if (gpath != nullptr)
++    {
++        data->unitpath = gpath;
++    }
++
++    g_clear_pointer(&call, g_variant_unref);
++
++    return info;
++}
++
++void SystemD::unitRemoved(const std::string& name, const std::string& path)
++{
++    UnitInfo info = parseUnit(name);
++
++    auto it = unitPaths.find(info);
++    if (it != unitPaths.end())
++    {
++        unitPaths.erase(it);
++        emitSignal(sig_appStopped, info);
++    }
++}
++
++void SystemD::emitSignal(
++    core::Signal<const std::shared_ptr<Application>&, const std::shared_ptr<Application::Instance>&>& sig,
++    UnitInfo& info)
++{
++    auto reg = registry_.lock();
++    if (!reg)
++    {
++        g_warning("Unable to emit systemd signal, invalid registry");
++        return;
++    }
++
++    auto appid = AppID::find(reg, info.appid);
++    auto app = Application::create(appid, reg);
++    auto inst = std::dynamic_pointer_cast<app_impls::Base>(app)->findInstance(info.inst);
++
++    sig(app, inst);
++}
++
++pid_t SystemD::unitPrimaryPid(const AppID& appId, const std::string& job, const std::string& instance)
++{
++    auto registry = registry_.lock();
++
++    if (!registry)
++    {
++        g_warning("Unable to get registry to determine primary PID");
++        return 0;
++    }
++
++    auto unitinfo = SystemD::UnitInfo{appId, job, instance};
++    auto unitname = unitName(unitinfo);
++    auto unitpath = unitPath(unitinfo);
++
++    if (unitpath.empty())
++    {
++        return 0;
++    }
++
++    return registry->impl->thread.executeOnThread<pid_t>([this, registry, unitname, unitpath]() {
++        GError* error{nullptr};
++        GVariant* call =
++            g_dbus_connection_call_sync(userbus_.get(),                                               /* user bus */
++                                        SYSTEMD_DBUS_ADDRESS,                                         /* bus name */
++                                        unitpath.c_str(),                                             /* path */
++                                        "org.freedesktop.DBus.Properties",                            /* interface */
++                                        "Get",                                                        /* method */
++                                        g_variant_new("(ss)", SYSTEMD_DBUS_IFACE_SERVICE, "MainPID"), /* params */
++                                        G_VARIANT_TYPE("(v)"),                                        /* ret type */
++                                        G_DBUS_CALL_FLAGS_NONE,                                       /* flags */
++                                        -1,                                                           /* timeout */
++                                        registry->impl->thread.getCancellable().get(),                /* cancellable */
++                                        &error);
++
++        if (error != nullptr)
++        {
++            auto message =
++                std::string{"Unable to get SystemD PID for '"} + unitname + std::string{"': "} + error->message;
++            g_error_free(error);
++            throw std::runtime_error(message);
++        }
++
++        /* Parse variant */
++        GVariant* vpid{nullptr};
++        g_variant_get(call, "(v)", &vpid);
++        g_clear_pointer(&call, g_variant_unref);
++
++        pid_t pid;
++        pid = g_variant_get_uint32(vpid);
++        g_clear_pointer(&vpid, g_variant_unref);
++
++        return pid;
++    });
++}
++
++std::vector<pid_t> SystemD::unitPids(const AppID& appId, const std::string& job, const std::string& instance)
++{
++    auto registry = registry_.lock();
++
++    if (!registry)
++    {
++        g_warning("Unable to get registry to determine primary PID");
++        return {};
++    }
++
++    auto unitinfo = SystemD::UnitInfo{appId, job, instance};
++    auto unitname = unitName(unitinfo);
++    auto unitpath = unitPath(unitinfo);
++
++    if (unitpath.empty())
++    {
++        return {};
++    }
++
++    auto cgrouppath = registry->impl->thread.executeOnThread<std::string>([this, registry, unitname, unitpath]() {
++        GError* error{nullptr};
++        GVariant* call =
++            g_dbus_connection_call_sync(userbus_.get(),                    /* user bus */
++                                        SYSTEMD_DBUS_ADDRESS,              /* bus name */
++                                        unitpath.c_str(),                  /* path */
++                                        "org.freedesktop.DBus.Properties", /* interface */
++                                        "Get",                             /* method */
++                                        g_variant_new("(ss)", SYSTEMD_DBUS_IFACE_SERVICE, "ControlGroup"), /* params */
++                                        G_VARIANT_TYPE("(v)"),                         /* ret type */
++                                        G_DBUS_CALL_FLAGS_NONE,                        /* flags */
++                                        -1,                                            /* timeout */
++                                        registry->impl->thread.getCancellable().get(), /* cancellable */
++                                        &error);
++
++        if (error != nullptr)
++        {
++            auto message = std::string{"Unable to get SystemD Control Group for '"} + unitname + std::string{"': "} +
++                           error->message;
++            g_error_free(error);
++            throw std::runtime_error(message);
++        }
++
++        /* Parse variant */
++        GVariant* vstring = nullptr;
++        g_variant_get(call, "(v)", &vstring);
++        g_clear_pointer(&call, g_variant_unref);
++
++        if (vstring == nullptr)
++        {
++            return std::string{};
++        }
++
++        std::string group;
++        auto ggroup = g_variant_get_string(vstring, nullptr);
++        if (ggroup != nullptr)
++        {
++            group = ggroup;
++        }
++        g_variant_unref(vstring);
++
++        return group;
++    });
++
++    gchar* fullpath = g_build_filename(cgroup_root_.c_str(), cgrouppath.c_str(), "tasks", nullptr);
++    gchar* pidstr = nullptr;
++    GError* error = nullptr;
++
++    g_debug("Getting PIDs from %s", fullpath);
++    g_file_get_contents(fullpath, &pidstr, nullptr, &error);
++    g_free(fullpath);
++
++    if (error != nullptr)
++    {
++        g_warning("Unable to read cgroup PID list: %s", error->message);
++        g_error_free(error);
++        return {};
++    }
++
++    gchar** pidlines = g_strsplit(pidstr, "\n", -1);
++    g_free(pidstr);
++    std::vector<pid_t> pids;
++
++    for (auto i = 0; pidlines[i] != nullptr; i++)
++    {
++        const gchar* pidline = pidlines[i];
++        if (pidline[0] != '\n')
++        {
++            auto pid = std::atoi(pidline);
++            if (pid != 0)
++            {
++                pids.emplace_back(pid);
++            }
++        }
++    }
++
++    g_strfreev(pidlines);
++
++    return pids;
++}
++
++void SystemD::stopUnit(const AppID& appId, const std::string& job, const std::string& instance)
++{
++    auto registry = registry_.lock();
++    auto unitname = unitName(SystemD::UnitInfo{appId, job, instance});
++
++    registry->impl->thread.executeOnThread<bool>([this, registry, unitname] {
++        GError* error{nullptr};
++        GVariant* call = g_dbus_connection_call_sync(
++            userbus_.get(),             /* user bus */
++            SYSTEMD_DBUS_ADDRESS,       /* bus name */
++            SYSTEMD_DBUS_PATH_MANAGER,  /* path */
++            SYSTEMD_DBUS_IFACE_MANAGER, /* interface */
++            "StopUnit",                 /* method */
++            g_variant_new(
++                "(ss)",                  /* params */
++                unitname.c_str(),        /* param: specify unit */
++                "replace-irreversibly"), /* param: replace the current job but don't allow us to be replaced */
++            G_VARIANT_TYPE("(o)"),       /* ret type */
++            G_DBUS_CALL_FLAGS_NONE,      /* flags */
++            -1,                          /* timeout */
++            registry->impl->thread.getCancellable().get(), /* cancellable */
++            &error);
++
++        if (error != nullptr)
++        {
++            auto message =
++                std::string{"Unable to get SystemD to stop '"} + unitname + std::string{"': "} + error->message;
++            g_error_free(error);
++            throw std::runtime_error(message);
++        }
++
++        g_clear_pointer(&call, g_variant_unref);
++
++        return true;
++    });
++}
++
++core::Signal<const std::shared_ptr<Application>&, const std::shared_ptr<Application::Instance>&>& SystemD::appStarted()
++{
++    /* For systemd we're automatically listening to the UnitNew signal
++       and emitting on the object */
++    return sig_appStarted;
++}
++
++core::Signal<const std::shared_ptr<Application>&, const std::shared_ptr<Application::Instance>&>& SystemD::appStopped()
++{
++    /* For systemd we're automatically listening to the UnitRemoved signal
++       and emitting on the object */
++    return sig_appStopped;
++}
++
++struct FailedData
++{
++    std::weak_ptr<Registry> registry;
++};
++
++core::Signal<const std::shared_ptr<Application>&, const std::shared_ptr<Application::Instance>&, Registry::FailureType>&
++    SystemD::appFailed()
++{
++    std::call_once(flag_appFailed, [this]() {
++        auto reg = registry_.lock();
++
++        reg->impl->thread.executeOnThread<bool>([this, reg]() {
++            auto data = new FailedData{reg};
++
++            handle_appFailed = g_dbus_connection_signal_subscribe(
++                userbus_.get(),                    /* bus */
++                SYSTEMD_DBUS_ADDRESS,              /* sender */
++                "org.freedesktop.DBus.Properties", /* interface */
++                "PropertiesChanged",               /* signal */
++                nullptr,                           /* path */
++                SYSTEMD_DBUS_IFACE_SERVICE,        /* arg0 */
++                G_DBUS_SIGNAL_FLAGS_NONE,
++                [](GDBusConnection*, const gchar*, const gchar* path, const gchar*, const gchar*, GVariant* params,
++                   gpointer user_data) -> void {
++                    auto data = static_cast<FailedData*>(user_data);
++                    auto reg = data->registry.lock();
++
++                    if (!reg)
++                    {
++                        g_warning("Registry object invalid!");
++                        return;
++                    }
++
++                    auto manager = std::dynamic_pointer_cast<SystemD>(reg->impl->jobs);
++
++                    /* Check to see if this is a path we care about */
++                    bool pathfound{false};
++                    UnitInfo unitinfo;
++                    for (const auto& unit : manager->unitPaths)
++                    {
++                        if (unit.second->unitpath == path)
++                        {
++                            pathfound = true;
++                            unitinfo = unit.first;
++                            break;
++                        }
++                    }
++                    if (!pathfound)
++                    {
++                        return;
++                    }
++
++                    /* Now see if it is a property we care about */
++                    auto vdict = g_variant_get_child_value(params, 1);
++                    GVariantDict dict;
++                    g_variant_dict_init(&dict, vdict);
++                    g_clear_pointer(&vdict, g_variant_unref);
++
++                    if (g_variant_dict_contains(&dict, "Result") == FALSE)
++                    {
++                        /* We don't care about anything else */
++                        g_variant_dict_clear(&dict);
++                        return;
++                    }
++
++                    /* Check to see if it just was successful */
++                    const gchar* value{nullptr};
++                    g_variant_dict_lookup(&dict, "Result", "&s", &value);
++
++                    if (g_strcmp0(value, "success") == 0)
++                    {
++                        g_variant_dict_clear(&dict);
++                        return;
++                    }
++                    g_variant_dict_clear(&dict);
++
++                    /* Oh, we might want to do something now */
++                    auto reason{Registry::FailureType::CRASH};
++                    if (g_strcmp0(value, "exit-code") == 0)
++                    {
++                        reason = Registry::FailureType::START_FAILURE;
++                    }
++
++                    auto appid = AppID::find(reg, unitinfo.appid);
++                    auto app = Application::create(appid, reg);
++                    auto inst = std::dynamic_pointer_cast<app_impls::Base>(app)->findInstance(unitinfo.inst);
++
++                    manager->sig_appFailed(app, inst, reason);
++                },    /* callback */
++                data, /* user data */
++                [](gpointer user_data) {
++                    auto data = static_cast<FailedData*>(user_data);
++                    delete data;
++                }); /* user data destroy */
++
++            return true;
++        });
++    });
++
++    return sig_appFailed;
++}
++
++}  // namespace manager
++}  // namespace jobs
++}  // namespace app_launch
++}  // namespace ubuntu
 === added file 'libubuntu-app-launch/jobs-systemd.h'
 --- libubuntu-app-launch/jobs-systemd.h	1970-01-01 00:00:00 +0000
 +++ libubuntu-app-launch/jobs-systemd.h	2017-02-01 20:34:54 +0000
@@ -0,0 +1,136 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#pragma once
++
++#include "jobs-base.h"
++#include <chrono>
++#include <future>
++#include <gio/gio.h>
++#include <map>
++#include <mutex>
++
++namespace ubuntu
++{
++namespace app_launch
++{
++namespace jobs
++{
++namespace manager
++{
++
++class SystemD : public Base
++{
++public:
++    SystemD(std::shared_ptr<Registry> registry);
++    virtual ~SystemD();
++
++    virtual std::shared_ptr<Application::Instance> launch(
++        const AppID& appId,
++        const std::string& job,
++        const std::string& instance,
++        const std::vector<Application::URL>& urls,
++        launchMode mode,
++        std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv) override;
++    virtual std::shared_ptr<Application::Instance> existing(const AppID& appId,
++                                                            const std::string& job,
++                                                            const std::string& instance,
++                                                            const std::vector<Application::URL>& urls) override;
++
++    virtual std::list<std::shared_ptr<Application>> runningApps() override;
++
++    virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) override;
++
++    virtual core::Signal<const std::shared_ptr<Application>&, const std::shared_ptr<Application::Instance>&>&
++        appStarted() override;
++    virtual core::Signal<const std::shared_ptr<Application>&, const std::shared_ptr<Application::Instance>&>&
++        appStopped() override;
++    virtual core::Signal<const std::shared_ptr<Application>&,
++                         const std::shared_ptr<Application::Instance>&,
++                         Registry::FailureType>&
++        appFailed() override;
++
++    static std::string userBusPath();
++
++    pid_t unitPrimaryPid(const AppID& appId, const std::string& job, const std::string& instance);
++    std::vector<pid_t> unitPids(const AppID& appId, const std::string& job, const std::string& instance);
++    void stopUnit(const AppID& appId, const std::string& job, const std::string& instance);
++
++private:
++    std::string cgroup_root_;
++    std::shared_ptr<GDBusConnection> userbus_;
++
++    guint handle_unitNew{0};     /**< GDBus signal watcher handle for the unit new signal */
++    guint handle_unitRemoved{0}; /**< GDBus signal watcher handle for the unit removed signal */
++    guint handle_appFailed{0};   /**< GDBus signal watcher handle for app failed signal */
++
++    std::once_flag
++        flag_appFailed; /**< Variable to track to see if signal handlers are installed for application failed */
++
++    struct UnitInfo
++    {
++        std::string appid;
++        std::string job;
++        std::string inst;
++
++        bool operator<(const UnitInfo& b) const
++        {
++            if (job != b.job)
++                return job < b.job;
++
++            if (appid != b.appid)
++                return appid < b.appid;
++
++            return inst < b.inst;
++        }
++    };
++
++    void getInitialUnits(const std::shared_ptr<GDBusConnection>& bus, const std::shared_ptr<GCancellable>& cancel);
++
++    struct UnitData
++    {
++        std::string jobpath;
++        std::string unitpath;
++    };
++
++    std::map<UnitInfo, std::shared_ptr<UnitData>> unitPaths;
++    UnitInfo parseUnit(const std::string& unit) const;
++    std::string unitName(const UnitInfo& info) const;
++    std::string unitPath(const UnitInfo& info);
++
++    UnitInfo unitNew(const std::string& name, const std::string& path, const std::shared_ptr<GDBusConnection>& bus);
++    void unitRemoved(const std::string& name, const std::string& path);
++    void emitSignal(
++        core::Signal<const std::shared_ptr<Application>&, const std::shared_ptr<Application::Instance>&>& sig,
++        UnitInfo& info);
++
++    static std::string findEnv(const std::string& value, std::list<std::pair<std::string, std::string>>& env);
++    static void removeEnv(const std::string& value, std::list<std::pair<std::string, std::string>>& env);
++    static void copyEnv(const std::string& envname, std::list<std::pair<std::string, std::string>>& env);
++    static void copyEnvByPrefix(const std::string& prefix, std::list<std::pair<std::string, std::string>>& env);
++    static int envSize(std::list<std::pair<std::string, std::string>>& env);
++
++    static std::vector<std::string> parseExec(std::list<std::pair<std::string, std::string>>& env);
++    static void application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data);
++};
++
++}  // namespace manager
++}  // namespace jobs
++}  // namespace app_launch
++}  // namespace ubuntu
 === modified file 'libubuntu-app-launch/jobs-upstart.cpp'
 --- libubuntu-app-launch/jobs-upstart.cpp	2017-01-11 22:28:11 +0000
 +++ libubuntu-app-launch/jobs-upstart.cpp	2017-02-01 20:34:54 +0000
@@ -84,8 +84,6 @@
                                           const AppID& appid,
                                           const std::string& jobpath,
                                           std::function<void(pid_t)> eachPid);
--
--    static std::shared_ptr<gchar*> urlsToStrv(const std::vector<Application::URL>& urls);
  };
  /** Uses Upstart to get the primary PID of the instance using Upstart's
@@ -317,29 +315,6 @@
      g_debug("Creating a new Upstart for '%s' instance '%s'", std::string(appId).c_str(), instance.c_str());
+ }
--/** Reformat a C++ vector of URLs into a C GStrv of strings
--
--    \param urls Vector of URLs to make into C strings
--*/
--std::shared_ptr<gchar*> Upstart::urlsToStrv(const std::vector<Application::URL>& urls)
--{
--    if (urls.empty())
--    {
--        return {};
--    }
--
--    auto array = g_array_new(TRUE, FALSE, sizeof(gchar*));
--
--    for (auto url : urls)
--    {
--        auto str = g_strdup(url.value().c_str());
--        g_debug("Converting URL: %s", str);
--        g_array_append_val(array, str);
--    }
--
--    return std::shared_ptr<gchar*>((gchar**)g_array_free(array, FALSE), g_strfreev);
--}
--
  /** Small helper that we can new/delete to work better with C stuff */
  struct StartCHelper
+ {
 === modified file 'libubuntu-app-launch/registry-impl.cpp'
 --- libubuntu-app-launch/registry-impl.cpp	2017-01-11 22:16:14 +0000
 +++ libubuntu-app-launch/registry-impl.cpp	2017-02-01 20:34:54 +0000
@@ -132,7 +132,7 @@
          if (error != nullptr)
+         {
              auto perror = std::shared_ptr<GError>(error, [](GError* error) { g_error_free(error); });
--            g_critical("Error parsing manifest for package '%s': %s", package.c_str(), perror->message);
++            g_debug("Error parsing manifest for package '%s': %s", package.c_str(), perror->message);
              return std::shared_ptr<JsonObject>();
+         }
 === modified file 'libubuntu-app-launch/snapd-info.cpp'
 --- libubuntu-app-launch/snapd-info.cpp	2016-11-09 22:24:10 +0000
 +++ libubuntu-app-launch/snapd-info.cpp	2017-02-01 20:34:54 +0000
@@ -170,7 +170,7 @@
+     }
      catch (std::runtime_error &e)
+     {
--        g_warning("Unable to get snap information for '%s': %s", package.value().c_str(), e.what());
++        g_debug("Unable to get snap information for '%s': %s", package.value().c_str(), e.what());
          return {};
+     }
+ }
 === modified file 'tests/CMakeLists.txt'
 --- tests/CMakeLists.txt	2017-01-11 23:13:23 +0000
 +++ tests/CMakeLists.txt	2017-02-01 20:34:54 +0000
@@ -67,6 +67,14 @@
  add_test(NAME jobs-base-test COMMAND jobs-base-test)
++# Jobs Systemd Test
++
++add_executable (jobs-systemd
++	jobs-systemd.cpp)
++target_link_libraries (jobs-systemd ${GMOCK_LIBRARIES} launcher-static ${DBUSTEST_LIBRARIES})
++
++add_test(NAME jobs-systemd COMMAND jobs-systemd)
++
  # Snapd Info Test
  if(CURL_FOUND)
@@ -167,8 +175,11 @@
  	list-apps.cpp
  	eventually-fixture.h
  	jobs-base-test.cpp
++	jobs-systemd.cpp
++	registry-mock.h
  	snapd-info-test.cpp
  	snapd-mock.h
  	spew-master.h
++	systemd-mock.h
  	zg-test.cc
+ )
 === modified file 'tests/eventually-fixture.h'
 --- tests/eventually-fixture.h	2017-01-11 23:13:23 +0000
 +++ tests/eventually-fixture.h	2017-02-01 20:34:54 +0000
@@ -27,6 +27,7 @@
+ {
  protected:
      std::chrono::milliseconds _eventuallyTime = std::chrono::minutes{1};
++    std::once_flag checkEventuallyEnv_;
      static gboolean timeout_cb(gpointer user_data)
+     {
@@ -45,6 +46,14 @@
      testing::AssertionResult eventuallyLoop(std::function<testing::AssertionResult(void)> &testfunc)
+     {
++        std::call_once(checkEventuallyEnv_, [this]() {
++            auto eventuallyenv = getenv("EVENTUALLY_TIMEOUT");
++            if (eventuallyenv != nullptr)
++            {
++                _eventuallyTime = std::chrono::seconds{std::atoi(eventuallyenv)};
++            }
++        });
++
          auto loop = std::shared_ptr<GMainLoop>(g_main_loop_new(nullptr, FALSE),
                                                 [](GMainLoop *loop) { g_clear_pointer(&loop, g_main_loop_unref); });
 === modified file 'tests/exec-util-test.cc'
 --- tests/exec-util-test.cc	2017-01-19 03:23:54 +0000
 +++ tests/exec-util-test.cc	2017-02-01 20:34:54 +0000
@@ -50,6 +50,7 @@
  			g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
  			g_setenv("UBUNTU_APP_LAUNCH_LIBERTINE_LAUNCH", "libertine-launch", TRUE);
  			g_setenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET", "/this/should/not/exist", TRUE);
++			g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
  			service = dbus_test_service_new(NULL);
@@ -184,12 +185,15 @@
  			EXPECT_STREQ("grep", value); }},
  		{"APP_ID", [](const gchar * value) {
  			EXPECT_STREQ("com.test.good_application_1.2.3", value); }},
++		{"APP_EXEC_POLICY", [](const gchar * value) {
++			EXPECT_STREQ("com.test.good_application_1.2.3", value); }},
  		{"APP_LAUNCHER_PID", [](const gchar * value) {
  			EXPECT_EQ(getpid(), atoi(value)); }},
  		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
  			EXPECT_STREQ(APP_DIR "/application.desktop", value); }},
  		{"APP_XMIR_ENABLE", [](const gchar * value) {
  			EXPECT_STREQ("0", value); }},
++		{"QML2_IMPORT_PATH", nocheck},
  	});
  #undef APP_DIR
@@ -267,10 +271,13 @@
  		{"APP_EXEC", nocheck},
  		{"APP_ID", [](const gchar * value) {
  			EXPECT_STREQ("com.test.mir_mir_1", value); }},
++		{"APP_EXEC_POLICY", [](const gchar * value) {
++			EXPECT_STREQ("com.test.mir_mir_1", value); }},
  		{"APP_LAUNCHER_PID", nocheck},
  		{"APP_DESKTOP_FILE_PATH", nocheck},
  		{"APP_XMIR_ENABLE", [](const gchar * value) {
  			EXPECT_STREQ("1", value); }},
++		{"QML2_IMPORT_PATH", nocheck},
  	});
+ }
@@ -289,10 +296,13 @@
  		{"APP_EXEC", nocheck},
  		{"APP_ID", [](const gchar * value) {
  			EXPECT_STREQ("com.test.mir_nomir_1", value); }},
++		{"APP_EXEC_POLICY", [](const gchar * value) {
++			EXPECT_STREQ("com.test.mir_nomir_1", value); }},
  		{"APP_LAUNCHER_PID", nocheck},
  		{"APP_DESKTOP_FILE_PATH", nocheck},
  		{"APP_XMIR_ENABLE", [](const gchar * value) {
  			EXPECT_STREQ("0", value); }},
++		{"QML2_IMPORT_PATH", nocheck},
  	});
+ }
 === modified file 'tests/failure-test.cc'
 --- tests/failure-test.cc	2017-01-11 05:48:33 +0000
 +++ tests/failure-test.cc	2017-02-01 20:34:54 +0000
@@ -45,6 +45,8 @@
          g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
          g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
++        g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
++
          testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
          g_test_dbus_up(testbus);
 === modified file 'tests/jobs-base-test.cpp'
 --- tests/jobs-base-test.cpp	2017-01-12 17:31:50 +0000
 +++ tests/jobs-base-test.cpp	2017-02-01 20:34:54 +0000
@@ -19,35 +19,14 @@
  #include "appid.h"
  #include "jobs-base.h"
--#include "registry-impl.h"
--#include "registry.h"
  #include "eventually-fixture.h"
++#include "registry-mock.h"
  #include "spew-master.h"
  #include <gmock/gmock.h>
  #include <gtest/gtest.h>
  #include <libdbustest/dbus-test.h>
--class RegistryImplMock : public ubuntu::app_launch::Registry::Impl
--{
--public:
--    RegistryImplMock(ubuntu::app_launch::Registry* reg)
--        : ubuntu::app_launch::Registry::Impl(reg)
--    {
--    }
--
--    MOCK_METHOD2(zgSendEvent, void(ubuntu::app_launch::AppID, const std::string& eventtype));
--};
--
--class RegistryMock : public ubuntu::app_launch::Registry
--{
--public:
--    RegistryMock()
--    {
--        impl = std::unique_ptr<RegistryImplMock>(new RegistryImplMock(this));
--    }
--};
--
  class instanceMock : public ubuntu::app_launch::jobs::instance::Base
+ {
  public:
 === added file 'tests/jobs-systemd.cpp'
 --- tests/jobs-systemd.cpp	1970-01-01 00:00:00 +0000
 +++ tests/jobs-systemd.cpp	2017-02-01 20:34:54 +0000
@@ -0,0 +1,362 @@
++/*
++ * 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 version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#include "jobs-systemd.h"
++
++#include "eventually-fixture.h"
++#include "registry-mock.h"
++#include "systemd-mock.h"
++
++#define CGROUP_DIR (CMAKE_BINARY_DIR "/systemd-cgroups")
++
++class JobsSystemd : public EventuallyFixture
++{
++protected:
++    std::shared_ptr<DbusTestService> service;
++    std::shared_ptr<RegistryMock> registry;
++    std::shared_ptr<SystemdMock> systemd;
++    GDBusConnection *bus = nullptr;
++
++    virtual void SetUp() override
++    {
++        /* Get the applications dir */
++        g_setenv("XDG_DATA_DIRS", CMAKE_SOURCE_DIR, TRUE);
++
++        /* Setting the cgroup temp directory */
++        g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_CGROUP_ROOT", CGROUP_DIR, TRUE);
++
++        /* Force over to session bus */
++        g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
++
++        service = std::shared_ptr<DbusTestService>(dbus_test_service_new(nullptr),
++                                                   [](DbusTestService *service) { g_clear_object(&service); });
++
++        systemd = std::make_shared<SystemdMock>(
++            std::list<SystemdMock::Instance>{
++                {defaultJobName(), std::string{multipleAppID()}, "1234567890", 11, {12, 13, 11}},
++                {defaultJobName(), std::string{multipleAppID()}, "0987654321", 10, {10}},
++                {defaultJobName(), std::string{singleAppID()}, {}, 5, {1, 2, 3, 4, 5}}},
++            CGROUP_DIR);
++        dbus_test_service_add_task(service.get(), *systemd);
++
++        dbus_test_service_start_tasks(service.get());
++        registry = std::make_shared<RegistryMock>();
++
++        bus = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, nullptr);
++        g_dbus_connection_set_exit_on_close(bus, FALSE);
++        g_object_add_weak_pointer(G_OBJECT(bus), (gpointer *)&bus);
++    }
++
++    virtual void TearDown() override
++    {
++        systemd.reset();
++        registry.reset();
++        service.reset();
++
++        g_object_unref(bus);
++        ASSERT_EVENTUALLY_EQ(nullptr, bus);
++    }
++
++    std::string defaultJobName()
++    {
++        return "application-legacy";
++    }
++
++    ubuntu::app_launch::AppID singleAppID()
++    {
++        return {ubuntu::app_launch::AppID::Package::from_raw({}),
++                ubuntu::app_launch::AppID::AppName::from_raw("single"),
++                ubuntu::app_launch::AppID::Version::from_raw({})};
++    }
++
++    ubuntu::app_launch::AppID multipleAppID()
++    {
++        return {ubuntu::app_launch::AppID::Package::from_raw({}),
++                ubuntu::app_launch::AppID::AppName::from_raw("multiple"),
++                ubuntu::app_launch::AppID::Version::from_raw({})};
++    }
++};
++
++/* Make sure we can build an object and destroy it */
++TEST_F(JobsSystemd, Init)
++{
++    registry->impl->jobs = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++}
++
++/* Make sure we make the initial call to get signals and an initial list */
++TEST_F(JobsSystemd, Startup)
++{
++    registry->impl->jobs = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++
++    EXPECT_EVENTUALLY_FUNC_EQ(true, std::function<bool()>([this]() { return systemd->subscribeCallsCnt() > 0; }));
++    EXPECT_EVENTUALLY_FUNC_EQ(true, std::function<bool()>([this]() -> bool { return systemd->listCallsCnt() > 0; }));
++}
++
++std::function<bool(const std::shared_ptr<ubuntu::app_launch::Application> &app)> findAppID(
++    const ubuntu::app_launch::AppID &appid)
++{
++    return [appid](const std::shared_ptr<ubuntu::app_launch::Application> &app) { return appid == app->appId(); };
++}
++
++/* Get the running apps and check out their instances */
++TEST_F(JobsSystemd, RunningApps)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    auto apps = manager->runningApps();
++    ASSERT_FALSE(apps.empty());
++    EXPECT_EQ(2u, apps.size());
++
++    auto single = *std::find_if(apps.begin(), apps.end(), findAppID(singleAppID()));
++    EXPECT_TRUE(bool(single));
++
++    auto multiple = *std::find_if(apps.begin(), apps.end(), findAppID(multipleAppID()));
++    EXPECT_TRUE(bool(multiple));
++
++    auto sinstances = single->instances();
++
++    ASSERT_FALSE(sinstances.empty());
++    EXPECT_EQ(1u, sinstances.size());
++
++    auto minstances = multiple->instances();
++
++    ASSERT_FALSE(minstances.empty());
++    EXPECT_EQ(2u, minstances.size());
++}
++
++/* Check to make sure we're getting the user bus path correctly */
++TEST_F(JobsSystemd, UserBusPath)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    EXPECT_EQ(std::string{"/this/should/not/exist"}, manager->userBusPath());
++
++    unsetenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH");
++    EXPECT_EQ(std::string{"/run/user/"} + std::to_string(getuid()) + std::string{"/bus"}, manager->userBusPath());
++}
++
++/* PID Tools */
++TEST_F(JobsSystemd, PidTools)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    EXPECT_EQ(5, manager->unitPrimaryPid(singleAppID(), defaultJobName(), {}));
++    std::vector<pid_t> pidlist{1, 2, 3, 4, 5};
++    EXPECT_EQ(pidlist, manager->unitPids(singleAppID(), defaultJobName(), {}));
++}
++
++/* PID Instance */
++TEST_F(JobsSystemd, PidInstance)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    auto inst = manager->existing(singleAppID(), defaultJobName(), {}, {});
++    EXPECT_TRUE(bool(inst));
++
++    EXPECT_EQ(5, inst->primaryPid());
++    std::vector<pid_t> pidlist{1, 2, 3, 4, 5};
++    EXPECT_EQ(pidlist, inst->pids());
++}
++
++/* Stopping a Job */
++TEST_F(JobsSystemd, StopUnit)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    manager->stopUnit(singleAppID(), defaultJobName(), {});
++
++    std::list<std::string> stopcalls;
++    EXPECT_EVENTUALLY_FUNC_LT(0u, std::function<unsigned int()>([&]() {
++                                  stopcalls = systemd->stopCalls();
++                                  return stopcalls.size();
++                              }));
++
++    EXPECT_EQ(SystemdMock::instanceName({defaultJobName(), std::string{singleAppID()}, {}, 1, {}}), *stopcalls.begin());
++
++    systemd->managerClear();
++    stopcalls.clear();
++
++    manager->stopUnit(multipleAppID(), defaultJobName(), "1234567890");
++
++    EXPECT_EVENTUALLY_FUNC_LT(0u, std::function<unsigned int()>([&]() {
++                                  stopcalls = systemd->stopCalls();
++                                  return stopcalls.size();
++                              }));
++
++    EXPECT_EQ(SystemdMock::instanceName({defaultJobName(), std::string{multipleAppID()}, "1234567890", 1, {}}),
++              *stopcalls.begin());
++}
++
++/* Stop Instance */
++TEST_F(JobsSystemd, StopInstance)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    auto inst = manager->existing(singleAppID(), defaultJobName(), {}, {});
++    EXPECT_TRUE(bool(inst));
++
++    inst->stop();
++
++    std::list<std::string> stopcalls;
++    EXPECT_EVENTUALLY_FUNC_LT(0u, std::function<unsigned int()>([&]() {
++                                  stopcalls = systemd->stopCalls();
++                                  return stopcalls.size();
++                              }));
++
++    EXPECT_EQ(SystemdMock::instanceName({defaultJobName(), std::string{singleAppID()}, {}, 1, {}}), *stopcalls.begin());
++}
++
++/* Starting a new job */
++TEST_F(JobsSystemd, LaunchJob)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    bool gotenv{false};
++    std::function<std::list<std::pair<std::string, std::string>>()> getenvfunc =
++        [&]() -> std::list<std::pair<std::string, std::string>> {
++        gotenv = true;
++        return {{"APP_EXEC", "sh"}};
++    };
++
++    auto inst = manager->launch(multipleAppID(), defaultJobName(), "123", {},
++                                ubuntu::app_launch::jobs::manager::launchMode::STANDARD, getenvfunc);
++
++    EXPECT_TRUE(bool(inst));
++    EXPECT_TRUE(gotenv);
++
++    /* Check to see that we got called */
++    std::list<SystemdMock::TransientUnit> units;
++    EXPECT_EVENTUALLY_FUNC_LT(0u, std::function<unsigned int()>([&]() {
++                                  units = systemd->unitCalls();
++                                  return units.size();
++                              }));
++
++    /* Make sure it was the right one */
++    EXPECT_EQ(SystemdMock::instanceName({defaultJobName(), std::string{multipleAppID()}, "123", 1, {}}),
++              units.begin()->name);
++
++    /* Check some standard environment variables */
++    EXPECT_NE(units.begin()->environment.end(),
++              units.begin()->environment.find(std::string{"APP_ID="} + std::string(multipleAppID())));
++    EXPECT_NE(
++        units.begin()->environment.end(),
++        units.begin()->environment.find(std::string{"DBUS_SESSION_BUS_ADDRESS="} + getenv("DBUS_SESSION_BUS_ADDRESS")));
++
++    /* Ensure the exec is correct */
++    EXPECT_EQ("/bin/sh", units.begin()->execpath);
++
++    /* Try an entirely custom variable */
++    systemd->managerClear();
++    units.clear();
++
++    std::function<std::list<std::pair<std::string, std::string>>()> arbitraryenvfunc =
++        [&]() -> std::list<std::pair<std::string, std::string>> {
++        return {{"ARBITRARY_KEY", "EVEN_MORE_ARBITRARY_VALUE"}};
++    };
++
++    manager->launch(multipleAppID(), defaultJobName(), "123", {},
++                    ubuntu::app_launch::jobs::manager::launchMode::STANDARD, arbitraryenvfunc);
++
++    EXPECT_EVENTUALLY_FUNC_LT(0u, std::function<unsigned int()>([&]() {
++                                  units = systemd->unitCalls();
++                                  return units.size();
++                              }));
++
++    EXPECT_NE(units.begin()->environment.end(),
++              units.begin()->environment.find("ARBITRARY_KEY=EVEN_MORE_ARBITRARY_VALUE"));
++}
++
++TEST_F(JobsSystemd, SignalNew)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    std::promise<ubuntu::app_launch::AppID> newunit;
++    manager->appStarted().connect([&](const std::shared_ptr<ubuntu::app_launch::Application> &app,
++                                      const std::shared_ptr<ubuntu::app_launch::Application::Instance> &inst) {
++        try
++        {
++            if (!app)
++            {
++                throw std::runtime_error("Invalid Application");
++            }
++
++            if (!inst)
++            {
++                throw std::runtime_error("Invalid Instance");
++            }
++
++            newunit.set_value(app->appId());
++        }
++        catch (...)
++        {
++            newunit.set_exception(std::current_exception());
++        }
++    });
++
++    systemd->managerEmitNew(SystemdMock::instanceName(
++
++                                {defaultJobName(), std::string{multipleAppID()}, "1234", 1, {}}),
++                            "/foo");
++
++    EXPECT_EQ(multipleAppID(), newunit.get_future().get());
++}
++
++TEST_F(JobsSystemd, SignalRemove)
++{
++    auto manager = std::make_shared<ubuntu::app_launch::jobs::manager::SystemD>(registry);
++    registry->impl->jobs = manager;
++
++    std::promise<ubuntu::app_launch::AppID> removeunit;
++    manager->appStopped().connect([&](const std::shared_ptr<ubuntu::app_launch::Application> &app,
++                                      const std::shared_ptr<ubuntu::app_launch::Application::Instance> &inst) {
++        try
++        {
++            if (!app)
++            {
++                throw std::runtime_error("Invalid Application");
++            }
++
++            if (!inst)
++            {
++                throw std::runtime_error("Invalid Instance");
++            }
++
++            removeunit.set_value(app->appId());
++        }
++        catch (...)
++        {
++            removeunit.set_exception(std::current_exception());
++        }
++    });
++
++    systemd->managerEmitRemoved(SystemdMock::instanceName(
++
++                                    {defaultJobName(), std::string{multipleAppID()}, "1234567890", 1, {}}),
++                                "/foo");
++
++    EXPECT_EQ(multipleAppID(), removeunit.get_future().get());
++}
 === modified file 'tests/libual-cpp-test.cc'
 --- tests/libual-cpp-test.cc	2017-01-19 03:24:42 +0000
 +++ tests/libual-cpp-test.cc	2017-02-01 20:34:54 +0000
@@ -157,6 +157,7 @@
          g_setenv("UBUNTU_APP_LAUNCH_DISABLE_SNAPD_TIMEOUT", "You betcha!", TRUE);
          g_unlink(LOCAL_SNAPD_TEST_SOCKET);
  #endif
++        g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
          service = dbus_test_service_new(NULL);
@@ -518,12 +519,12 @@
  /* Snapd mock data */
  static std::pair<std::string, std::string> interfaces{
      "GET /v2/interfaces HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
--    SnapdMock::httpJsonResponse(
--        SnapdMock::snapdOkay(SnapdMock::interfacesJson({{"unity8", "unity8-package", {"foo", "single", "xmir", "noxmir"}}})))};
++    SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
++        SnapdMock::interfacesJson({{"unity8", "unity8-package", {"foo", "single", "xmir", "noxmir"}}})))};
  static std::pair<std::string, std::string> u8Package{
      "GET /v2/snaps/unity8-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
--    SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
--        SnapdMock::packageJson("unity8-package", "active", "app", "1.2.3.4", "x123", {"foo", "single", "xmir", "noxmir"})))};
++    SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(SnapdMock::packageJson(
++        "unity8-package", "active", "app", "1.2.3.4", "x123", {"foo", "single", "xmir", "noxmir"})))};
  TEST_F(LibUAL, ApplicationIdSnap)
+ {
@@ -550,12 +551,12 @@
+ {
      /* Queries come in threes, apparently */
      SnapdMock snapd{LOCAL_SNAPD_TEST_SOCKET,
--            {
--                u8Package, interfaces, u8Package,
--                u8Package, interfaces, u8Package,
--                u8Package, interfaces, u8Package,
--                u8Package, interfaces, u8Package,
--            }};
++                    {
++                        u8Package, interfaces, u8Package, /* App 1 */
++                        u8Package, interfaces, u8Package, /* App 2 */
++                        u8Package, interfaces, u8Package, /* App 3 */
++                        u8Package, interfaces, u8Package, /* App 4 */
++                    }};
      registry = std::make_shared<ubuntu::app_launch::Registry>();
      std::string snapRoot{SNAP_BASEDIR};
 === modified file 'tests/libual-test.cc'
 --- tests/libual-test.cc	2017-01-11 23:22:52 +0000
 +++ tests/libual-test.cc	2017-02-01 20:34:54 +0000
@@ -90,6 +90,7 @@
  			g_setenv("XDG_DATA_HOME",  CMAKE_SOURCE_DIR "/libertine-home", 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);
 === added file 'tests/registry-mock.h'
 --- tests/registry-mock.h	1970-01-01 00:00:00 +0000
 +++ tests/registry-mock.h	2017-02-01 20:34:54 +0000
@@ -0,0 +1,57 @@
++/*
++ * 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 version 3, as published
++ * by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *     Ted Gould <ted.gould@canonical.com>
++ */
++
++#pragma once
++
++#include "registry-impl.h"
++#include "registry.h"
++
++#include <gmock/gmock.h>
++
++class RegistryImplMock : public ubuntu::app_launch::Registry::Impl
++{
++public:
++    RegistryImplMock(ubuntu::app_launch::Registry* reg)
++        : ubuntu::app_launch::Registry::Impl(reg)
++    {
++        g_debug("Registry Mock Implementation Created");
++    }
++
++    ~RegistryImplMock()
++    {
++        g_debug("Registry Mock Implementation taken down");
++    }
++
++    MOCK_METHOD2(zgSendEvent, void(ubuntu::app_launch::AppID, const std::string& eventtype));
++};
++
++class RegistryMock : public ubuntu::app_launch::Registry
++{
++public:
++    RegistryMock()
++    {
++        g_debug("Registry Mock Created");
++        impl = std::unique_ptr<RegistryImplMock>(new RegistryImplMock(this));
++    }
++
++    ~RegistryMock()
++    {
++        g_debug("Registry Mock taken down");
++    }
++};
 === modified file 'tests/spew-master.h'
 --- tests/spew-master.h	2016-12-16 17:23:55 +0000
 +++ tests/spew-master.h	2017-02-01 20:34:54 +0000
@@ -19,6 +19,8 @@
  #pragma once
++#include "glib-thread.h"
++
  class SpewMaster
+ {
  public:
 === added file 'tests/systemd-mock.h'
 --- tests/systemd-mock.h	1970-01-01 00:00:00 +0000
 +++ tests/systemd-mock.h	2017-02-01 20:34:54 +0000
@@ -0,0 +1,481 @@
++/*
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors:
++ *      Ted Gould <ted@canonical.com>
++ */
++
++#include <algorithm>
++#include <future>
++#include <list>
++#include <map>
++#include <memory>
++#include <numeric>
++#include <type_traits>
++
++#include <gio/gio.h>
++
++#include <libdbustest/dbus-test.h>
++
++#include "glib-thread.h"
++
++class SystemdMock
++{
++public:
++    struct Instance
++    {
++        std::string job;
++        std::string appid;
++        std::string instanceid;
++        pid_t primaryPid;
++        std::vector<pid_t> pids;
++    };
++
++private:
++    DbusTestDbusMock* mock = nullptr;
++    DbusTestDbusMockObject* managerobj = nullptr;
++    GLib::ContextThread thread;
++    std::list<std::pair<Instance, DbusTestDbusMockObject*>> insts;
++
++    void throwError(GError* error)
++    {
++        if (error == nullptr)
++        {
++            return;
++        }
++
++        auto message = std::string{"Error in systemd mock: "} + error->message;
++        g_error_free(error);
++        throw std::runtime_error{message};
++    }
++
++public:
++    SystemdMock(const std::list<Instance>& instances, const std::string& controlGroupPath)
++    {
++        GError* error = nullptr;
++        mock = dbus_test_dbus_mock_new("org.freedesktop.systemd1");
++        dbus_test_task_set_bus(DBUS_TEST_TASK(mock), DBUS_TEST_SERVICE_BUS_SESSION);
++        dbus_test_task_set_name(DBUS_TEST_TASK(mock), "systemd");
++
++        managerobj = dbus_test_dbus_mock_get_object(mock, "/org/freedesktop/systemd1",
++                                                    "org.freedesktop.systemd1.Manager", nullptr);
++
++        dbus_test_dbus_mock_object_add_method(mock, managerobj, "Subscribe", nullptr, nullptr, "", nullptr);
++        dbus_test_dbus_mock_object_add_method(
++            mock, managerobj, "ListUnits", nullptr, G_VARIANT_TYPE("(a(ssssssouso))"), /* ret type */
++            ("ret = [ " + std::accumulate(instances.begin(), instances.end(), std::string{},
++                                          [](const std::string accum, const Instance& inst) {
++                                              std::string retval = accum;
++
++                                              if (!retval.empty())
++                                              {
++                                                  retval += ", ";
++                                              }
++
++                                              retval += std::string{"("} +                 /* start tuple */
++                                                        "'" + instanceName(inst) + "', " + /* id */
++                                                        "'unused', " +                     /* description */
++                                                        "'unused', " +                     /* load state */
++                                                        "'unused', " +                     /* active state */
++                                                        "'unused', " +                     /* substate */
++                                                        "'unused', " +                     /* following */
++                                                        "'/unused', " +                    /* path */
++                                                        "5, " +                            /* jobId */
++                                                        "'unused', " +                     /* jobType */
++                                                        "'" + instancePath(inst) + "'" +   /* jobPath */
++                                                        ")";                               /* finish tuple */
++
++                                              return retval;
++                                          }) +
++             "]")
++                .c_str(),
++            &error);
++        throwError(error);
++
++        dbus_test_dbus_mock_object_add_method(
++            mock, managerobj, "GetUnit", G_VARIANT_TYPE_STRING, G_VARIANT_TYPE_OBJECT_PATH, /* ret type */
++            ("ret = '/'\n" + std::accumulate(instances.begin(), instances.end(), std::string{},
++                                             [](const std::string accum, const Instance& inst) {
++                                                 std::string retval = accum;
++
++                                                 retval += "if args[0] == '" + instanceName(inst) + "':\n";
++                                                 retval += "\tret = '" + instancePath(inst) + "'\n";
++
++                                                 return retval;
++                                             }))
++                .c_str(),
++            &error);
++        throwError(error);
++
++        dbus_test_dbus_mock_object_add_method(
++            mock, managerobj, "StopUnit", G_VARIANT_TYPE("(ss)"), G_VARIANT_TYPE_OBJECT_PATH, /* ret type */
++            std::accumulate(instances.begin(), instances.end(), std::string{},
++                            [](const std::string accum, const Instance& inst) {
++                                std::string retval = accum;
++
++                                retval += "if args[0] == '" + instanceName(inst) + "':\n";
++                                retval += "\tret = '" + instancePath(inst) + "'\n";
++
++                                return retval;
++                            })
++                .c_str(),
++            &error);
++        throwError(error);
++
++        dbus_test_dbus_mock_object_add_method(mock, managerobj, "StartTransientUnit",
++                                              G_VARIANT_TYPE("(ssa(sv)a(sa(sv)))"),
++                                              G_VARIANT_TYPE_OBJECT_PATH, /* ret type */
++                                              "ret = '/'", &error);
++        throwError(error);
++
++        for (auto& instance : instances)
++        {
++            auto obj = dbus_test_dbus_mock_get_object(mock, instancePath(instance).c_str(),
++                                                      "org.freedesktop.systemd1.Service", &error);
++            throwError(error);
++            dbus_test_dbus_mock_object_add_property(mock, obj, "MainPID", G_VARIANT_TYPE_UINT32,
++                                                    g_variant_new_uint32(instance.primaryPid), &error);
++            throwError(error);
++
++            /* Control Group */
++            auto dir = g_build_filename(controlGroupPath.c_str(), instancePath(instance).c_str(), nullptr);
++            auto tasks = g_build_filename(dir, "tasks", nullptr);
++
++            g_mkdir_with_parents(dir, 0777);
++
++            g_file_set_contents(tasks, std::accumulate(instance.pids.begin(), instance.pids.end(), std::string{},
++                                                       [](const std::string& accum, pid_t pid) {
++                                                           if (accum.empty())
++                                                           {
++                                                               return std::to_string(pid);
++                                                           }
++                                                           else
++                                                           {
++                                                               return accum + "\n" + std::to_string(pid);
++                                                           }
++                                                       })
++                                           .c_str(),
++                                -1, &error);
++            throwError(error);
++
++            g_free(tasks);
++            g_free(dir);
++
++            dbus_test_dbus_mock_object_add_property(mock, obj, "ControlGroup", G_VARIANT_TYPE_STRING,
++                                                    g_variant_new_string(instancePath(instance).c_str()), nullptr);
++
++            insts.emplace_back(std::make_pair(instance, obj));
++        }
++    }
++
++    ~SystemdMock()
++    {
++        g_debug("Destroying the Systemd Mock");
++        g_clear_object(&mock);
++    }
++
++    static std::string dbusSafe(const std::string& input)
++    {
++        std::string output = input;
++        std::transform(output.begin(), output.end(), output.begin(), [](char in) {
++            if (std::isalpha(in) || std::isdigit(in))
++            {
++                return in;
++            }
++            else
++            {
++                return '_';
++            }
++
++        });
++        return output;
++    }
++
++    static std::string instancePath(const Instance& inst)
++    {
++        std::string retval = std::string{"/"} + dbusSafe(inst.job) + "/" + dbusSafe(inst.appid);
++
++        if (!inst.instanceid.empty())
++        {
++            retval += "/" + dbusSafe(inst.instanceid);
++        }
++
++        return retval;
++    }
++
++    static std::string instanceName(const Instance& inst)
++    {
++        return std::string{"ubuntu-app-launch-"} + inst.job + "-" + inst.appid + "-" + inst.instanceid + ".service";
++    }
++
++    operator std::shared_ptr<DbusTestTask>()
++    {
++        std::shared_ptr<DbusTestTask> retval(DBUS_TEST_TASK(g_object_ref(mock)),
++                                             [](DbusTestTask* task) { g_clear_object(&task); });
++        return retval;
++    }
++
++    operator DbusTestTask*()
++    {
++        return DBUS_TEST_TASK(mock);
++    }
++
++    operator DbusTestDbusMock*()
++    {
++        return mock;
++    }
++
++    unsigned int subscribeCallsCnt()
++    {
++        guint len = 0;
++        GError* error = nullptr;
++
++        dbus_test_dbus_mock_object_get_method_calls(mock,        /* mock */
++                                                    managerobj,  /* manager */
++                                                    "Subscribe", /* function */
++                                                    &len,        /* number */
++                                                    &error       /* error */
++                                                    );
++
++        if (error != nullptr)
++        {
++            g_warning("Unable to get 'Subscribe' calls from systemd mock: %s", error->message);
++            g_error_free(error);
++            throw std::runtime_error{"Mock disfunctional"};
++        }
++
++        return len;
++    }
++
++    unsigned int listCallsCnt()
++    {
++        guint len = 0;
++        GError* error = nullptr;
++
++        dbus_test_dbus_mock_object_get_method_calls(mock,        /* mock */
++                                                    managerobj,  /* manager */
++                                                    "ListUnits", /* function */
++                                                    &len,        /* number */
++                                                    &error       /* error */
++                                                    );
++
++        if (error != nullptr)
++        {
++            g_warning("Unable to get 'Subscribe' calls from systemd mock: %s", error->message);
++            g_error_free(error);
++            throw std::runtime_error{"Mock disfunctional"};
++        }
++
++        return len;
++    }
++
++    std::list<std::string> stopCalls()
++    {
++        guint len = 0;
++        GError* error = nullptr;
++
++        auto calls = dbus_test_dbus_mock_object_get_method_calls(mock,       /* mock */
++                                                                 managerobj, /* manager */
++                                                                 "StopUnit", /* function */
++                                                                 &len,       /* number */
++                                                                 &error      /* error */
++                                                                 );
++
++        if (error != nullptr)
++        {
++            g_warning("Unable to get 'StopUnit' calls from systemd mock: %s", error->message);
++            g_error_free(error);
++            throw std::runtime_error{"Mock disfunctional"};
++        }
++
++        std::list<std::string> retval;
++
++        for (unsigned int i = 0; i < len; i++)
++        {
++            auto& call = calls[i];
++            gchar* name = nullptr;
++            gchar* inst = nullptr;
++
++            g_variant_get(call.params, "(&s&s)", &name, &inst);
++
++            if (name == nullptr)
++            {
++                g_warning("Invalid 'name' on 'StopUnit' call");
++                continue;
++            }
++
++            retval.emplace_back(name);
++        }
++
++        return retval;
++    }
++
++    struct TransientUnit
++    {
++        std::string name;
++        std::set<std::string> environment;
++        std::string execpath;
++        std::list<std::string> execline;
++    };
++
++    std::list<TransientUnit> unitCalls()
++    {
++        guint len = 0;
++        GError* error = nullptr;
++
++        auto calls = dbus_test_dbus_mock_object_get_method_calls(mock,                 /* mock */
++                                                                 managerobj,           /* manager */
++                                                                 "StartTransientUnit", /* function */
++                                                                 &len,                 /* number */
++                                                                 &error                /* error */
++                                                                 );
++
++        if (error != nullptr)
++        {
++            g_warning("Unable to get 'StartTransientUnit' calls from systemd mock: %s", error->message);
++            g_error_free(error);
++            throw std::runtime_error{"Mock disfunctional"};
++        }
++
++        std::list<TransientUnit> retval;
++
++        for (unsigned int i = 0; i < len; i++)
++        {
++            auto& call = calls[i];
++            gchar* name = nullptr;
++
++            g_variant_get_child(call.params, 0, "&s", &name);
++
++            if (name == nullptr)
++            {
++                g_warning("Invalid 'name' on 'StartTransientUnit' call");
++                continue;
++            }
++
++            TransientUnit unit;
++            unit.name = name;
++
++            auto paramarray = g_variant_get_child_value(call.params, 2);
++            gchar* ckey;
++            GVariant* var;
++            GVariantIter iter;
++            g_variant_iter_init(&iter, paramarray);
++            while (g_variant_iter_loop(&iter, "(sv)", &ckey, &var))
++            {
++                g_debug("Looking at parameter: %s", ckey);
++                std::string key{ckey};
++
++                if (key == "Environment")
++                {
++                    GVariantIter array;
++                    gchar* envvar;
++                    g_variant_iter_init(&array, var);
++
++                    while (g_variant_iter_loop(&array, "&s", &envvar))
++                    {
++                        unit.environment.emplace(envvar);
++                    }
++                }
++                else if (key == "ExecStart")
++                {
++                    /* a(sasb) */
++                    if (g_variant_n_children(var) > 1)
++                    {
++                        g_warning("'ExecStart' has more than one entry, only processing the first");
++                    }
++
++                    auto tuple = g_variant_get_child_value(var, 0);
++
++                    const gchar* cpath = nullptr;
++                    g_variant_get_child(tuple, 0, "&s", &cpath);
++
++                    if (cpath != nullptr)
++                    {
++                        unit.execpath = cpath;
++                    }
++                    else
++                    {
++                        g_warning("'ExecStart[0][0]' isn't a string?");
++                    }
++
++                    auto vexecarray = g_variant_get_child_value(tuple, 1);
++                    GVariantIter execarray;
++                    g_variant_iter_init(&execarray, vexecarray);
++                    const gchar* execentry;
++
++                    while (g_variant_iter_loop(&execarray, "&s", &execentry))
++                    {
++                        unit.execline.emplace_back(execentry);
++                    }
++
++                    g_clear_pointer(&vexecarray, g_variant_unref);
++                    g_clear_pointer(&tuple, g_variant_unref);
++                }
++            }
++            g_variant_unref(paramarray);
++
++            retval.emplace_back(unit);
++        }
++
++        return retval;
++    }
++
++    void managerClear()
++    {
++        GError* error = nullptr;
++
++        dbus_test_dbus_mock_object_clear_method_calls(mock,       /* mock */
++                                                      managerobj, /* manager */
++                                                      &error      /* error */
++                                                      );
++
++        if (error != nullptr)
++        {
++            g_warning("Unable to clear manager calls: %s", error->message);
++            g_error_free(error);
++            throw std::runtime_error{"Mock disfunctional"};
++        }
++    }
++
++    void managerEmitNew(const std::string& name, const std::string& path)
++    {
++        GError* error = nullptr;
++
++        dbus_test_dbus_mock_object_emit_signal(mock, managerobj, "UnitNew", G_VARIANT_TYPE("(so)"),
++                                               g_variant_new("(so)", name.c_str(), path.c_str()), &error);
++
++        if (error != nullptr)
++        {
++            g_warning("Unable to emit 'UnitNew': %s", error->message);
++            g_error_free(error);
++            throw std::runtime_error{"Mock disfunctional"};
++        }
++    }
++
++    void managerEmitRemoved(const std::string& name, const std::string& path)
++    {
++        GError* error = nullptr;
++
++        dbus_test_dbus_mock_object_emit_signal(mock, managerobj, "UnitRemoved", G_VARIANT_TYPE("(so)"),
++                                               g_variant_new("(so)", name.c_str(), path.c_str()), &error);
++
++        if (error != nullptr)
++        {
++            g_warning("Unable to emit 'UnitRemoved': %s", error->message);
++            g_error_free(error);
++            throw std::runtime_error{"Mock disfunctional"};
++        }
++    }
++};
 === modified file 'xmir-helper.c'
 --- xmir-helper.c	2015-08-11 02:41:08 +0000
 +++ xmir-helper.c	2017-02-01 20:34:54 +0000
@@ -86,6 +86,8 @@
  			NULL
  		};
++		printf("Executing XMir on PID: %d", getpid());
++
  		return execv(xmir, xmirexec);
+ 	}

Ubuntu Application Launcher

Merge lp:~ted/ubuntu-app-launch/jobs-systemd into lp:ubuntu-app-launch

Commit message

Description of the change

Preview Diff

Subscribers