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

[Ted Gould]

SystemD backend added

[lp:~ted/ubuntu-app-launch/jobs-systemd]

309. By Ted Gould on 2016-10-27

Adding in numeric header

310. By Ted Gould on 2016-11-10

Don't throw an exception when we can't read the file, just assume it is empty

311. By Ted Gould on 2016-11-10

Merge in the tests branch

312. By Ted Gould on 2016-11-14

Pulling through updates

313. By Ted Gould on 2016-11-14

Setup the dbus signal watchers for new and removed units

314. By Ted Gould on 2016-11-14

Flesh out the unitNew and unitRemoved cache part of the functions

315. By Ted Gould on 2016-11-14

Emit signals if we see no applications or they disappear

316. By Ted Gould on 2016-11-14

Use pause and resume from the base class

317. By Ted Gould on 2016-11-14

We are no emitting valid stopped and started signals

318. By Ted Gould on 2016-11-14

Switch to the signal based unit cache

319. By Ted Gould on 2016-11-14

Replace listUnits code with using our unit cache

320. By Ted Gould on 2016-11-15

Setting up the signal watcher for building the failed signal

321. By Ted Gould on 2016-11-15

Flesh out the failed signal setup

322. By Ted Gould on 2016-11-15

Make sure the failure test is still using the Upstart backend

323. By Ted Gould on 2016-11-16

Debug messages

324. By Ted Gould on 2016-11-16

Subscribing to events from systemd

325. By Ted Gould on 2016-11-16

Make sure we get the unit path not just the job path

326. By Ted Gould on 2016-11-17

Putting in a warning if we're not setting the ExecStart

327. By Ted Gould on 2016-11-17

Warn if we end up with an odd parse

328. By Ted Gould on 2016-11-17

Make the code less clever but easier to read and hopefully we can figure out what's going on.

329. By Ted Gould on 2016-11-17

Pulling through trunk

330. By Ted Gould on 2016-11-17

Clear out some of the environment variables and check the length

331. By Ted Gould on 2016-12-02

Keeping libertine launch

332. By Ted Gould on 2017-01-06

Merge parent

333. By Ted Gould on 2017-01-06

Test fixes

334. By Ted Gould on 2017-01-11

Update to the jobs-tests branch updates

335. By Ted Gould on 2017-01-13

Pull out the registry-mock into it's own file for sharing

336. By Ted Gould on 2017-01-13

Get in the bones for our testing

337. By Ted Gould on 2017-01-13

Add in the systemd mock

338. By Ted Gould on 2017-01-13

Make sure not to use the pointer if we're cancelled

339. By Ted Gould on 2017-01-13

Build the infrastructure for putting instances in

340. By Ted Gould on 2017-01-14

Getting our test objects setup

341. By Ted Gould on 2017-01-17

Add tests to make sure we're initing systemd

342. By Ted Gould on 2017-01-17

Add a fallback to use the session bus for testing

343. By Ted Gould on 2017-01-17

Force the systemd unit to session bus

344. By Ted Gould on 2017-01-17

Make the tests more reliable by waiting on dbus to close

345. By Ted Gould on 2017-01-17

Ensure that we're immune to very quickly destroyed instances

346. By Ted Gould on 2017-01-18

Add in a check for an eventually timeout envvar

347. By Ted Gould on 2017-01-19

Removing fancy async calls

348. By Ted Gould on 2017-01-19

Setup some 'GetUnit' and more complex mocking for jobs tests

349. By Ted Gould on 2017-01-19

Don't emit signals on the initial getting a list of units

350. By Ted Gould on 2017-01-19

Fixing up debug messages

351. By Ted Gould on 2017-01-19

Make sure to use the registry we have instead of allocating a new one

352. By Ted Gould on 2017-01-19

A description

353. By Ted Gould on 2017-01-19

Merge from trunk

354. By Ted Gould on 2017-01-19

Making it so that we have two multiple and a single

355. By Ted Gould on 2017-01-19

Apply formatting

356. By Ted Gould on 2017-01-19

Test to ensure the user bus path is correct

357. By Ted Gould on 2017-01-19

Adding a test for the PID functions

358. By Ted Gould on 2017-01-20

Check the stop call code

359. By Ted Gould on 2017-01-20

Clearing and checking multiple stopping

360. By Ted Gould on 2017-01-20

Reduce the amount of data needed

361. By Ted Gould on 2017-01-20

Make a launch test

362. By Ted Gould on 2017-01-20

First parts of verifying the transient calls

363. By Ted Gould on 2017-01-21

Environment checking

364. By Ted Gould on 2017-01-21

Adding in some tests of the instance objects even though they only call into the manager

365. By Ted Gould on 2017-01-21

Signal new test

366. By Ted Gould on 2017-01-21

Check signal removed

367. By Ted Gould on 2017-01-23

Fix for GCC 5.4

368. By Ted Gould on 2017-01-23

Fail fast

369. By Ted Gould on 2017-01-23

Okay, that was probably turning it up too high

370. By Ted Gould on 2017-01-23

Making it so that we throw on errors when building the mock.

371. By Ted Gould on 2017-01-23

Drop parallel to make builds more reliable

372. By Ted Gould on 2017-01-24

Make it so that we replace a job on stop

373. By Ted Gould on 2017-01-26

Update to trunk

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

400. By Ted Gould on 2017-01-28

Test the exec line and ensure it doesn't fail

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

403. By Ted Gould on 2017-02-01

Making sure everything is on the right bus

Unmerged revisions

403. By Ted Gould on 2017-02-01

Making sure everything is on the right bus

402. By Ted Gould on 2017-01-28

Use the g_array functions to avoid some casts

401. By Ted Gould on 2017-01-28

Don't crash free memory, works but is odd

400. By Ted Gould on 2017-01-28

Test the exec line and ensure it doesn't fail

399. By Ted Gould on 2017-01-27

Overrides

398. By Charles Kerr on 2017-01-27

Clearer sorting

397. By Ted Gould on 2017-01-27

Fixing up the failure signals

396. By Ted Gould on 2017-01-27

Switching to static_cast<>

395. By Ted Gould on 2017-01-27

Remove try/catch that isn't needed

394. By Ted Gould on 2017-01-27

Don't get all the jobs until we're sure we have a registry

