Merge lp:~thomas-voss/location-service/add-standalone-provider-runner into lp:location-service/trunk

[Thomas Voß]

Add a standalone daemon for executing providers out of process.

Add a standalone daemon for executing providers out of process.

[lp:~thomas-voss/location-service/add-standalone-provider-runner]

115. By Thomas Voß on 2014-09-17

Adjust copyright years.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:114
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~thomas-voss/location-service/add-standalone-provider-runner/+merge/234941/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/location-service-ci/286/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/location-service-utopic-amd64-ci/193/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/location-service-utopic-armhf-ci/193/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/location-service-utopic-i386-ci/193/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/location-service-ci/286/rebuild

review: Needs Fixing (continuous-integration)

[Manuel de la Peña (mandel)]

review: Approve

[lp:~thomas-voss/location-service/add-standalone-provider-runner]

116. By Thomas Voß on 2014-09-17

Install provider daemon.

=== modified file 'debian/ubuntu-location-service-bin.install'
--- debian/ubuntu-location-service-bin.install	2014-07-31 12:12:43 +0000
+++ debian/ubuntu-location-service-bin.install	2014-09-17 13:26:40 +0000
@@ -1,5 +1,6 @@
 etc/dbus-1/system.d/
 etc/init/*
 usr/share/upstart/sessions/ubuntu-location-service-trust-stored.conf
+usr/bin/ubuntu-location-service-providerd
 usr/bin/ubuntu-location-serviced
 usr/bin/ubuntu-location-serviced-cli

=== modified file 'src/location_service/com/ubuntu/location/CMakeLists.txt'
--- src/location_service/com/ubuntu/location/CMakeLists.txt	2014-09-17 13:26:40 +0000
+++ src/location_service/com/ubuntu/location/CMakeLists.txt	2014-09-17 13:26:40 +0000
@@ -131,12 +131,24 @@
 )
 
 add_library(
+  ubuntu-location-service-provider-daemon
+
+  service/provider_daemon.cpp
+)
+
+add_library(
   ubuntu-location-service-daemon
 
   service/daemon.cpp
 )
 
 add_executable(
+  ubuntu-location-service-providerd
+
+  service/provider_daemon_main.cpp
+)
+
+add_executable(
   ubuntu-location-serviced
 
   service/daemon_main.cpp
@@ -149,12 +161,32 @@
 )
 
 target_link_libraries(
+  ubuntu-location-service-provider-daemon
+
+  ubuntu-location-service
+)
+
+target_link_libraries(
   ubuntu-location-service-daemon
 
   ubuntu-location-service
 )
 
 target_link_libraries(
+  ubuntu-location-service-providerd
+
+  ubuntu-location-service-provider-daemon
+
+  ${ENABLED_PROVIDER_TARGETS}
+
+  ${Boost_LIBRARIES}
+  ${DBUS_LIBRARIES}
+  ${DBUS_CPP_LIBRARIES}
+  ${GLog_LIBRARY}
+  ${GFlags_LIBRARY}
+)
+
+target_link_libraries(
   ubuntu-location-serviced
 
   ubuntu-location-service-daemon
@@ -183,6 +215,11 @@
 )
 
 install(
+  TARGETS ubuntu-location-service-providerd
+  DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+install(
   TARGETS ubuntu-location-serviced
   DESTINATION ${CMAKE_INSTALL_BINDIR}
 )

=== modified file 'src/location_service/com/ubuntu/location/providers/remote/provider.cpp'
--- src/location_service/com/ubuntu/location/providers/remote/provider.cpp	2014-09-17 13:26:40 +0000
+++ src/location_service/com/ubuntu/location/providers/remote/provider.cpp	2014-09-17 13:26:40 +0000
@@ -26,6 +26,10 @@
 #include <core/dbus/signal.h>
 #include <core/dbus/asio/executor.h>
 
+#include <core/posix/this_process.h>
+
+#include <boost/asio.hpp>
+
 #include <thread>
 
 namespace cul = com::ubuntu::location;
@@ -35,6 +39,73 @@
 
 namespace
 {
+struct Runtime
+{
+    static Runtime& instance()
+    {
+        static Runtime runtime;
+        return runtime;
+    }
+
+    Runtime()
+        : keep_alive{io_service},
+          worker1
+          {
+              [this]()
+              {
+                  io_service.run();
+              }
+          },
+          worker2
+          {
+              [this]()
+              {
+                  io_service.run();
+              }
+          }
+    {
+    }
+
+    ~Runtime()
+    {
+        io_service.stop();
+
+        if (worker1.joinable())
+            worker1.join();
+
+        if (worker2.joinable())
+            worker2.join();
+    }
+
+    boost::asio::io_service io_service;
+    boost::asio::io_service::work keep_alive;
+    std::thread worker1;
+    std::thread worker2;
+};
+
+core::dbus::Bus::Ptr bus_from_name(const std::string& bus_name)
+{
+    core::dbus::Bus::Ptr bus;
+
+    if (bus_name == "system")
+        bus = std::make_shared<core::dbus::Bus>(core::dbus::WellKnownBus::system);
+    else if (bus_name == "session")
+        bus = std::make_shared<core::dbus::Bus>(core::dbus::WellKnownBus::session);
+    else if (bus_name == "system_with_address_from_env")
+        bus = std::make_shared<core::dbus::Bus>(core::posix::this_process::env::get_or_throw("DBUS_SYSTEM_BUS_ADDRESS"));
+    else if (bus_name == "session_with_address_from_env")
+        bus = std::make_shared<core::dbus::Bus>(core::posix::this_process::env::get_or_throw("DBUS_SESSION_BUS_ADDRESS"));
+
+    if (not bus) throw std::runtime_error
+    {
+        "Could not create bus for name: " + bus_name
+    };
+
+    bus->install_executor(core::dbus::asio::make_executor(bus, Runtime::instance().io_service));
+
+    return bus;
+}
+
 void throw_if_error(const dbus::Result<void>& result)
 {
     if (result.is_error()) throw std::runtime_error
@@ -52,13 +123,6 @@
     };
     return result.value();
 }
-
-dbus::Bus::Ptr the_system_bus()
-{
-    dbus::Bus::Ptr system_bus = std::make_shared<dbus::Bus>(dbus::WellKnownBus::system);
-    system_bus->install_executor(core::dbus::asio::make_executor(system_bus));
-    return system_bus;
-}
 }
 
 struct remote::Provider::Stub::Private
@@ -84,12 +148,14 @@
 
 cul::Provider::Ptr remote::Provider::Stub::create_instance(const cul::ProviderFactory::Configuration& config)
 {
+    auto bus_name = config.count(Stub::key_bus) > 0 ? config.get<std::string>(Stub::key_bus) :
+                                                       "system";
     auto name = config.count(Stub::key_name) > 0 ? config.get<std::string>(Stub::key_name) :
                                                    throw std::runtime_error("Missing bus-name");
     auto path = config.count(Stub::key_path) > 0 ? config.get<std::string>(Stub::key_path) :
                                                    throw std::runtime_error("Missing bus-path");
 
-    auto bus = the_system_bus();
+    auto bus = bus_from_name(bus_name);
     auto service = dbus::Service::use_service(bus, name);
     auto object = service->object_for_path(path);
 
@@ -122,11 +188,12 @@
 
 remote::Provider::Stub::~Stub() noexcept
 {
+    VLOG(10) << __PRETTY_FUNCTION__;
 }
 
 bool remote::Provider::Stub::matches_criteria(const cul::Criteria& criteria)
 {
-    VLOG(10) << __PRETTY_FUNCTION__ << std::endl;
+    VLOG(10) << __PRETTY_FUNCTION__ << std::endl;    
     return throw_if_error_or_return(d->stub.object->transact_method<remote::Interface::MatchesCriteria, bool>(criteria));
 }
 
@@ -150,56 +217,108 @@
 
 void remote::Provider::Stub::on_reference_location_updated(const cul::Update<cul::Position>& position)
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
-    throw_if_error(d->stub.object->transact_method<remote::Interface::OnReferenceLocationChanged, void>(position));
+    std::weak_ptr<Private> wp{d};
+    Runtime::instance().io_service.post([wp, position]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        try
+        {
+            throw_if_error(sp->stub.object->transact_method<remote::Interface::OnReferenceLocationChanged, void>(position));
+        } catch(const std::exception& e)
+        {
+            // We drop the error and just log it for post-mortem inspection.
+            LOG(WARNING) << "Transaction<remote::Interface::OnReferenceLocationChanged>: " << e.what();
+        }
+    });
 }
 
 void remote::Provider::Stub::on_reference_velocity_updated(const cul::Update<cul::Velocity>& velocity)
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
-    throw_if_error(d->stub.object->transact_method<remote::Interface::OnReferenceVelocityChanged, void>(velocity));
+    std::weak_ptr<Private> wp{d};
+    Runtime::instance().io_service.post([wp, velocity]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        try
+        {
+            throw_if_error(sp->stub.object->transact_method<remote::Interface::OnReferenceVelocityChanged, void>(velocity));
+        } catch(const std::exception& e)
+        {
+            // We drop the error and just log it for post-mortem inspection.
+            LOG(WARNING) << "Transaction<remote::Interface::OnReferenceVelocityChanged>: " << e.what();
+        }
+    });
 }
 
 void remote::Provider::Stub::on_reference_heading_updated(const cul::Update<cul::Heading>& heading)
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
-    throw_if_error(d->stub.object->transact_method<remote::Interface::OnReferenceHeadingChanged, void>(heading));
+    std::weak_ptr<Private> wp{d};
+    Runtime::instance().io_service.post([wp, heading]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        try
+        {
+            throw_if_error(sp->stub.object->transact_method<remote::Interface::OnReferenceHeadingChanged, void>(heading));
+        } catch(const std::exception& e)
+        {
+            // We drop the error and just log it for post-mortem inspection.
+            LOG(WARNING) << "Transaction<remote::Interface::OnReferenceHeadingChanged>: " << e.what();
+        }
+    });
 }
 
 void remote::Provider::Stub::start_position_updates()
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
+    VLOG(10) << "> " << __PRETTY_FUNCTION__;
     throw_if_error(d->stub.object->transact_method<remote::Interface::StartPositionUpdates, void>());
+    VLOG(10) << "< " << __PRETTY_FUNCTION__;
 }
 
 void remote::Provider::Stub::stop_position_updates()
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
+    VLOG(10) << "> " << __PRETTY_FUNCTION__;
     throw_if_error(d->stub.object->transact_method<remote::Interface::StopPositionUpdates, void>());
+    VLOG(10) << "< " << __PRETTY_FUNCTION__;
 }
 
 void remote::Provider::Stub::start_heading_updates()
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
+    VLOG(10) << "> " << __PRETTY_FUNCTION__;
     throw_if_error(d->stub.object->transact_method<remote::Interface::StartHeadingUpdates, void>());
+    VLOG(10) << "< " << __PRETTY_FUNCTION__;
 }
 
 void remote::Provider::Stub::stop_heading_updates()
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
+    VLOG(10) << "> " << __PRETTY_FUNCTION__;
     throw_if_error(d->stub.object->transact_method<remote::Interface::StopHeadingUpdates, void>());
+    VLOG(10) << "< " << __PRETTY_FUNCTION__;
 }
 
 void remote::Provider::Stub::start_velocity_updates()
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
+    VLOG(10) << "> " << __PRETTY_FUNCTION__;
     throw_if_error(d->stub.object->transact_method<remote::Interface::StartVelocityUpdates, void>());
+    VLOG(10) << "< " << __PRETTY_FUNCTION__;
+
 }
 
 void remote::Provider::Stub::stop_velocity_updates()
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
+    VLOG(10) << "> " << __PRETTY_FUNCTION__;
     throw_if_error(d->stub.object->transact_method<remote::Interface::StopVelocityUpdates, void>());
+    VLOG(10) << "< " << __PRETTY_FUNCTION__;
 }
 
 struct remote::Provider::Skeleton::Private
@@ -212,14 +331,17 @@
               {
                   impl->updates().position.connect([this](const cul::Update<cul::Position>& position)
                   {
+                      VLOG(100) << "Position changed reported by impl: " << position;
                       skeleton.signals.position_changed->emit(position.value);
                   }),
                   impl->updates().heading.connect([this](const cul::Update<cul::Heading>& heading)
                   {
+                      VLOG(100) << "Heading changed reported by impl: " << heading;
                       skeleton.signals.heading_changed->emit(heading.value);
                   }),
                   impl->updates().velocity.connect([this](const cul::Update<cul::Velocity>& velocity)
                   {
+                      VLOG(100) << "Velocity changed reported by impl: " << velocity;
                       skeleton.signals.velocity_changed->emit(velocity.value);
                   })
               }
@@ -243,22 +365,6 @@
     : cul::Provider(),
       d(new Private(config))
 {
-    // Wire up to updates.
-    d->impl->updates().position.connect([this](const cul::Update<cul::Position>& position)
-    {
-        d->skeleton.signals.position_changed->emit(position.value);
-    });
-
-    d->impl->updates().heading.connect([this](const cul::Update<cul::Heading>& heading)
-    {
-        d->skeleton.signals.heading_changed->emit(heading.value);
-    });
-
-    d->impl->updates().velocity.connect([this](const cul::Update<cul::Velocity>& velocity)
-    {
-        d->skeleton.signals.velocity_changed->emit(velocity.value);
-    });
-
     // And install method handlers.
     d->skeleton.object->install_method_handler<remote::Interface::MatchesCriteria>([this](const dbus::Message::Ptr & msg)
     {

=== modified file 'src/location_service/com/ubuntu/location/providers/remote/provider.h'
--- src/location_service/com/ubuntu/location/providers/remote/provider.h	2014-09-17 13:26:40 +0000
+++ src/location_service/com/ubuntu/location/providers/remote/provider.h	2014-09-17 13:26:40 +0000
@@ -48,6 +48,8 @@
         // from the provided property bundle.
         static Provider::Ptr create_instance(const ProviderFactory::Configuration&);
 
+        // Name of the command line parameter for passing in the DBus to connect to.
+        static constexpr const char* key_bus{"bus"};
         // Name of the command line parameter for passing in the remote service name.
         static constexpr const char* key_name{"name"};
         // Name of the command line parameter for passing in the path of the remote provider impl.
@@ -76,7 +78,7 @@
 
     private:
         struct Private;
-        std::unique_ptr<Private> d;
+        std::shared_ptr<Private> d;
     };
 
     class Skeleton : public com::ubuntu::location::Provider
@@ -106,7 +108,7 @@
 
     private:
         struct Private;
-        std::unique_ptr<Private> d;
+        std::shared_ptr<Private> d;
     };
 };
 }

=== modified file 'src/location_service/com/ubuntu/location/service/daemon.cpp'
--- src/location_service/com/ubuntu/location/service/daemon.cpp	2014-08-13 13:08:22 +0000
+++ src/location_service/com/ubuntu/location/service/daemon.cpp	2014-09-17 13:26:40 +0000
@@ -89,7 +89,7 @@
 location::service::Daemon::Configuration location::service::Daemon::Configuration::from_command_line_args(
         int argc,
         const char** argv,
-        location::service::Daemon::DBusConnectionFactory factory)
+        location::service::DBusConnectionFactory factory)
 {
     location::service::Daemon::Configuration result;
 
@@ -289,7 +289,7 @@
 location::service::Daemon::Cli::Configuration location::service::Daemon::Cli::Configuration::from_command_line_args(
         int argc,
         const char** argv,
-        location::service::Daemon::DBusConnectionFactory factory)
+        location::service::DBusConnectionFactory factory)
 {
     location::service::Daemon::Cli::Configuration result;
 

=== modified file 'src/location_service/com/ubuntu/location/service/daemon.h'
--- src/location_service/com/ubuntu/location/service/daemon.h	2014-07-29 10:51:48 +0000
+++ src/location_service/com/ubuntu/location/service/daemon.h	2014-09-17 13:26:40 +0000
@@ -20,7 +20,7 @@
 
 #include <com/ubuntu/location/configuration.h>
 
-#include <core/dbus/bus.h>
+#include <com/ubuntu/location/service/dbus_connection_factory.h>
 
 #include <iosfwd>
 #include <string>
@@ -38,21 +38,6 @@
  */
 struct Daemon
 {
-    /** @brief Function signature for creating DBus connections. */
-    typedef std::function<core::dbus::Bus::Ptr(core::dbus::WellKnownBus)> DBusConnectionFactory;
-
-    /** @brief Returns the default connection factory. */
-    static DBusConnectionFactory default_dbus_connection_factory()
-    {
-        return [](core::dbus::WellKnownBus bus)
-        {
-            return core::dbus::Bus::Ptr
-            {
-                new core::dbus::Bus(bus)
-            };
-        };
-    }
-
     /** @brief Describes the command-line interface to the daemon. */
     struct Cli
     {

=== modified file 'src/location_service/com/ubuntu/location/service/daemon_main.cpp'
--- src/location_service/com/ubuntu/location/service/daemon_main.cpp	2014-08-14 20:25:22 +0000
+++ src/location_service/com/ubuntu/location/service/daemon_main.cpp	2014-09-17 13:26:40 +0000
@@ -44,7 +44,7 @@
     {
         FLAGS_logtostderr = true;
         VLOG(1) << "Problem creating directory for log files: " << ec << "."
-                     << "Falling back to stderr logging.";
+                << "Falling back to stderr logging.";
     }
 
     FLAGS_log_dir = log_dir;

=== added file 'src/location_service/com/ubuntu/location/service/dbus_connection_factory.h'
--- src/location_service/com/ubuntu/location/service/dbus_connection_factory.h	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/service/dbus_connection_factory.h	2014-09-17 13:26:40 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2012-2013 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 LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_DBUS_CONNECTION_FACTORY_H_
+#define LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_DBUS_CONNECTION_FACTORY_H_
+
+#include <core/dbus/bus.h>
+
+#include <functional>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace location
+{
+namespace service
+{
+/** @brief Function signature for creating DBus connections. */
+typedef std::function<core::dbus::Bus::Ptr(core::dbus::WellKnownBus)> DBusConnectionFactory;
+
+/** @brief Returns the default connection factory. */
+static DBusConnectionFactory default_dbus_connection_factory()
+{
+    return [](core::dbus::WellKnownBus bus)
+    {
+        return core::dbus::Bus::Ptr
+        {
+            new core::dbus::Bus(bus)
+        };
+    };
+}
+}
+}
+}
+}
+
+#endif // LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_DBUS_CONNECTION_FACTORY_H_

