Merge lp:~thomas-voss/trust-store/watch-service-name-owner-changes into lp:trust-store/15.04

[Thomas Voß]

core::trust::dbus::Agent::Skeleton now watches for name owner changes, announcing itself
asynchronously if a new name owner is detected.

core::trust::dbus::Agent::Skeleton now watches for name owner changes, announcing itself
asynchronously if a new name owner is detected.

[lp:~thomas-voss/trust-store/watch-service-name-owner-changes]

138. By Thomas Voß on 2016-01-03

Make core::trust::Runtime a proper class and do not expose its internals anymore.

139. By Thomas Voß on 2016-01-03

Address a few minor niggles regarding object lifetimes and noexcept(true) guarantees.

140. By Thomas Voß on 2016-01-04

Wait a little longer to account for slow builders.

141. By Thomas Voß on 2016-01-04

Link correct bug report.

Unmerged revisions

141. By Thomas Voß on 2016-01-04

Link correct bug report.

140. By Thomas Voß on 2016-01-04

Wait a little longer to account for slow builders.

139. By Thomas Voß on 2016-01-03

Address a few minor niggles regarding object lifetimes and noexcept(true) guarantees.

138. By Thomas Voß on 2016-01-03

Make core::trust::Runtime a proper class and do not expose its internals anymore.

137. By Thomas Voß on 2016-01-03

core::trust::dbus::Agent::Skeleton now watches for name owner changes, announcing itself
asynchronously if a new name owner is detected.

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-08-31 13:16:20 +0000
+++ src/CMakeLists.txt	2016-01-04 15:02:54 +0000
@@ -149,6 +149,9 @@
   trust-stored
 
   core/trust/daemon.cpp
+
+  core/trust/runtime.h
+  core/trust/runtime.cpp
 )
 
 add_executable(

=== modified file 'src/core/trust/daemon.cpp'
--- src/core/trust/daemon.cpp	2015-08-31 14:00:41 +0000
+++ src/core/trust/daemon.cpp	2016-01-04 15:02:54 +0000
@@ -22,6 +22,7 @@
 #include <core/trust/cached_agent.h>
 #include <core/trust/expose.h>
 #include <core/trust/i18n.h>
+#include <core/trust/runtime.h>
 #include <core/trust/store.h>
 #include <core/trust/white_listing_agent.h>
 
@@ -49,67 +50,6 @@
 
 namespace
 {
-    struct Runtime
-    {
-        // Do not execute in parallel, serialize
-        // accesses.
-        static constexpr std::size_t concurrency_hint{2};
-
-        // Our evil singleton pattern. Not bad though, we control the
-        // entire executable and rely on automatic cleanup of static
-        // instances.
-        static Runtime& instance()
-        {
-            static Runtime runtime;
-            return runtime;
-        }
-
-        ~Runtime()
-        {
-            io_service.stop();
-
-            if (worker1.joinable())
-                worker1.join();
-
-            if (worker2.joinable())
-                worker2.join();
-        }
-
-        // We trap sig term to ensure a clean shutdown.
-        std::shared_ptr<core::posix::SignalTrap> signal_trap
-        {
-            core::posix::trap_signals_for_all_subsequent_threads(
-            {
-                core::posix::Signal::sig_term,
-                core::posix::Signal::sig_int
-            })
-        };
-
-        // Our io_service instance exposed to remote agents.
-        boost::asio::io_service io_service
-        {
-            concurrency_hint
-        };
-
-        // We keep the io_service alive and introduce some artificial
-        // work.
-        boost::asio::io_service::work keep_alive
-        {
-            io_service
-        };
-
-        // We immediate execute the io_service instance
-        std::thread worker1
-        {
-            std::thread{[this]() { io_service.run(); }}
-        };
-
-        std::thread worker2
-        {
-            std::thread{[this]() { io_service.run(); }}
-        };
-    };
-
     core::trust::Daemon::Dictionary fill_dictionary_from_unrecognized_options(const Options::parsed_options& parsed_options)
     {
         auto unrecognized = Options::collect_unrecognized(
@@ -170,7 +110,7 @@
             "Could not create bus for name: " + bus_name
         };
 
-        bus->install_executor(core::dbus::asio::make_executor(bus, Runtime::instance().io_service));
+        bus->install_executor(core::trust::Runtime::instance().make_executor_for_bus(bus));
 
         return bus;
     }
@@ -256,7 +196,7 @@
                 core::trust::remote::posix::Skeleton::Configuration config
                 {
                     agent,
-                    Runtime::instance().io_service,
+                    core::trust::Runtime::instance().service(),
                     boost::asio::local::stream_protocol::endpoint{dict.at("endpoint")},
                     core::trust::remote::helpers::proc_stat_start_time_resolver(),
                     core::trust::remote::helpers::aa_get_task_con_app_id_resolver(),
@@ -289,16 +229,19 @@
                                 core::trust::remote::dbus::default_agent_registry_path
                             });
 
+                core::dbus::DBus daemon{bus};
+
                 core::trust::remote::dbus::Agent::Skeleton::Configuration config
                 {
                     agent,
                     object,
+                    daemon.make_service_watcher(dbus_service_name),
                     service,
                     bus,
                     core::trust::remote::helpers::aa_get_task_con_app_id_resolver()
                 };
 
-                return std::make_shared<core::trust::remote::dbus::Agent::Skeleton>(config);
+                return std::make_shared<core::trust::remote::dbus::Agent::Skeleton>(std::move(config));
             }
         }
     };