=== modified file 'libubuntu-app-launch/CMakeLists.txt'
--- libubuntu-app-launch/CMakeLists.txt	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2016-11-10 21:59:02 +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	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/application-impl-base.cpp	2016-11-10 21:59:02 +0000
@@ -95,6 +95,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)
+{
+    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-11-10 21:59:01 +0000
+++ libubuntu-app-launch/application-impl-base.h	2016-11-10 21:59:02 +0000
@@ -17,6 +17,7 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "application-info-desktop.h"
 #include "application.h"
 
 extern "C" {
@@ -43,6 +44,8 @@
 
     bool hasInstances() override;
 
+    std::string getInstance(const std::shared_ptr<app_info::Desktop>& desktop);
+
 protected:
     /** Pointer to the registry so we can ask it for things */
     std::shared_ptr<Registry> _registry;

=== modified file 'libubuntu-app-launch/application-impl-click.cpp'
--- libubuntu-app-launch/application-impl-click.cpp	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/application-impl-click.cpp	2016-11-10 21:59:02 +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-11-10 21:59:01 +0000
+++ libubuntu-app-launch/application-impl-legacy.cpp	2016-11-10 21:59:02 +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-09-23 21:54:33 +0000
+++ libubuntu-app-launch/application-impl-legacy.h	2016-11-10 21:59:02 +0000
@@ -86,7 +86,6 @@
     std::regex instanceRegex_;
 
     std::list<std::pair<std::string, std::string>> launchEnv(const std::string& instance);
-    std::string getInstance();
 };
 
 }  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
--- libubuntu-app-launch/application-impl-libertine.cpp	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2016-11-10 21:59:02 +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	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/application-impl-snap.cpp	2016-11-10 21:59:02 +0000
@@ -196,6 +196,8 @@
     }
 
     info_ = std::make_shared<SnapInfo>(appid_, _registry, interface_, pkgInfo_->directory);
+
+    g_debug("Application Snap object for AppID '%s'", std::string(appid).c_str());
 }
 
 /** Uses the findInterface() function to find the interface if we don't
@@ -229,7 +231,7 @@
             }
             catch (std::runtime_error& e)
             {
-                g_warning("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
+                g_debug("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
             }
         }
     }
@@ -436,9 +438,10 @@
 */
 std::shared_ptr<Application::Instance> Snap::launch(const std::vector<Application::URL>& urls)
 {
+    auto instance = getInstance(info_);
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return _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
@@ -448,8 +451,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	2016-09-14 16:42:20 +0000
+++ libubuntu-app-launch/application-info-desktop.cpp	2016-11-10 21:59:02 +0000
@@ -253,7 +253,7 @@
             if (stringlistFromKeyfileContains(keyfile, "NotShowIn", xdg_current_desktop, false) ||
                 !stringlistFromKeyfileContains(keyfile, "OnlyShowIn", xdg_current_desktop, true))
             {
-                g_warning("Application is not shown in Unity");
+                g_debug("Application is not shown in current desktop: %s", xdg_current_desktop);
                 // Exception removed for OTA11 as a temporary fix
                 // throw std::runtime_error("Application is not shown in Unity");
             }
@@ -352,6 +352,7 @@
     , _xMirEnable(
           boolFromKeyfile<XMirEnable>(keyfile, "X-Ubuntu-XMir-Enable", (flags & DesktopFlags::XMIR_DEFAULT).any()))
     , _exec(stringFromKeyfile<Exec>(keyfile, "Exec"))
+    , _singleInstance(boolFromKeyfile<SingleInstance>(keyfile, "X-Ubuntu-Single-Instance", false))
 {
 }
 

=== modified file 'libubuntu-app-launch/application-info-desktop.h'
--- libubuntu-app-launch/application-info-desktop.h	2016-09-14 16:38:42 +0000
+++ libubuntu-app-launch/application-info-desktop.h	2016-11-10 21:59:02 +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/jobs-base.cpp'
--- libubuntu-app-launch/jobs-base.cpp	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/jobs-base.cpp	2016-11-10 21:59:02 +0000
@@ -23,6 +23,7 @@
 #include <numeric>
 
 #include "jobs-base.h"
+#include "jobs-systemd.h"
 #include "jobs-upstart.h"
 #include "registry-impl.h"
 
@@ -37,6 +38,7 @@
 
 Base::Base(const std::shared_ptr<Registry>& registry)
     : registry_(registry)
+    , allJobs_{"application-click", "application-legacy", "application-snap"}
     , dbus_(registry->impl->_dbus)
 {
 }
@@ -58,7 +60,23 @@
 
 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))
+    {
+        return std::make_shared<jobs::manager::SystemD>(registry);
+    }
+    else
+    {
+        return std::make_shared<jobs::manager::Upstart>(registry);
+    }
+}
+
+const std::set<std::string>& Base::getAllJobs()
+{
+    return allJobs_;
 }
 
 /** Take the GVariant of parameters and turn them into an application and
@@ -277,7 +295,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
@@ -585,6 +605,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	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/jobs-base.h	2016-11-10 21:59:02 +0000
@@ -24,6 +24,7 @@
 
 #include <core/signal.h>
 #include <gio/gio.h>
+#include <set>
 
 namespace ubuntu
 {
@@ -66,6 +67,8 @@
     /** A link to the registry we're using for connections */
     std::shared_ptr<Registry> registry_;
 
+    static std::shared_ptr<gchar*> urlsToStrv(const std::vector<Application::URL>& urls);
+
 private:
     std::vector<pid_t> forAllPids(std::function<void(pid_t)> eachPid);
     void signalToPid(pid_t pid, int signal);
@@ -110,6 +113,8 @@
 
     virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) = 0;
 
+    const std::set<std::string>& getAllJobs();
+
     static std::shared_ptr<Base> determineFactory(std::shared_ptr<Registry> registry);
 
     /* Signals to apps */