=== added file 'src/location_service/com/ubuntu/location/service/provider_daemon.cpp'
--- src/location_service/com/ubuntu/location/service/provider_daemon.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/service/provider_daemon.cpp	2014-09-17 13:26:40 +0000
@@ -0,0 +1,147 @@
+/*
+ * Copyright © 2014 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 <com/ubuntu/location/service/provider_daemon.h>
+
+#include <com/ubuntu/location/configuration.h>
+#include <com/ubuntu/location/provider_factory.h>
+
+#include <com/ubuntu/location/providers/remote/skeleton.h>
+
+#include <com/ubuntu/location/service/configuration.h>
+#include <com/ubuntu/location/service/program_options.h>
+
+#include <core/posix/signal.h>
+
+namespace location = com::ubuntu::location;
+
+namespace
+{
+location::ProgramOptions init_daemon_options()
+{
+    location::ProgramOptions options;
+
+    options.add("help", "Produces this help message");
+    options.add<std::string>("service-name",
+                             "The name of the service under which the provider should be exposed.");
+    options.add<std::string>("service-path",
+                             "The dbus object path under which the provider is known.");
+    options.add<std::string>("provider",
+                             "The provider that should be exposed to the bus");
+
+    return options;
+}
+
+location::ProgramOptions& mutable_daemon_options()
+{
+    static location::ProgramOptions options = init_daemon_options();
+    return options;
+}
+}
+
+location::service::ProviderDaemon::Configuration location::service::ProviderDaemon::Configuration::from_command_line_args(
+        int argc, const char** argv, location::service::DBusConnectionFactory factory)
+{
+    if (!mutable_daemon_options().parse_from_command_line_args(argc, argv))
+        throw std::runtime_error{"Could not parse command-line, aborting..."};
+
+    location::service::ProviderDaemon::Configuration result;
+
+    result.connection = factory(mutable_daemon_options().bus());
+
+    auto service = core::dbus::Service::add_service(
+                result.connection,
+                mutable_daemon_options().value_for_key<std::string>("service-name"));
+
+    result.object = service->add_object_for_path(core::dbus::types::ObjectPath
+    {
+        mutable_daemon_options().value_for_key<std::string>("service-path")
+    });
+
+    auto provider_name = mutable_daemon_options().value_for_key<std::string>("provider");
+    location::Configuration config;
+
+    mutable_daemon_options().enumerate_unrecognized_options([&config, provider_name](const std::string& s)
+    {
+        std::stringstream in(s);
+        std::string key, value;
+
+        std::getline(in, key, '=');
+        std::getline(in, value, '=');
+
+        std::size_t pos = key.find(provider_name);
+        if (pos == std::string::npos)
+            return;
+
+        static const std::string option_marker{"--"};
+        static const std::string scope_separator{"::"};
+
+        key = key.erase(key.find_first_of(option_marker), option_marker.size());
+        key = key.erase(key.find_first_of(provider_name), provider_name.size());
+        key = key.erase(key.find_first_of(scope_separator), scope_separator.size());
+
+        config.put(key, value);
+    });
+
+    result.provider = location::ProviderFactory::instance().create_provider_for_name_with_config(
+                provider_name,
+                config);
+
+    return result;
+}
+
+int location::service::ProviderDaemon::main(const location::service::ProviderDaemon::Configuration& configuration)
+{
+    auto trap = core::posix::trap_signals_for_all_subsequent_threads(
+    {
+        core::posix::Signal::sig_term,
+        core::posix::Signal::sig_int
+    });
+
+    trap->signal_raised().connect([trap](const core::posix::Signal&)
+    {
+        trap->stop();
+    });
+
+    std::thread worker
+    {
+        [configuration]()
+        {
+            configuration.connection->run();
+        }
+    };
+
+    auto skeleton = location::providers::remote::skeleton::create_with_configuration(location::providers::remote::skeleton::Configuration
+    {
+        configuration.object,
+        configuration.connection,
+        configuration.provider
+    });
+
+
+    std::cout << "We are up and running" << std::endl;
+
+    trap->run();
+
+    configuration.connection->stop();
+
+    if (worker.joinable())
+        worker.join();
+
+    return EXIT_SUCCESS;
+}

=== added file 'src/location_service/com/ubuntu/location/service/provider_daemon.h'
--- src/location_service/com/ubuntu/location/service/provider_daemon.h	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/service/provider_daemon.h	2014-09-17 13:26:40 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright © 2014 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 LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_PROVIDER_DAEMON_H_
+#define LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_PROVIDER_DAEMON_H_
+
+#include <com/ubuntu/location/provider.h>
+
+#include <com/ubuntu/location/service/dbus_connection_factory.h>
+
+#include <core/dbus/bus.h>
+#include <core/dbus/object.h>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace location
+{
+namespace service
+{
+// Provides a default out-of-process runner for known providers,
+// leveraging the actual provider instance and a remote::Provider to
+// expose it to the bus.
+struct ProviderDaemon
+{
+    // Startup configuration goes here.
+    struct Configuration
+    {
+        // Initializes a startup configuration from a command line.
+        // Throws in case of issues.
+        // Known parameters are:
+        //   --bus={system, session}: The bus to connect to.
+        //   --service-name=name: The name of the service under which the provider should be exposed.
+        //   --service-path=path: The dbus object path under which the provider is known.
+        //   --provider=name: The name of the actual provider implementation.
+        static Configuration from_command_line_args(int argc, const char** argv, DBusConnectionFactory factory);
+
+        // The bus connection that should be used by the remote::Provider::Skeleton instance.
+        core::dbus::Bus::Ptr connection;
+        // The object on the bus that represents the remote::Provider::Skeleton.
+        core::dbus::Object::Ptr object;
+        // The actual provider implementation.
+        Provider::Ptr provider;
+    };
+
+    // Executes the daemon with the given configuration.
+    static int main(const Configuration& configuration);
+};
+}
+}
+}
+}
+
+#endif // LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_PROVIDER_DAEMON_H_

=== added file 'src/location_service/com/ubuntu/location/service/provider_daemon_main.cpp'
--- src/location_service/com/ubuntu/location/service/provider_daemon_main.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/service/provider_daemon_main.cpp	2014-09-17 13:26:40 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2014 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 <com/ubuntu/location/service/provider_daemon.h>
+
+namespace location = com::ubuntu::location;
+
+int main(int argc, const char** argv)
+{
+    return location::service::ProviderDaemon::main(
+                location::service::ProviderDaemon::Configuration::from_command_line_args(
+                    argc,
+                    argv,
+                    location::service::default_dbus_connection_factory()));
+}

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-09-17 13:26:40 +0000
+++ tests/CMakeLists.txt	2014-09-17 13:26:40 +0000
@@ -37,6 +37,7 @@
 
     ubuntu-location-service
     ubuntu-location-service-connectivity
+    ubuntu-location-service-provider-daemon
     ubuntu-location-service-daemon
 
     mongoose
@@ -117,5 +118,7 @@
   endif (LOCATION_SERVICE_ENABLE_DBUS_TEST_RUNNER)
 endif (LOCATION_SERVICE_ENABLE_GEOCLUE_PROVIDERS)
 
+LOCATION_SERVICE_ADD_TEST(remote_providerd_test remote_providerd_test.cpp)
+
 LOCATION_SERVICE_ADD_TEST(remote_provider_test remote_provider_test.cpp)
 LOCATION_SERVICE_ADD_TEST(espoo_provider_test espoo_provider_test.cpp)

=== modified file 'tests/remote_provider_test.cpp'
--- tests/remote_provider_test.cpp	2014-09-17 13:26:40 +0000
+++ tests/remote_provider_test.cpp	2014-09-17 13:26:40 +0000
@@ -388,6 +388,8 @@
 
         bus->stop();
 
+        std::cout << "Stopped the bus" << std::endl;
+
         if (worker.joinable())
             worker.join();
 
@@ -395,7 +397,9 @@
                                                core::posix::exit::Status::success;
     }, core::posix::StandardStream::empty);
 
+    std::cout << "Waiting for stub to finish." << std::endl;
     EXPECT_TRUE(did_finish_successfully(stub.wait_for(core::posix::wait::Flags::untraced)));
+    std::cout << "Shutting down skeleton." << std::endl;
     skeleton.send_signal_or_throw(core::posix::Signal::sig_term);
     EXPECT_TRUE(did_finish_successfully(skeleton.wait_for(core::posix::wait::Flags::untraced)));
 }

=== added file 'tests/remote_providerd_test.cpp'
--- tests/remote_providerd_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/remote_providerd_test.cpp	2014-09-17 13:26:40 +0000
@@ -0,0 +1,194 @@
+/*
+ * Copyright © 2014 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 <com/ubuntu/location/service/daemon.h>
+#include <com/ubuntu/location/service/provider_daemon.h>
+
+#include <com/ubuntu/location/service/stub.h>
+
+#include <com/ubuntu/location/position.h>
+#include <com/ubuntu/location/update.h>
+
+#include <core/dbus/fixture.h>
+
+#include <core/dbus/asio/executor.h>
+
+#include <core/posix/fork.h>
+
+#include <gmock/gmock.h>
+
+namespace location = com::ubuntu::location;
+
+namespace
+{
+::testing::AssertionResult did_finish_successfully(const core::posix::wait::Result& result)
+{
+    if (result.status != core::posix::wait::Result::Status::exited)
+        return ::testing::AssertionFailure() << "Process did not exit, but: " << (int)result.status;
+    if (result.detail.if_exited.status != core::posix::exit::Status::success)
+        return ::testing::AssertionFailure() << "Process did exit with failure.";
+
+    return ::testing::AssertionSuccess();
+}
+
+struct MockEventReceiver
+{
+    MOCK_METHOD1(position_update_received, void(const location::Update<location::Position>&));
+    MOCK_METHOD1(heading_update_received, void(const location::Update<location::Heading>&));
+    MOCK_METHOD1(velocity_update_received, void(const location::Update<location::Velocity>&));
+};
+
+struct RemoteProviderdTest : public core::dbus::testing::Fixture
+{
+
+};
+}
+
+TEST_F(RemoteProviderdTest, AClientReceivesUpdatesFromAnOutOfProcessProvider)
+{
+    auto oopp = core::posix::fork([this]()
+    {
+        auto bus = session_bus();
+        bus->install_executor(core::dbus::asio::make_executor(bus));
+
+        const char* argv[] =
+        {
+            "--bus", "session",                                         // 2
+            "--service-name", "com.ubuntu.location.providers.Dummy",    // 4
+            "--service-path", "/com/ubuntu/location/providers/Dummy",   // 6
+            "--provider", "dummy::Provider"                             // 8
+        };
+
+        auto dbus_connection_factory = [bus](core::dbus::WellKnownBus)
+        {
+            return bus;
+        };
+
+        return static_cast<core::posix::exit::Status>(
+                    location::service::ProviderDaemon::main(
+                        location::service::ProviderDaemon::Configuration::from_command_line_args(
+                            8, argv, dbus_connection_factory)));
+    }, core::posix::StandardStream::empty);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds{250});
+
+    auto service = core::posix::fork([this]()
+    {
+        core::posix::this_process::env::set_or_throw(
+                    "TRUST_STORE_PERMISSION_MANAGER_IS_RUNNING_UNDER_TESTING",
+                    "1");
+
+        const char* argv[] =
+        {
+            "--bus", "session",                                                 // 2
+            "--provider", "remote::Provider",                                   // 4
+            "--remote::Provider::bus=session_with_address_from_env",            // 5
+            "--remote::Provider::name=com.ubuntu.location.providers.Dummy",     // 6
+            "--remote::Provider::path=/com/ubuntu/location/providers/Dummy"     // 7
+        };
+
+        // The daemon instance requires two bus instances.
+        auto dbus_connection_factory = [this](core::dbus::WellKnownBus)
+        {
+            return session_bus();
+        };
+
+        return static_cast<core::posix::exit::Status>(
+                    location::service::Daemon::main(
+                        location::service::Daemon::Configuration::from_command_line_args(
+                            7, argv, dbus_connection_factory)));
+    }, core::posix::StandardStream::empty);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds{250});
+
+    auto client = core::posix::fork([this]()
+    {
+        using namespace ::testing;
+
+        auto trap = core::posix::trap_signals_for_all_subsequent_threads(
+        {
+            core::posix::Signal::sig_term,
+            core::posix::Signal::sig_int
+        });
+
+        trap->signal_raised().connect([trap](const core::posix::Signal&)
+        {
+            trap->stop();
+        });
+
+        auto bus = session_bus();
+        bus->install_executor(core::dbus::asio::make_executor(bus));
+
+        std::thread worker
+        {
+            [bus]() { bus->run(); }
+        };
+
+        MockEventReceiver receiver;
+        EXPECT_CALL(receiver, position_update_received(_)).Times(AtLeast(1));
+        EXPECT_CALL(receiver, heading_update_received(_)).Times(AtLeast(1));
+        EXPECT_CALL(receiver, velocity_update_received(_)).Times(AtLeast(1));
+
+        com::ubuntu::location::service::Stub service{bus};
+
+        auto session = service.create_session_for_criteria(location::Criteria{});
+
+        session->updates().position.changed().connect([&receiver](location::Update<location::Position> pos)
+        {
+             receiver.position_update_received(pos);
+        });
+
+        session->updates().heading.changed().connect([&receiver](location::Update<location::Heading> heading)
+        {
+             receiver.heading_update_received(heading);
+        });
+
+        session->updates().velocity.changed().connect([&receiver](location::Update<location::Velocity> velocity)
+        {
+             receiver.velocity_update_received(velocity);
+        });
+
+        session->updates().position_status = location::service::session::Interface::Updates::Status::enabled;
+        session->updates().velocity_status = location::service::session::Interface::Updates::Status::enabled;
+        session->updates().heading_status = location::service::session::Interface::Updates::Status::enabled;
+
+        trap->run();
+
+        bus->stop();
+
+        if (worker.joinable())
+            worker.join();
+
+        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure :
+                                               core::posix::exit::Status::success;
+    }, core::posix::StandardStream::empty);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds{4000});
+
+    std::cout << "Shutting down client" << std::endl;
+    client.send_signal_or_throw(core::posix::Signal::sig_term);
+    EXPECT_TRUE(did_finish_successfully(client.wait_for(core::posix::wait::Flags::untraced)));
+
+    std::cout << "Shutting down service" << std::endl;
+    service.send_signal_or_throw(core::posix::Signal::sig_term);
+    EXPECT_TRUE(did_finish_successfully(service.wait_for(core::posix::wait::Flags::untraced)));
+
+    std::cout << "Shutting down oopp" << std::endl;
+    oopp.send_signal_or_throw(core::posix::Signal::sig_term);
+    EXPECT_TRUE(did_finish_successfully(oopp.wait_for(core::posix::wait::Flags::untraced)));
+}