@@ -390,16 +333,6 @@
 // Executes the daemon with the given configuration.
 core::posix::exit::Status core::trust::Daemon::Skeleton::main(const core::trust::Daemon::Skeleton::Configuration& configuration)
 {
-    Runtime::instance().signal_trap->signal_raised().connect([](core::posix::Signal)
-    {
-        Runtime::instance().signal_trap->stop();
-    });
-
-    std::thread worker
-    {
-        [configuration]() { configuration.bus->run(); }
-    };
-
     // Expose the local store to the bus, keeping it exposed for the
     // lifetime of the returned token.
     auto token = core::trust::expose_store_to_bus_with_name(
@@ -407,12 +340,7 @@
                 configuration.bus,
                 configuration.service_name);
 
-    Runtime::instance().signal_trap->run();
-
-    configuration.bus->stop();
-
-    if (worker.joinable())
-        worker.join();
+    core::trust::Runtime::instance().run();
 
     return core::posix::exit::Status::success;
 }
@@ -432,7 +360,7 @@
 
                 core::trust::remote::posix::Stub::Configuration config
                 {
-                    Runtime::instance().io_service,
+                    core::trust::Runtime::instance().service(),
                     boost::asio::local::stream_protocol::endpoint{dict.at("endpoint")},
                     core::trust::remote::helpers::proc_stat_start_time_resolver(),
                     core::trust::remote::posix::Stub::get_sock_opt_credentials_resolver(),
@@ -522,13 +450,18 @@
 // A user can feed a request to the stub.
 struct Shell : public std::enable_shared_from_this<Shell>
 {
-    Shell(const std::shared_ptr<core::trust::Agent>& agent)
+    Shell(const std::shared_ptr<core::trust::Agent>& agent, boost::asio::io_service& ios)
         : agent{agent},
-          stdin{Runtime::instance().io_service, STDIN_FILENO},
+          stdin{ios, STDIN_FILENO},
           app_id_resolver{core::trust::remote::helpers::aa_get_task_con_app_id_resolver()}
     {
     }
 
+    ~Shell()
+    {
+        stop();
+    }
+
     // Prints out the initial prompt and initiates a read operation on stdin.
     void start()
     {
@@ -605,20 +538,13 @@
 core::posix::exit::Status core::trust::Daemon::Stub::main(const core::trust::Daemon::Stub::Configuration& configuration)
 {
     // We setup our minimal shell here.
-    auto shell = std::make_shared<Shell>(configuration.remote.agent);
-
-    Runtime::instance().signal_trap->signal_raised().connect([](core::posix::Signal)
-    {
-        Runtime::instance().signal_trap->stop();
-    });
+    auto shell = std::make_shared<Shell>(configuration.remote.agent, core::trust::Runtime::instance().service());
 
     // We start up our shell
     shell->start();
 
     // Wait until signal arrives.
-    Runtime::instance().signal_trap->run();
-
-    shell->stop();
+    core::trust::Runtime::instance().run();
 
     return core::posix::exit::Status::success;
 }

=== modified file 'src/core/trust/dbus/agent_registry.h'
--- src/core/trust/dbus/agent_registry.h	2014-08-04 07:10:52 +0000
+++ src/core/trust/dbus/agent_registry.h	2016-01-04 15:02:54 +0000
@@ -114,8 +114,10 @@
     };
 
     // A DBus stub implementation of core::trust::AgentRegistry.
-    struct Stub : public core::trust::Agent::Registry
+    class Stub : public std::enable_shared_from_this<Stub>,
+                 public core::trust::Agent::Registry
     {
+    public:
         // Functor for generating unique object paths.
         typedef std::function<core::dbus::types::ObjectPath(const core::trust::Uid&)> ObjectPathGenerator;
 
@@ -139,12 +141,12 @@
             core::dbus::Service::Ptr service;
             // The underlying bus instance.
             core::dbus::Bus::Ptr bus;
-        };
+        };        
 
-        // Initializes stub access to the Stub.
-        Stub(const Configuration& configuration)
-            : configuration(configuration)
+        // create returns a new shared Stub instance for configuration.
+        static std::shared_ptr<Stub> create(const Configuration& configuration)
         {
+            return std::shared_ptr<Stub>(new Stub(configuration));
         }
 
         // Calls into the remote implementation to register the given agent implementation.
@@ -179,6 +181,46 @@
             locking_agent_registry.register_agent_for_user(uid, skeleton);
         }
 