@@ -130,6 +135,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	2016-11-10 21:59:02 +0000
@@ -0,0 +1,950 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#include <algorithm>
+#include <gio/gio.h>
+#include <numeric>
+#include <regex>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "helpers.h"
+#include "jobs-systemd.h"
+#include "registry-impl.h"
+#include "second-exec-core.h"
+
+extern "C" {
+#include "ubuntu-app-launch-trace.h"
+}
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace instance
+{
+
+class SystemD : public Base
+{
+    friend class manager::SystemD;
+
+public:
+    explicit SystemD(const AppID& appId,
+                     const std::string& job,
+                     const std::string& instance,
+                     const std::vector<Application::URL>& urls,
+                     const std::shared_ptr<Registry>& registry);
+
+    /* Query lifecycle */
+    pid_t primaryPid() override;
+    std::string logPath() override;
+    std::vector<pid_t> pids() override;
+
+    /* Manage lifecycle */
+    void stop() override;
+
+};  // class SystemD
+
+SystemD::SystemD(const AppID& appId,
+                 const std::string& job,
+                 const std::string& instance,
+                 const std::vector<Application::URL>& urls,
+                 const std::shared_ptr<Registry>& registry)
+    : Base(appId, job, instance, urls, registry)
+{
+    g_debug("Creating a new SystemD for '%s' instance '%s'", std::string(appId).c_str(), instance.c_str());
+}
+
+pid_t SystemD::primaryPid()
+{
+    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
+    return manager->unitPrimaryPid(appId_, job_, instance_);
+}
+
+std::string SystemD::logPath()
+{
+    /* NOTE: We can never get this for systemd */
+    return {};
+}
+
+std::vector<pid_t> SystemD::pids()
+{
+    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
+    return manager->unitPids(appId_, job_, instance_);
+}
+
+void SystemD::stop()
+{
+    auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry_->impl->jobs);
+    return manager->stopUnit(appId_, job_, instance_);
+}
+
+}  // namespace instance
+
+namespace manager
+{
+
+static const std::string SYSTEMD_DBUS_ADDRESS{"org.freedesktop.systemd1"};
+static const std::string SYSTEMD_DBUS_IFACE_MANAGER{"org.freedesktop.systemd1.Manager"};
+static const std::string SYSTEMD_DBUS_PATH_MANAGER{"/org/freedesktop/systemd1"};
+static const std::string SYSTEMD_DBUS_IFACE_UNIT{"org.freedesktop.systemd1.Unit"};
+static const std::string SYSTEMD_DBUS_IFACE_SERVICE{"org.freedesktop.systemd1.Service"};
+
+SystemD::SystemD(std::shared_ptr<Registry> registry)
+    : Base(registry)
+{
+    auto cancel = registry->impl->thread.getCancellable();
+    userbus_ = registry->impl->thread.executeOnThread<std::shared_ptr<GDBusConnection>>([cancel]() {
+        GError* error = nullptr;
+        auto bus = std::shared_ptr<GDBusConnection>(
+            g_dbus_connection_new_for_address_sync(
+                ("unix:path=" + userBusPath()).c_str(), /* path to the user bus */
+                (GDBusConnectionFlags)(G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
+                                       G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION), /* It is a message bus */
+                nullptr,                                                                /* observer */
+                cancel.get(), /* cancellable from the thread */
+                &error),      /* error */
+            [](GDBusConnection* bus) { g_clear_object(&bus); });
+
+        if (error != nullptr)
+        {
+            std::string message = std::string("Unable to connect to user bus: ") + error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        return bus;
+    });
+}
+
+SystemD::~SystemD()
+{
+}
+
+std::string SystemD::findEnv(const std::string& value, std::list<std::pair<std::string, std::string>>& env)
+{
+    std::string retval;
+    auto entry = std::find_if(env.begin(), env.end(),
+                              [&value](std::pair<std::string, std::string>& entry) { return entry.first == value; });
+
+    if (entry != env.end())
+    {
+        retval = entry->second;
+    }
+
+    return retval;
+}
+
+std::vector<std::string> SystemD::parseExec(std::list<std::pair<std::string, std::string>>& env)
+{
+    auto exec = findEnv("APP_EXEC", env);
+    if (exec.empty())
+    {
+        g_debug("Application exec line is empty?!?!?");
+        return {};
+    }
+    auto uris = findEnv("APP_URIS", env);
+
+    auto execarray = desktop_exec_parse(exec.c_str(), uris.c_str());
+
+    std::vector<std::string> retval;
+    retval.reserve(execarray->len);
+    for (unsigned int i = 0; i < execarray->len; i++)
+    {
+        retval.emplace_back(g_array_index(execarray, gchar*, i));
+    }
+
+    g_array_set_clear_func(execarray, g_free);
+    g_array_free(execarray, FALSE); /* TODO: Not TRUE? */
+
+    /* See if we need the xmir helper */
+    if (findEnv("APP_XMIR_ENABLE", env) == "1" && getenv("DISPLAY") == nullptr)
+    {
+        retval.emplace(retval.begin(), findEnv("APP_ID", env));
+        retval.emplace(retval.begin(), XMIR_HELPER);
+    }
+
+    /* See if we're doing apparmor by hand */
+    auto appexecpolicy = findEnv("APP_EXEC_POLICY", env);
+    if (!appexecpolicy.empty() && appexecpolicy != "unconfined")
+    {
+        retval.emplace(retval.begin(), appexecpolicy);
+        retval.emplace(retval.begin(), "-p");
+        retval.emplace(retval.begin(), "aa-exec");
+    }
+
+    return retval;
+}
+
+/** Small helper that we can new/delete to work better with C stuff */
+struct StartCHelper
+{
+    std::shared_ptr<instance::SystemD> ptr;
+    std::shared_ptr<GDBusConnection> bus;
+};
+
+void SystemD::application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data)
+{
+    auto data = static_cast<StartCHelper*>(user_data);
+    GError* error{nullptr};
+    GVariant* result{nullptr};
+
+    tracepoint(ubuntu_app_launch, libual_start_message_callback, std::string(data->ptr->appId_).c_str());
+
+    g_debug("Started Message Callback: %s", std::string(data->ptr->appId_).c_str());
+
+    result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(obj), res, &error);
+
+    g_clear_pointer(&result, g_variant_unref);
+
+    if (error != nullptr)
+    {
+        if (g_dbus_error_is_remote_error(error))
+        {
+            gchar* remote_error = g_dbus_error_get_remote_error(error);
+            g_debug("Remote error: %s", remote_error);
+            if (g_strcmp0(remote_error, "org.freedesktop.systemd1.UnitExists") == 0)
+            {
+                auto urls = instance::SystemD::urlsToStrv(data->ptr->urls_);
+                second_exec(data->bus.get(),                                           /* DBus */
+                            data->ptr->registry_->impl->thread.getCancellable().get(), /* cancellable */
+                            data->ptr->primaryPid(),                                   /* primary pid */
+                            std::string(data->ptr->appId_).c_str(),                    /* appid */
+                            urls.get());                                               /* urls */
+            }
+
+            g_free(remote_error);
+        }
+        else
+        {
+            g_warning("Unable to emit event to start application: %s", error->message);
+        }
+        g_error_free(error);
+    }
+
+    delete data;
+}
+
+void SystemD::copyEnv(const std::string& envname, std::list<std::pair<std::string, std::string>>& env)
+{
+    if (!findEnv(envname, env).empty())
+    {
+        g_debug("Already a value set for '%s' ignoring", envname.c_str());
+        return;
+    }
+
+    auto cvalue = getenv(envname.c_str());
+    g_debug("Copying Environment: %s", envname.c_str());
+    if (cvalue != nullptr)
+    {
+        std::string value = getenv(envname.c_str());
+        env.emplace_back(std::make_pair(envname, value));
+    }
+    else
+    {
+        g_debug("Unable to copy environment '%s'", envname.c_str());
+    }
+}
+
+void SystemD::copyEnvByPrefix(const std::string& prefix, std::list<std::pair<std::string, std::string>>& env)
+{
+    for (unsigned int i = 0; environ[i] != nullptr; i++)
+    {
+        if (g_str_has_prefix(environ[i], prefix.c_str()))
+        {
+            std::string envfull = environ[i];
+            std::string envname;
+            bool seenequal = false;
+            std::remove_copy_if(envfull.begin(), envfull.end(), std::back_inserter(envname),
+                                [&seenequal](const char c) {
+                                    if (c == '=')
+                                    {
+                                        seenequal = true;
+                                    }
+                                    return seenequal;
+                                });
+            copyEnv(envname, env);
+        }
+    }
+}
+
+std::shared_ptr<Application::Instance> SystemD::launch(
+    const AppID& appId,
+    const std::string& job,
+    const std::string& instance,
+    const std::vector<Application::URL>& urls,
+    launchMode mode,
+    std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv)
+{
+    if (appId.empty())
+        return {};
+
+    auto registry = registry_.lock();
+    return registry->impl->thread.executeOnThread<std::shared_ptr<instance::SystemD>>(
+        [&]() -> std::shared_ptr<instance::SystemD> {
+            auto manager = std::dynamic_pointer_cast<manager::SystemD>(registry->impl->jobs);
+            std::string appIdStr{appId};
+            g_debug("Initializing params for an new instance::SystemD for: %s", appIdStr.c_str());
+
+            tracepoint(ubuntu_app_launch, libual_start, appIdStr.c_str());
+
+            int timeout = 1;
+            if (ubuntu::app_launch::Registry::Impl::isWatchingAppStarting())
+            {
+                timeout = 0;
+            }
+
+            auto handshake = starting_handshake_start(appIdStr.c_str(), timeout);
+            if (handshake == nullptr)
+            {
+                g_warning("Unable to setup starting handshake");
+            }
+
+            /* Figure out the unit name for the job */
+            auto unitname = unitName(SystemD::UnitInfo{appIdStr, job, instance});
+
+            /* Build up our environment */
+            auto env = getenv();
+
+            env.emplace_back(std::make_pair("APP_ID", appIdStr));                           /* Application ID */
+            env.emplace_back(std::make_pair("APP_LAUNCHER_PID", std::to_string(getpid()))); /* Who we are, for bugs */
+
+            copyEnv("DISPLAY", env);
+            copyEnvByPrefix("DBUS_", env);
+            copyEnvByPrefix("MIR_", env);
+            copyEnvByPrefix("QT_", env);
+            copyEnvByPrefix("UBUNTU_", env);
+            copyEnvByPrefix("UNITY_", env);
+            copyEnvByPrefix("XDG_", env);
+
+            if (!urls.empty())
+            {
+                auto accumfunc = [](const std::string& prev, Application::URL thisurl) -> std::string {
+                    gchar* gescaped = g_shell_quote(thisurl.value().c_str());
+                    std::string escaped;
+                    if (gescaped != nullptr)
+                    {
+                        escaped = gescaped;
+                        g_free(gescaped);
+                    }
+                    else
+                    {
+                        g_warning("Unable to escape URL: %s", thisurl.value().c_str());
+                        return prev;
+                    }
+
+                    if (prev.empty())
+                    {
+                        return escaped;
+                    }
+                    else
+                    {
+                        return prev + " " + escaped;
+                    }
+                };
+                auto urlstring = std::accumulate(urls.begin(), urls.end(), std::string{}, accumfunc);
+                env.emplace_back(std::make_pair("APP_URIS", urlstring));
+            }
+
+            if (mode == launchMode::TEST)
+            {
+                env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
+            }
+
+            /* Convert to GVariant */
+            GVariantBuilder builder;
+            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+
+            g_variant_builder_add_value(&builder, g_variant_new_string(unitname.c_str()));
+            g_variant_builder_add_value(&builder, g_variant_new_string("replace"));  // Job mode
+
+            /* Parameter Array */
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+            /* Environment */
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+            g_variant_builder_add_value(&builder, g_variant_new_string("Environment"));
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+            for (const auto& envvar : env)
+            {
+                if (!envvar.first.empty() && !envvar.second.empty())
+                {
+                    g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf(
+                                                              "%s=%s", envvar.first.c_str(), envvar.second.c_str())));
+                    // g_debug("Setting environment: %s=%s", envvar.first.c_str(), envvar.second.c_str());
+                }
+            }
+
+            g_variant_builder_close(&builder);
+            g_variant_builder_close(&builder);
+            g_variant_builder_close(&builder);
+
+            /* ExecStart */
+            auto commands = parseExec(env);
+            gchar* pathexec{nullptr};
+            if (!commands.empty() && ((pathexec = g_find_program_in_path(commands[0].c_str())) != nullptr))
+            {
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+                g_variant_builder_add_value(&builder, g_variant_new_string("ExecStart"));
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+                g_variant_builder_add_value(&builder, g_variant_new_take_string(pathexec));
+
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+                for (auto param : commands)
+                {
+                    g_variant_builder_add_value(&builder, g_variant_new_string(param.c_str()));
+                }
+                g_variant_builder_close(&builder);
+
+                g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE));
+
+                g_variant_builder_close(&builder);
+                g_variant_builder_close(&builder);
+                g_variant_builder_close(&builder);
+                g_variant_builder_close(&builder);
+            }
+
+            /* RemainAfterExit */
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+            g_variant_builder_add_value(&builder, g_variant_new_string("RemainAfterExit"));
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+            g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE));
+            g_variant_builder_close(&builder);
+            g_variant_builder_close(&builder);
+
+            /* Type */
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+            g_variant_builder_add_value(&builder, g_variant_new_string("Type"));
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+            g_variant_builder_add_value(&builder, g_variant_new_string("oneshot"));
+            g_variant_builder_close(&builder);
+            g_variant_builder_close(&builder);
+
+            /* Working Directory */
+            if (!findEnv("APP_DIR", env).empty())
+            {
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
+                g_variant_builder_add_value(&builder, g_variant_new_string("WorkingDirectory"));
+                g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
+                g_variant_builder_add_value(&builder, g_variant_new_string(findEnv("APP_DIR", env).c_str()));
+                g_variant_builder_close(&builder);
+                g_variant_builder_close(&builder);
+            }
+
+            /* Parameter Array */
+            g_variant_builder_close(&builder);
+
+            /* Dependent Units (none) */
+            g_variant_builder_add_value(&builder, g_variant_new_array(G_VARIANT_TYPE("(sa(sv))"), nullptr, 0));
+
+            auto retval = std::make_shared<instance::SystemD>(appId, job, instance, urls, registry);
+            auto chelper = new StartCHelper{};
+            chelper->ptr = retval;
+            chelper->bus = manager->userbus_;
+
+            tracepoint(ubuntu_app_launch, handshake_wait, appIdStr.c_str());
+            starting_handshake_wait(handshake);
+            tracepoint(ubuntu_app_launch, handshake_complete, appIdStr.c_str());
+
+            /* Call the job start function */
+            g_debug("Asking systemd to start task for: %s", appIdStr.c_str());
+            g_dbus_connection_call(manager->userbus_.get(),                       /* bus */
+                                   SYSTEMD_DBUS_ADDRESS.c_str(),                  /* service name */
+                                   SYSTEMD_DBUS_PATH_MANAGER.c_str(),             /* Path */
+                                   SYSTEMD_DBUS_IFACE_MANAGER.c_str(),            /* interface */
+                                   "StartTransientUnit",                          /* method */
+                                   g_variant_builder_end(&builder),               /* params */
+                                   G_VARIANT_TYPE("(o)"),                         /* return */
+                                   G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                   -1,                                            /* default timeout */
+                                   registry->impl->thread.getCancellable().get(), /* cancellable */
+                                   application_start_cb,                          /* callback */
+                                   chelper                                        /* object */
+                                   );
+
+            tracepoint(ubuntu_app_launch, libual_start_message_sent, appIdStr.c_str());
+
+            return retval;
+        });
+}
+
+std::shared_ptr<Application::Instance> SystemD::existing(const AppID& appId,
+                                                         const std::string& job,
+                                                         const std::string& instance,
+                                                         const std::vector<Application::URL>& urls)
+{
+    return std::make_shared<instance::SystemD>(appId, job, instance, urls, registry_.lock());
+}
+
+std::vector<std::shared_ptr<instance::Base>> SystemD::instances(const AppID& appID, const std::string& job)
+{
+    std::vector<std::shared_ptr<instance::Base>> instances;
+    auto registry = registry_.lock();
+    std::vector<Application::URL> urls;
+
+    for (const auto& unit : listUnits())
+    {
+        SystemD::UnitInfo unitinfo;
+
+        try
+        {
+            unitinfo = parseUnit(unit.id);
+        }
+        catch (std::runtime_error& e)
+        {
+            continue;
+        }
+
+        if (job != unitinfo.job)
+        {
+            continue;
+        }
+
+        if (std::string(appID) != unitinfo.appid)
+        {
+            continue;
+        }
+
+        instances.emplace_back(std::make_shared<instance::SystemD>(appID, job, unitinfo.inst, urls, registry));
+    }
+
+    g_debug("Found %d instances for AppID '%s'", int(instances.size()), std::string(appID).c_str());
+
+    return instances;
+}
+
+std::list<std::shared_ptr<Application>> SystemD::runningApps()
+{
+    auto allJobs = getAllJobs();
+    auto registry = registry_.lock();
+    std::set<std::string> appids;
+
+    for (const auto& unit : listUnits())
+    {
+        SystemD::UnitInfo unitinfo;
+
+        try
+        {
+            unitinfo = parseUnit(unit.id);
+        }
+        catch (std::runtime_error& e)
+        {
+            continue;
+        }
+
+        if (allJobs.find(unitinfo.job) == allJobs.end())
+        {
+            continue;
+        }
+
+        appids.insert(unitinfo.appid);
+    }
+
+    std::list<std::shared_ptr<Application>> apps;
+    for (const auto& appid : appids)
+    {
+        auto id = AppID::find(appid);
+        if (id.empty())
+        {
+            g_debug("Unable to handle AppID: %s", appid.c_str());
+            continue;
+        }
+
+        apps.emplace_back(Application::create(id, registry));
+    }
+
+    return apps;
+}
+
+std::string SystemD::userBusPath()
+{
+    auto cpath = getenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH");
+    if (cpath != nullptr)
+    {
+        return cpath;
+    }
+    return std::string{"/run/user/"} + std::to_string(getuid()) + std::string{"/bus"};
+}
+
+std::list<SystemD::UnitEntry> SystemD::listUnits()
+{
+    auto registry = registry_.lock();
+    return registry->impl->thread.executeOnThread<std::list<SystemD::UnitEntry>>([this, registry]() {
+        GError* error{nullptr};
+        std::list<SystemD::UnitEntry> ret;
+
+        GVariant* callt = g_dbus_connection_call_sync(userbus_.get(),                                /* user bus */
+                                                      SYSTEMD_DBUS_ADDRESS.c_str(),                  /* bus name */
+                                                      SYSTEMD_DBUS_PATH_MANAGER.c_str(),             /* path */
+                                                      SYSTEMD_DBUS_IFACE_MANAGER.c_str(),            /* interface */
+                                                      "ListUnits",                                   /* method */
+                                                      nullptr,                                       /* params */
+                                                      G_VARIANT_TYPE("(a(ssssssouso))"),             /* ret type */
+                                                      G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                                      -1,                                            /* timeout */
+                                                      registry->impl->thread.getCancellable().get(), /* cancellable */
+                                                      &error);
+
+        if (error != nullptr)
+        {
+            auto message = std::string{"Unable to list SystemD units: "} + error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        GVariant* call = g_variant_get_child_value(callt, 0);
+        g_variant_unref(callt);
+
+        const gchar* id;
+        const gchar* description;
+        const gchar* loadState;
+        const gchar* activeState;
+        const gchar* subState;
+        const gchar* following;
+        const gchar* path;
+        guint32 jobId;
+        const gchar* jobType;
+        const gchar* jobPath;
+        auto iter = g_variant_iter_new(call);
+        while (g_variant_iter_loop(iter, "(&s&s&s&s&s&s&ou&s&o)", &id, &description, &loadState, &activeState,
+                                   &subState, &following, &path, &jobId, &jobType, &jobPath))
+        {
+            ret.emplace_back(SystemD::UnitEntry{id, description, loadState, activeState, subState, following, path,
+                                                jobId, jobType, jobPath});
+        }
+
+        g_variant_iter_free(iter);
+        g_variant_unref(call);
+
+        return ret;
+    });
+}
+
+/* TODO: Application job names */
+const std::regex unitNaming{
+    "^ubuntu\\-app\\-launch\\-(application\\-(?:click|legacy|snap))\\-(.*)\\-([0-9]*)\\.service$"};
+
+SystemD::UnitInfo SystemD::parseUnit(const std::string& unit)
+{
+    std::smatch match;
+    if (!std::regex_match(unit, match, unitNaming))
+    {
+        throw std::runtime_error{"Unable to parse unit name: " + unit};
+    }
+
+    return {match[2].str(), match[1].str(), match[3].str()};
+}
+
+std::string SystemD::unitName(const SystemD::UnitInfo& info)
+{
+    return std::string{"ubuntu-app-launch-"} + info.job + "-" + info.appid + "-" + info.inst + ".service";
+}
+
+/** Function that uses and maintains the cache of the paths for units
+    on the systemd dbus connection. If we already have the entry in the
+    cache we just return the path and this function is fast. If not we have
+    to ask systemd for it and that can take a bit longer.
+
+    After getting the data we throw a small background task in to clean
+    up the cache if it has more than 50 entries. We delete those who
+    haven't be used for an hour.
+*/
+std::string SystemD::unitPath(const std::string& unitName)
+{
+    auto registry = registry_.lock();
+    std::string retval;
+
+    if (true)
+    {
+        /* Create a context for the gaurd */
+        std::lock_guard<std::mutex> guard(unitPathsMutex_);
+        auto iter = std::find_if(unitPaths_.begin(), unitPaths_.end(),
+                                 [&unitName](const SystemD::UnitPath& entry) { return entry.unitName == unitName; });
+
+        if (iter != unitPaths_.end())
+        {
+            retval = iter->unitPath;
+            iter->timeStamp = std::chrono::system_clock::now();
+        }
+    }
+
+    if (retval.empty())
+    {
+        retval = registry->impl->thread.executeOnThread<std::string>([this, registry, unitName]() {
+            std::string path;
+            GError* error{nullptr};
+            GVariant* call =
+                g_dbus_connection_call_sync(userbus_.get(),                                /* user bus */
+                                            SYSTEMD_DBUS_ADDRESS.c_str(),                  /* bus name */
+                                            SYSTEMD_DBUS_PATH_MANAGER.c_str(),             /* path */
+                                            SYSTEMD_DBUS_IFACE_MANAGER.c_str(),            /* interface */
+                                            "GetUnit",                                     /* method */
+                                            g_variant_new("(s)", unitName.c_str()),        /* params */
+                                            G_VARIANT_TYPE("(o)"),                         /* ret type */
+                                            G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                            -1,                                            /* timeout */
+                                            registry->impl->thread.getCancellable().get(), /* cancellable */
+                                            &error);
+
+            if (error != nullptr)
+            {
+                auto message = std::string{"Unable to get SystemD unit path for '"} + unitName + std::string{"': "} +
+                               error->message;
+                g_error_free(error);
+                throw std::runtime_error(message);
+            }
+
+            /* Parse variant */
+            gchar* gpath = nullptr;
+            g_variant_get(call, "(o)", &gpath);
+            if (gpath != nullptr)
+            {
+                std::lock_guard<std::mutex> guard(unitPathsMutex_);
+                path = gpath;
+                unitPaths_.emplace_back(SystemD::UnitPath{unitName, path, std::chrono::system_clock::now()});
+            }
+
+            g_variant_unref(call);
+
+            return path;
+        });
+    }
+
+    /* Queue a possible cleanup */
+    if (unitPaths_.size() > 50)
+    {
+        /* TODO: We should look at UnitRemoved as well */
+        /* TODO: Add to cache on UnitNew */
+        registry->impl->thread.executeOnThread([this] {
+            std::lock_guard<std::mutex> guard(unitPathsMutex_);
+            std::remove_if(unitPaths_.begin(), unitPaths_.end(), [](const SystemD::UnitPath& entry) -> bool {
+                auto age = std::chrono::system_clock::now() - entry.timeStamp;
+                return age > std::chrono::hours{1};
+            });
+        });
+    }
+
+    return retval;
+}
+
+pid_t SystemD::unitPrimaryPid(const AppID& appId, const std::string& job, const std::string& instance)
+{
+    auto registry = registry_.lock();
+    auto unitname = unitName(SystemD::UnitInfo{appId, job, instance});
+    auto unitpath = unitPath(unitname);
+
+    return registry->impl->thread.executeOnThread<pid_t>([this, registry, unitname, unitpath]() {
+        GError* error{nullptr};
+        GVariant* call = g_dbus_connection_call_sync(
+            userbus_.get(),                                                       /* user bus */
+            SYSTEMD_DBUS_ADDRESS.c_str(),                                         /* bus name */
+            unitpath.c_str(),                                                     /* path */
+            "org.freedesktop.DBus.Properties",                                    /* interface */
+            "Get",                                                                /* method */
+            g_variant_new("(ss)", SYSTEMD_DBUS_IFACE_SERVICE.c_str(), "MainPID"), /* params */
+            G_VARIANT_TYPE("(v)"),                                                /* ret type */
+            G_DBUS_CALL_FLAGS_NONE,                                               /* flags */
+            -1,                                                                   /* timeout */
+            registry->impl->thread.getCancellable().get(),                        /* cancellable */
+            &error);
+
+        if (error != nullptr)
+        {
+            auto message =
+                std::string{"Unable to get SystemD PID for '"} + unitname + std::string{"': "} + error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        /* Parse variant */
+        GVariant* vpid{nullptr};
+        g_variant_get(call, "(v)", &vpid);
+        g_variant_unref(call);
+
+        pid_t pid;
+        pid = g_variant_get_uint32(vpid);
+        g_variant_unref(vpid);
+
+        return pid;
+    });
+}
+
+std::vector<pid_t> SystemD::unitPids(const AppID& appId, const std::string& job, const std::string& instance)
+{
+    auto registry = registry_.lock();
+    auto unitname = unitName(SystemD::UnitInfo{appId, job, instance});
+    auto unitpath = unitPath(unitname);
+
+    auto cgrouppath = registry->impl->thread.executeOnThread<std::string>([this, registry, unitname, unitpath]() {
+        GError* error{nullptr};
+        GVariant* call = g_dbus_connection_call_sync(
+            userbus_.get(),                                                            /* user bus */
+            SYSTEMD_DBUS_ADDRESS.c_str(),                                              /* bus name */
+            unitpath.c_str(),                                                          /* path */
+            "org.freedesktop.DBus.Properties",                                         /* interface */
+            "Get",                                                                     /* method */
+            g_variant_new("(ss)", SYSTEMD_DBUS_IFACE_SERVICE.c_str(), "ControlGroup"), /* params */
+            G_VARIANT_TYPE("(v)"),                                                     /* ret type */
+            G_DBUS_CALL_FLAGS_NONE,                                                    /* flags */
+            -1,                                                                        /* timeout */
+            registry->impl->thread.getCancellable().get(),                             /* cancellable */
+            &error);
+
+        if (error != nullptr)
+        {
+            auto message = std::string{"Unable to get SystemD Control Group for '"} + unitname + std::string{"': "} +
+                           error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        /* Parse variant */
+        GVariant* vstring = nullptr;
+        g_variant_get(call, "(v)", &vstring);
+        g_variant_unref(call);
+
+        if (vstring == nullptr)
+        {
+            return std::string{};
+        }
+
+        std::string group;
+        auto ggroup = g_variant_get_string(vstring, nullptr);
+        if (ggroup != nullptr)
+        {
+            group = ggroup;
+        }
+        g_variant_unref(vstring);
+
+        return group;
+    });
+
+    gchar* fullpath = g_build_filename("/sys", "fs", "cgroup", "systemd", cgrouppath.c_str(), "tasks", nullptr);
+    gchar* pidstr = nullptr;
+    GError* error = nullptr;
+
+    g_debug("Getting PIDs from %s", fullpath);
+    g_file_get_contents(fullpath, &pidstr, nullptr, &error);
+    g_free(fullpath);
+
+    if (error != nullptr)
+    {
+        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.c_str(),                    /* bus name */
+                                                     SYSTEMD_DBUS_PATH_MANAGER.c_str(),               /* path */
+                                                     SYSTEMD_DBUS_IFACE_MANAGER.c_str(),              /* interface */
+                                                     "StopUnit",                                      /* method */
+                                                     g_variant_new("(ss)", unitname.c_str(), "fail"), /* params */
+                                                     G_VARIANT_TYPE("(o)"),                           /* ret type */
+                                                     G_DBUS_CALL_FLAGS_NONE,                          /* flags */
+                                                     -1,                                              /* timeout */
+                                                     registry->impl->thread.getCancellable().get(),   /* cancellable */
+                                                     &error);
+
+        if (error != nullptr)
+        {
+            auto message =
+                std::string{"Unable to get SystemD to stop '"} + unitname + std::string{"': "} + error->message;
+            g_error_free(error);
+            throw std::runtime_error(message);
+        }
+
+        g_variant_unref(call);
+
+        return true;
+    });
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& SystemD::appStarted()
+{
+    g_warning("Systemd signals not implemented");
+    return sig_appStarted;
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& SystemD::appStopped()
+{
+    g_warning("Systemd signals not implemented");
+    return sig_appStopped;
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, Registry::FailureType>&
+    SystemD::appFailed()
+{
+    g_warning("Systemd signals not implemented");
+    return sig_appFailed;
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    SystemD::appPaused()
+{
+    g_warning("Systemd signals not implemented");
+    return sig_appPaused;
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    SystemD::appResumed()
+{
+    g_warning("Systemd signals not implemented");
+    return sig_appResumed;
+}
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/jobs-systemd.h'
--- libubuntu-app-launch/jobs-systemd.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-systemd.h	2016-11-10 21:59:02 +0000
@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#pragma once
+
+#include "jobs-base.h"
+#include <chrono>
+#include <gio/gio.h>
+#include <map>
+#include <mutex>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace manager
+{
+
+class SystemD : public Base
+{
+public:
+    SystemD(std::shared_ptr<Registry> registry);
+    virtual ~SystemD();
+
+    virtual std::shared_ptr<Application::Instance> launch(
+        const AppID& appId,
+        const std::string& job,
+        const std::string& instance,
+        const std::vector<Application::URL>& urls,
+        launchMode mode,
+        std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv) override;
+    virtual std::shared_ptr<Application::Instance> existing(const AppID& appId,
+                                                            const std::string& job,
+                                                            const std::string& instance,
+                                                            const std::vector<Application::URL>& urls) override;
+
+    virtual std::list<std::shared_ptr<Application>> runningApps() override;
+
+    virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) override;
+
+    virtual core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStarted() override;
+    virtual core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStopped() override;
+    virtual core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, Registry::FailureType>&
+        appFailed() override;
+    virtual core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+        appPaused() override;
+    virtual core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+        appResumed() override;
+
+    static std::string userBusPath();
+
+    pid_t unitPrimaryPid(const AppID& appId, const std::string& job, const std::string& instance);
+    std::vector<pid_t> unitPids(const AppID& appId, const std::string& job, const std::string& instance);
+    void stopUnit(const AppID& appId, const std::string& job, const std::string& instance);
+
+private:
+    std::shared_ptr<GDBusConnection> userbus_;
+
+    /* ssssssouso */
+    struct UnitEntry
+    {
+        std::string id;
+        std::string description;
+        std::string loadState;
+        std::string activeState;
+        std::string subState;
+        std::string following;
+        std::string path;
+        std::uint32_t jobId;
+        std::string jobType;
+        std::string jobPath;
+    };
+    std::list<UnitEntry> listUnits();
+
+    struct UnitInfo
+    {
+        std::string appid;
+        std::string job;
+        std::string inst;
+    };
+    UnitInfo parseUnit(const std::string& unit);
+    std::string unitName(const UnitInfo& info);
+
+    struct UnitPath
+    {
+        std::string unitName;
+        std::string unitPath;
+        std::chrono::time_point<std::chrono::system_clock> timeStamp;
+    };
+    std::list<UnitPath> unitPaths_;
+    std::mutex unitPathsMutex_;
+    std::string unitPath(const std::string& unitName);
+
+    static std::string findEnv(const std::string& value, std::list<std::pair<std::string, std::string>>& env);
+    static void copyEnv(const std::string& envname, std::list<std::pair<std::string, std::string>>& env);
+    static void copyEnvByPrefix(const std::string& prefix, std::list<std::pair<std::string, std::string>>& env);
+
+    static std::vector<std::string> parseExec(std::list<std::pair<std::string, std::string>>& env);
+    static void application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data);
+};
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu

=== modified file 'libubuntu-app-launch/jobs-upstart.cpp'
--- libubuntu-app-launch/jobs-upstart.cpp	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/jobs-upstart.cpp	2016-11-10 21:59:02 +0000
@@ -73,8 +73,6 @@
 private:
     std::string upstartJobPath(const std::string& job);
     std::string upstartName();
-
-    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
@@ -306,29 +304,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	2016-11-10 21:59:01 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2016-11-10 21:59:02 +0000
@@ -144,7 +144,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-10-03 23:54:08 +0000
+++ libubuntu-app-launch/snapd-info.cpp	2016-11-10 21:59:02 +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/exec-util-test.cc'
--- tests/exec-util-test.cc	2016-09-15 17:13:04 +0000
+++ tests/exec-util-test.cc	2016-11-10 21:59:02 +0000
@@ -45,6 +45,7 @@
 			g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
 			g_setenv("UBUNTU_APP_LAUNCH_LIBERTINE_LAUNCH", "libertine-launch", TRUE);
 			g_setenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET", "/this/should/not/exist", TRUE);
+			g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
 
 			service = dbus_test_service_new(NULL);
 
@@ -184,12 +185,15 @@
 			EXPECT_STREQ("grep", value); }},
 		{"APP_ID", [](const gchar * value) {
 			EXPECT_STREQ("com.test.good_application_1.2.3", value); }},
+		{"APP_EXEC_POLICY", [](const gchar * value) {
+			EXPECT_STREQ("com.test.good_application_1.2.3", value); }},
 		{"APP_LAUNCHER_PID", [](const gchar * value) {
 			EXPECT_EQ(getpid(), atoi(value)); }},
 		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
 			EXPECT_STREQ(APP_DIR "/application.desktop", value); }},
 		{"APP_XMIR_ENABLE", [](const gchar * value) {
 			EXPECT_STREQ("0", value); }},
+		{"QML2_IMPORT_PATH", nocheck},
 	});
 
 #undef APP_DIR
@@ -267,10 +271,13 @@
 		{"APP_EXEC", nocheck},
 		{"APP_ID", [](const gchar * value) {
 			EXPECT_STREQ("com.test.mir_mir_1", value); }},
+		{"APP_EXEC_POLICY", [](const gchar * value) {
+			EXPECT_STREQ("com.test.mir_mir_1", value); }},
 		{"APP_LAUNCHER_PID", nocheck},
 		{"APP_DESKTOP_FILE_PATH", nocheck},
 		{"APP_XMIR_ENABLE", [](const gchar * value) {
 			EXPECT_STREQ("1", value); }},
+		{"QML2_IMPORT_PATH", nocheck},
 	});
 }
 
@@ -289,10 +296,13 @@
 		{"APP_EXEC", nocheck},
 		{"APP_ID", [](const gchar * value) {
 			EXPECT_STREQ("com.test.mir_nomir_1", value); }},
+		{"APP_EXEC_POLICY", [](const gchar * value) {
+			EXPECT_STREQ("com.test.mir_nomir_1", value); }},
 		{"APP_LAUNCHER_PID", nocheck},
 		{"APP_DESKTOP_FILE_PATH", nocheck},
 		{"APP_XMIR_ENABLE", [](const gchar * value) {
 			EXPECT_STREQ("0", value); }},