+        // Calls into the remote implementation to register the given agent implementation.
+        // Throws std::runtime_error and std::logic_error in case of issues.
+        void register_agent_for_user_async(const core::trust::Uid& uid, const std::shared_ptr<core::trust::Agent>& impl, const std::function<void()>& then)
+        {
+            // We sample a path for the given uid
+            auto path = configuration.object_path_generator(uid);
+            // And construct the skeleton instance.
+            auto skeleton = std::shared_ptr<core::trust::dbus::Agent::Skeleton>
+            {
+                new core::trust::dbus::Agent::Skeleton
+                {
+                    core::trust::dbus::Agent::Skeleton::Configuration
+                    {
+                        configuration.service->add_object_for_path(path),
+                        configuration.bus,
+                        std::bind(&core::trust::Agent::authenticate_request_with_parameters, impl, std::placeholders::_1)
+                    }
+                }
+            };
+
+            auto sp = shared_from_this();
+
+            // And announce the agent.
+            configuration.object->invoke_method_asynchronously_with_callback<
+                Methods::RegisterAgentForUser, void
+            >([this, sp, then, uid, skeleton](const core::dbus::Result<void>& result)
+            {
+                if (result.is_error())
+                {
+                    std::cerr << "Failed to register agent for user: " << result.error().print() << std::endl;
+                }
+                else
+                {
+                    // All good, update our own state prior to invoking the supplied callback.
+                    locking_agent_registry.register_agent_for_user(uid, skeleton);
+                    then();
+                }
+            }, uid, path);
+        }
+
         // Calls into the remote implementation to unregister any agent registered for the given uid.
         // Throws std::runtime_error and std::logic_error in case of issues.
         void unregister_agent_for_user(const core::trust::Uid& uid) override
@@ -195,6 +237,13 @@
             };
         }
 
+    private:
+        // Initializes stub access to the Stub.
+        Stub(const Configuration& configuration)
+            : configuration(configuration)
+        {
+        }
+
         // We just store all creation-time arguments.
         Configuration configuration;
         // Our local registry of agents

=== modified file 'src/core/trust/remote/dbus.cpp'
--- src/core/trust/remote/dbus.cpp	2014-07-29 17:00:35 +0000
+++ src/core/trust/remote/dbus.cpp	2016-01-04 15:02:54 +0000
@@ -19,6 +19,7 @@
 #include <core/trust/remote/dbus.h>
 
 #include <core/trust/dbus_agent.h>
+#include <core/trust/runtime.h>
 
 core::trust::remote::dbus::Agent::Stub::Stub(const core::trust::remote::dbus::Agent::Stub::Configuration& configuration)
     : agent_registry_skeleton
@@ -43,20 +44,31 @@
     return agent->authenticate_request_with_parameters(parameters);
 }
 
-core::trust::remote::dbus::Agent::Skeleton::Skeleton(const core::trust::remote::dbus::Agent::Skeleton::Configuration& configuration)
+core::trust::remote::dbus::Agent::Skeleton::Skeleton(core::trust::remote::dbus::Agent::Skeleton::Configuration configuration)
     : core::trust::remote::Agent::Skeleton{configuration.impl},