+		{"QML2_IMPORT_PATH", nocheck},
 	});
 }
 

=== modified file 'tests/libual-cpp-test.cc'
--- tests/libual-cpp-test.cc	2016-11-10 21:59:01 +0000
+++ tests/libual-cpp-test.cc	2016-11-10 21:59:02 +0000
@@ -149,6 +149,7 @@
         g_setenv("UBUNTU_APP_LAUNCH_DISABLE_SNAPD_TIMEOUT", "You betcha!", TRUE);
         g_unlink(SNAPD_TEST_SOCKET);
 #endif
+        g_setenv("UBUNTU_APP_LAUNCH_SYSTEMD_PATH", "/this/should/not/exist", TRUE);
 
         service = dbus_test_service_new(NULL);
 

=== modified file 'tests/libual-test.cc'
--- tests/libual-test.cc	2016-09-14 15:29:35 +0000
+++ tests/libual-test.cc	2016-11-10 21:59:02 +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);
 

=== modified file 'xmir-helper.c'
--- xmir-helper.c	2015-08-11 02:41:08 +0000
+++ xmir-helper.c	2016-11-10 21:59:02 +0000
@@ -86,6 +86,8 @@
 			NULL
 		};
 
+		printf("Executing XMir on PID: %d", getpid());
+
 		return execv(xmir, xmirexec);
 	}