+      config(std::move(configuration)),
       agent_registry_stub
       {
-          core::trust::dbus::AgentRegistry::Stub::Configuration
-          {
-              configuration.agent_registry_object,
-              core::trust::dbus::AgentRegistry::Stub::counting_object_path_generator(),
-              configuration.service,
-              configuration.bus
-          }
+          core::trust::dbus::AgentRegistry::Stub::create(
+              core::trust::dbus::AgentRegistry::Stub::Configuration
+              {
+                  config.agent_registry_object,
+                  core::trust::dbus::AgentRegistry::Stub::counting_object_path_generator(),
+                  config.service,
+                  config.bus
+              })
       }
 {
-    agent_registry_stub.register_agent_for_user(core::trust::Uid{::getuid()}, configuration.impl);
+    static const auto printing_cb = []() { std::cout << "Successfully registered agent for user." << std::endl; };
+
+    agent_registry_stub->register_agent_for_user_async(core::trust::Uid{::getuid()}, config.impl, printing_cb);
+
+    // We don't have to track the lifetime of "this" as config.agent_registry_watcher is owned
+    // by "this".
+    config.agent_registry_watcher->service_registered().connect([this]()
+    {
+        agent_registry_stub->register_agent_for_user_async(core::trust::Uid{::getuid()}, config.impl, printing_cb);
+    });
 }
 
 core::trust::Request::Answer core::trust::remote::dbus::Agent::Skeleton::authenticate_request_with_parameters(const core::trust::Agent::RequestParameters& parameters)

=== modified file 'src/core/trust/remote/dbus.h'
--- src/core/trust/remote/dbus.h	2014-08-04 07:57:05 +0000
+++ src/core/trust/remote/dbus.h	2016-01-04 15:02:54 +0000
@@ -25,6 +25,8 @@
 #include <core/trust/dbus/agent.h>
 #include <core/trust/dbus/agent_registry.h>
 
+#include <core/dbus/service_watcher.h>
+
 #include <unistd.h>
 #include <sys/types.h>
 
@@ -86,6 +88,8 @@
             std::shared_ptr<Agent> impl;
             // The remote object implementing core.trust.dbus.AgentRegistry.
             core::dbus::Object::Ptr agent_registry_object;
+            // The watcher monitoring the remote object implementing core.trust.dbus.AgentRegistry.
+            std::unique_ptr<core::dbus::ServiceWatcher> agent_registry_watcher;
             // The service that objects implementing core.trust.dbus.Agent should be added to.
             core::dbus::Service::Ptr service;
             // The underlying bus instance.
@@ -95,13 +99,15 @@
         };
 
         // Constructs a new Skeleton instance, installing impl for handling actual requests.
-        Skeleton(const Configuration& configuration);
+        Skeleton(Configuration configuration);
 
         // From core::trust::Agent, dispatches to the actual implementation.
         core::trust::Request::Answer authenticate_request_with_parameters(const RequestParameters& parameters);
 
+        // Store all creation-time parameters.
+        Configuration config;
         // Stub for accessing the remote agent registry.
-        core::trust::dbus::AgentRegistry::Stub agent_registry_stub;
+        std::shared_ptr<core::trust::dbus::AgentRegistry::Stub> agent_registry_stub;
     };
 };
 }

=== added file 'src/core/trust/runtime.cpp'
--- src/core/trust/runtime.cpp	1970-01-01 00:00:00 +0000
+++ src/core/trust/runtime.cpp	2016-01-04 15:02:54 +0000
@@ -0,0 +1,105 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <core/trust/runtime.h>
+
+#include <core/dbus/asio/executor.h>
+
+#include <iostream>
+#include <stdexcept>
+
+namespace
+{
+void execute_and_never_throw(boost::asio::io_service& ios) noexcept(true)
+{
+    while (true)
+    {
+        try
+        {
+            ios.run();
+            break;
+        }
+        catch (const std::exception& e)
+        {
+            std::cerr << __PRETTY_FUNCTION__ << ": " << e.what() << std::endl;
+        }
+        catch (...)
+        {
+            std::cerr << __PRETTY_FUNCTION__ << ": unknown exception" << std::endl;
+        }
+    }
+}
+}
+
+core::trust::Runtime& core::trust::Runtime::instance()
+{
+    static Runtime runtime;
+    return runtime;
+}
+
+core::trust::Runtime::Runtime()
+    : signal_trap{core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_term, core::posix::Signal::sig_int})},
+      keep_alive{io_service}
+{
+    for (std::size_t i = 0; i < Runtime::concurrency_hint; i++)
+    {
+        pool.emplace_back(execute_and_never_throw, std::ref(io_service));
+    }
+
+    signal_trap->signal_raised().connect([this](const core::posix::Signal&)
+    {
+        stop();
+    });
+}
+
+core::trust::Runtime::~Runtime()
+{
+    try
+    {
+        io_service.stop();
+
+        for (auto& worker : pool)
+            if (worker.joinable())
+                worker.join();
+    }
+    catch (...)
+    {
+        // Empty on purpose. We just have to
+        // fulfill the noexcept(true) guarantee.
+    }
+}
+
+void core::trust::Runtime::run()
+{
+    signal_trap->run();
+}
+
+void core::trust::Runtime::stop()
+{
+    signal_trap->stop();
+}
+
+boost::asio::io_service& core::trust::Runtime::service()
+{
+    return io_service;
+}
+
+core::dbus::Executor::Ptr core::trust::Runtime::make_executor_for_bus(const core::dbus::Bus::Ptr& bus)
+{
+    return core::dbus::asio::make_executor(bus, io_service);
+}

=== added file 'src/core/trust/runtime.h'
--- src/core/trust/runtime.h	1970-01-01 00:00:00 +0000
+++ src/core/trust/runtime.h	2016-01-04 15:02:54 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef CORE_TRUST_RUNTIME_H_
+#define CORE_TRUST_RUNTIME_H_
+
+#include <core/posix/signal.h>
+
+#include <core/dbus/bus.h>
+#include <core/dbus/executor.h>
+
+#include <boost/asio.hpp>
+
+#include <memory>
+#include <thread>
+#include <vector>
+
+namespace core
+{
+namespace trust
+{
+// A Runtime maintains a pool of workers enabling
+// implementations to dispatch invocations and have their
+// ready handlers automatically executed.
+class Runtime
+{
+public:
+    // Do not execute in parallel, serialize
+    // accesses.
+    static constexpr std::size_t concurrency_hint{2};
+
+    // Our evil singleton pattern. Not bad though, we control the
+    // entire executable and rely on automatic cleanup of static
+    // instances.
+    static Runtime& instance();
+
+    // Gracefully shuts down operations.
+    ~Runtime() noexcept(true);
+
+    // run blocks until either stop is called or a
+    // signal requesting graceful shutdown is received.
+    void run();
+
+    // requests the runtime to shut down, does not block.
+    void stop();
+
+    // Returns a mutable reference to the underlying boost::asio::io_service
+    // powering the runtime's reactor.
+    boost::asio::io_service& service();
+
+    // Creates an executor for a bus instance hooking into this Runtime instance.
+    core::dbus::Executor::Ptr make_executor_for_bus(const core::dbus::Bus::Ptr& bus);
+
+private:
+    Runtime();
+
+    // We trap sig term to ensure a clean shutdown.
+    std::shared_ptr<core::posix::SignalTrap> signal_trap;
+
+    // Our io_service instance exposed to remote agents.
+    boost::asio::io_service io_service;
+
+    // We keep the io_service alive and introduce some artificial
+    // work.
+    boost::asio::io_service::work keep_alive;
+
+    // We execute the io_service on a pool of worker threads.
+    std::vector<std::thread> pool;
+};
+}
+}
+
+#endif // CORE_TRUST_RUNTIME_H_

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-11-14 12:17:24 +0000
+++ tests/CMakeLists.txt	2016-01-04 15:02:54 +0000
@@ -46,6 +46,9 @@
 add_executable(
   remote_agent_test
   remote_agent_test.cpp
+
+  ${CMAKE_SOURCE_DIR}/src/core/trust/runtime.h
+  ${CMAKE_SOURCE_DIR}/src/core/trust/runtime.cpp
 )
 
 add_executable(

=== modified file 'tests/dbus_test.cpp'
--- tests/dbus_test.cpp	2014-08-04 08:32:57 +0000
+++ tests/dbus_test.cpp	2016-01-04 15:02:54 +0000
@@ -370,21 +370,19 @@
                         InvokeWithoutArgs(&state, &State::notify),
                         Return(core::trust::Request::Answer::denied)));
 
-        core::trust::dbus::AgentRegistry::Stub stub
-        {
+        auto stub = core::trust::dbus::AgentRegistry::Stub::create(
             core::trust::dbus::AgentRegistry::Stub::Configuration
             {
                 agent_registry_object,
                 core::trust::dbus::AgentRegistry::Stub::counting_object_path_generator(),
                 service,
                 bus
-            }
-        };
+            });
 
         std::thread t{[bus]() { bus->run(); }};
 
         // We register for the current user id.
-        stub.register_agent_for_user(core::trust::Uid{::getuid()}, agent);
+        stub->register_agent_for_user(core::trust::Uid{::getuid()}, agent);
 
         // Tell the other side that we are good to go.
         agent_registered.try_signal_ready_for(std::chrono::milliseconds{500});
@@ -393,7 +391,7 @@
         state.wait();
 
         // And unregister again.
-        stub.unregister_agent_for_user(core::trust::Uid{::getuid()});
+        stub->unregister_agent_for_user(core::trust::Uid{::getuid()});
 
         bus->stop();
 

=== modified file 'tests/remote_agent_test.cpp'
--- tests/remote_agent_test.cpp	2015-08-14 09:53:12 +0000
+++ tests/remote_agent_test.cpp	2016-01-04 15:02:54 +0000
@@ -30,6 +30,8 @@
 #include <core/dbus/asio/executor.h>
 #include <core/dbus/fixture.h>
 
+#include <core/trust/runtime.h>
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -792,6 +794,12 @@
 {
 struct DBus : public core::dbus::testing::Fixture
 {
+    core::dbus::Bus::Ptr session_bus_with_executor()
+    {
+        auto sb = session_bus();
+        sb->install_executor(core::trust::Runtime::instance().make_executor_for_bus(sb));
+        return sb;
+    }
 };
 
 std::string service_name
@@ -804,10 +812,6 @@
 {
     using namespace ::testing;
 
-    core::testing::CrossProcessSync
-            stub_ready,         // signals stub     --| I'm ready |--> skeleton
-            skeleton_ready;     // signals skeleton --| I'm ready |--> stub
-
     auto app = core::posix::fork([]()
     {
         while(true) std::this_thread::sleep_for(std::chrono::milliseconds{500});
@@ -825,7 +829,50 @@
     const core::trust::Uid app_uid{::getuid()};
     const core::trust::Pid app_pid{app.pid()};
 
-    auto stub = core::posix::fork([this, app_uid, app_pid, answer, &stub_ready, &skeleton_ready]()
+    auto skeleton = core::posix::fork([this, answer]()
+    {
+        auto bus = session_bus_with_executor();
+
+        // We have to rely on a MockAgent to break the dependency on a running Mir instance.
+        auto mock_agent = std::make_shared<::testing::NiceMock<MockAgent>>();
+
+        ON_CALL(*mock_agent, authenticate_request_with_parameters(_))
+                .WillByDefault(Return(answer));
+
+        std::string dbus_service_name = core::trust::remote::dbus::default_service_name_prefix + std::string{"."} + service_name;
+
+        auto service = core::dbus::Service::use_service(bus, dbus_service_name);
+        auto object = service->object_for_path(core::dbus::types::ObjectPath
+        {
+            core::trust::remote::dbus::default_agent_registry_path
+        });
+
+        core::dbus::DBus daemon{bus};
+
+        core::trust::remote::dbus::Agent::Skeleton::Configuration config
+        {
+            mock_agent,
+            object,
+            daemon.make_service_watcher(dbus_service_name),
+            service,
+            bus,
+            core::trust::remote::helpers::aa_get_task_con_app_id_resolver()
+        };
+
+        auto skeleton = std::make_shared<core::trust::remote::dbus::Agent::Skeleton>(std::move(config));
+
+        core::trust::Runtime::instance().run();
+        return core::posix::exit::Status::success;
+    }, core::posix::StandardStream::empty);
+
+
+    // stubf models a trusted helper, with the following simplified
+    // mode of operation:
+    //   (1.) Helper claims its unique name on the bus.
+    //   (2.) Helper installs an AgentRegistry::Skeleton.
+    //   (3.) Helper learns about per-user trust::Agent instances on the bus.
+    //   (4.) Helper issues requests for authentication.
+    auto stubf = [this, app_uid, app_pid, answer]()
     {
         core::trust::Agent::RequestParameters ref_params
         {
@@ -836,10 +883,7 @@
             "just an example description"
         };
 
-        auto bus = session_bus();
-        bus->install_executor(core::dbus::asio::make_executor(bus));
-
-        std::thread worker{[bus]() { bus->run(); }};
+        auto bus = session_bus_with_executor();
 
         std::string dbus_service_name = core::trust::remote::dbus::default_service_name_prefix + std::string{"."} + service_name;
 
@@ -857,76 +901,24 @@
 
         auto stub = std::make_shared<core::trust::remote::dbus::Agent::Stub>(config);
 
-        stub_ready.try_signal_ready_for(std::chrono::milliseconds{1000});
-        skeleton_ready.wait_for_signal_ready_for(std::chrono::milliseconds{1000});
+        std::this_thread::sleep_for(std::chrono::seconds(10));
 
         for (unsigned int i = 0; i < 100; i++)
             EXPECT_EQ(answer, stub->authenticate_request_with_parameters(ref_params));
 
-        bus->stop();
-
-        if (worker.joinable())
-            worker.join();
-
         return Test::HasFailure() ?
                     core::posix::exit::Status::failure :
                     core::posix::exit::Status::success;
-    }, core::posix::StandardStream::empty);
-
-    auto skeleton = core::posix::fork([this, answer, &stub_ready, &skeleton_ready]()
-    {
-        auto trap = core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_term});
-
-        trap->signal_raised().connect([trap](core::posix::Signal)
-        {
-            trap->stop();
-        });
-
-        auto bus = session_bus();
-        bus->install_executor(core::dbus::asio::make_executor(bus));
-
-        std::thread worker{[bus]() { bus->run(); }};
-
-        // We have to rely on a MockAgent to break the dependency on a running Mir instance.
-        auto mock_agent = std::make_shared<::testing::NiceMock<MockAgent>>();
-
-        ON_CALL(*mock_agent, authenticate_request_with_parameters(_))
-                .WillByDefault(Return(answer));
-
-        std::string dbus_service_name = core::trust::remote::dbus::default_service_name_prefix + std::string{"."} + service_name;
-
-        stub_ready.wait_for_signal_ready_for(std::chrono::milliseconds{1000});
-
-        auto service = core::dbus::Service::use_service(bus, dbus_service_name);
-        auto object = service->object_for_path(core::dbus::types::ObjectPath
-        {
-            core::trust::remote::dbus::default_agent_registry_path
-        });
-
-        core::trust::remote::dbus::Agent::Skeleton::Configuration config
-        {
-            mock_agent,
-            object,
-            service,
-            bus,
-            core::trust::remote::helpers::aa_get_task_con_app_id_resolver()
-        };
-
-        auto skeleton = std::make_shared<core::trust::remote::dbus::Agent::Skeleton>(config);
-
-        skeleton_ready.try_signal_ready_for(std::chrono::milliseconds{1000});
-
-        trap->run();
-
-        bus->stop();
-
-        if (worker.joinable())
-            worker.join();
-
-        return core::posix::exit::Status::success;
-    }, core::posix::StandardStream::empty);
-
-    EXPECT_TRUE(ProcessExitedSuccessfully(stub.wait_for(core::posix::wait::Flags::untraced)));
+    };
+
+    std::this_thread::sleep_for(std::chrono::seconds(2));
+    auto stub = core::posix::fork(stubf, core::posix::StandardStream::empty);
+    EXPECT_TRUE(ProcessExitedSuccessfully(stub.wait_for(core::posix::wait::Flags::untraced)));
+
+    std::this_thread::sleep_for(std::chrono::seconds(2));
+    stub = core::posix::fork(stubf, core::posix::StandardStream::empty);
+    EXPECT_TRUE(ProcessExitedSuccessfully(stub.wait_for(core::posix::wait::Flags::untraced)));
+
     skeleton.send_signal_or_throw(core::posix::Signal::sig_term);
     EXPECT_TRUE(ProcessExitedSuccessfully(skeleton.wait_for(core::posix::wait::Flags::untraced)));