Merge lp:~thomas-voss/location-service/introduce-locationd into lp:location-service

[Thomas Voß]

Introduce locationd, featuring the following cmds:
 - list: list all known provider implementations
 - provider: run a known provider implementation out of process.
 - run: execute locationd.
 - status: query the status of a locationd instance.
 - test: execute runtime tests.

Introduce locationd, featuring the following cmds:
 - list: list all known provider implementations
 - provider: run a known provider implementation out of process.
 - run: execute locationd.
 - status: query the status of a locationd instance.
 - test: execute runtime tests.

[Simon Fels (morphis)]

Very nice. LGTM

review: Approve

=== added directory 'build'
=== added directory 'build/src'
=== modified file 'src/location/CMakeLists.txt'
--- src/location/CMakeLists.txt	2016-06-28 11:53:34 +0000
+++ src/location/CMakeLists.txt	2016-06-30 09:21:49 +0000
@@ -39,8 +39,43 @@
 
   boost_ptree_settings.cpp
 
+  daemon.h
+  daemon.cpp
   service.cpp
 
+  dummy_service.h
+  dummy_service.cpp
+
+  permission_manager.h
+  runtime.h
+  runtime.cpp
+  runtime_tests.h
+  runtime_tests.cpp
+  service_with_engine.h
+  service_with_engine.cpp
+  session_with_provider.h
+  session_with_provider.cpp
+
+  trust_store_permission_manager.h
+  trust_store_permission_manager.cpp
+
+  cmds/list.h
+  cmds/list.cpp
+  cmds/provider.h
+  cmds/provider.cpp
+  cmds/run.h
+  cmds/run.cpp
+  cmds/status.h
+  cmds/status.cpp
+  cmds/test.h
+  cmds/test.cpp
+
+  util/cli.h
+  util/cli.cpp
+  util/do_not_copy_or_move.h
+  util/well_known_bus.h
+  util/well_known_bus.cpp
+
   dbus/skeleton/service.h
   dbus/skeleton/service.cpp
   dbus/skeleton/session.h
@@ -190,6 +225,12 @@
   service/daemon_cli_main.cpp
 )
 
+add_executable(
+  locationd
+
+  daemon_main.cpp
+)
+
 target_link_libraries(
   ubuntu-location-service-provider-daemon
 
@@ -244,6 +285,20 @@
   ${GFlags_LIBRARY}
 )
 
+target_link_libraries(
+  locationd
+
+  ubuntu-location-service
+
+  ${ENABLED_PROVIDER_TARGETS}
+
+#  ${Boost_LIBRARIES}
+#  ${DBUS_LIBRARIES}
+#  ${DBUS_CPP_LIBRARIES}
+#  ${GLog_LIBRARY}
+#  ${GFlags_LIBRARY}
+)
+
 install(
   TARGETS ubuntu-location-service-providerd
   DESTINATION ${CMAKE_INSTALL_BINDIR}
@@ -258,3 +313,8 @@
   TARGETS ubuntu-location-serviced-cli
   DESTINATION ${CMAKE_INSTALL_BINDIR}
 )
+
+install(
+  TARGETS locationd
+  DESTINATION ${CMAKE_INSTALL_BINDIR}
+)

=== added directory 'src/location/cmds'
=== added file 'src/location/cmds/list.cpp'
--- src/location/cmds/list.cpp	1970-01-01 00:00:00 +0000
+++ src/location/cmds/list.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/cmds/list.h>
+#include <location/provider_factory.h>
+
+namespace cli = location::util::cli;
+
+location::cmds::List::List()
+    : CommandWithFlagsAndAction{cli::Name{"list"}, cli::Usage{"list"}, cli::Description{"lists known provider implementations"}}
+{
+    action([this](const Context& ctxt)
+    {
+        location::ProviderFactory::instance().enumerate([&ctxt](const std::string& name, const location::ProviderFactory::Factory&)
+        {
+            ctxt.cout << "  - " << name << std::endl;
+        });
+        return EXIT_SUCCESS;
+    });
+}

=== added file 'src/location/cmds/list.h'
--- src/location/cmds/list.h	1970-01-01 00:00:00 +0000
+++ src/location/cmds/list.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_CMDS_LIST_H_
+#define LOCATION_CMDS_LIST_H_
+
+#include <location/util/cli.h>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace cmds
+{
+// List lists all known provider implementations
+class List : public util::cli::CommandWithFlagsAndAction
+{
+public:
+    // List initializes a new instance.
+    List();
+};
+}
+}
+
+#endif // LOCATION_CMDS_LIST_H_

=== added file 'src/location/cmds/provider.cpp'
--- src/location/cmds/provider.cpp	1970-01-01 00:00:00 +0000
+++ src/location/cmds/provider.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/cmds/provider.h>
+
+#include <location/provider_factory.h>
+#include <location/runtime.h>
+
+#include <location/providers/remote/skeleton.h>
+
+#include <core/dbus/service.h>
+#include <core/dbus/asio/executor.h>
+#include <core/posix/signal.h>
+
+namespace cli = location::util::cli;
+
+namespace
+{
+void die_if(bool b, std::ostream& out, const std::string& message)
+{
+    if (b) { out << message << std::endl; std::exit(EXIT_FAILURE); }
+}
+}
+
+location::cmds::Provider::Provider()
+    : CommandWithFlagsAndAction{cli::Name{"provider"}, cli::Usage{"provider"}, cli::Description{"executes a built-in provider"}},
+      bus{core::dbus::WellKnownBus::system}
+{
+    flag(cli::make_flag(cli::Name{"bus"}, cli::Description{"bus instance to connect to, defaults to system"}, bus));
+    flag(cli::make_flag(cli::Name{"service"}, cli::Description{"name of the service hosting the provider."}, service));
+    flag(cli::make_flag(cli::Name{"path"}, cli::Description{"dbus object path hosting the provider."}, path));
+    flag(cli::make_flag(cli::Name{"id"}, cli::Description{"id of the actual provider implementation."}, id));
+
+    action([this](const Context& ctxt)
+    {
+        die_if(not service, ctxt.cout, "service name is missing");
+        die_if(not path, ctxt.cout, "object path is missing");
+        die_if(not id, ctxt.cout, "name of actual provider implementation is missing");
+
+        // We exit cleanly for SIGINT and SIGTERM.
+        auto trap = core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_int, core::posix::Signal::sig_term});
+        trap->signal_raised().connect([trap](core::posix::Signal)
+        {
+            trap->stop();
+        });
+
+        auto impl = location::ProviderFactory::instance().create_provider_for_name_with_config(*id, location::Configuration{});
+
+        auto rt = location::Runtime::create();
+        rt->start();
+
+        auto incoming = std::make_shared<core::dbus::Bus>(bus);
+        incoming->install_executor(core::dbus::asio::make_executor(incoming, rt->service()));
+        auto object = core::dbus::Service::add_service(incoming, *service)
+                        ->add_object_for_path(core::dbus::types::ObjectPath{*path});
+
+        location::providers::remote::skeleton::Configuration config{object, incoming, impl};
+        auto skeleton = location::providers::remote::skeleton::create_with_configuration(config);
+
+        trap->run();
+
+        incoming->stop(); rt->stop();
+
+        return EXIT_SUCCESS;
+    });
+}
+

=== added file 'src/location/cmds/provider.h'
--- src/location/cmds/provider.h	1970-01-01 00:00:00 +0000
+++ src/location/cmds/provider.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_CMDS_PROVIDER_H_
+#define LOCATION_CMDS_PROVIDER_H_
+
+#include <location/optional.h>
+#include <location/util/cli.h>
+
+#include <location/util/well_known_bus.h>
+
+#include <boost/filesystem.hpp>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace cmds
+{
+// Provider executes an in-tree provider out-of-process.
+class Provider : public util::cli::CommandWithFlagsAndAction
+{
+public:
+    // Run initializes a new instance.
+    Provider();
+
+private:
+    core::dbus::WellKnownBus bus;   // The bus we should connect to.
+    Optional<std::string> service;  // The name of the service under which the provider should be exposed.
+    Optional<std::string> path;     // The dbus object path under which the provider is known.
+    Optional<std::string> id;       // The id of the actual provider implementation.
+};
+}
+}
+
+#endif // LOCATION_CMDS_PROVIDER_H_

=== added file 'src/location/cmds/run.cpp'
--- src/location/cmds/run.cpp	1970-01-01 00:00:00 +0000
+++ src/location/cmds/run.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/cmds/run.h>
+
+#include <location/boost_ptree_settings.h>
+#include <location/fusion_provider_selection_policy.h>
+#include <location/service_with_engine.h>
+#include <location/settings.h>
+#include <location/trust_store_permission_manager.h>
+
+#include <location/dbus/skeleton/service.h>
+#include <location/runtime.h>
+
+#include <location/util/well_known_bus.h>
+
+#include <core/dbus/asio/executor.h>
+#include <core/posix/signal.h>
+
+namespace cli = location::util::cli;
+
+location::cmds::Run::Run()
+    : CommandWithFlagsAndAction{cli::Name{"run"}, cli::Usage{"run"}, cli::Description{"runs the daemon"}},
+      bus{core::dbus::WellKnownBus::system},
+      settings{"/var/lib/ubuntu-location-service/config.ini"}
+{
+    flag(cli::make_flag(cli::Name{"bus"}, cli::Description{"bus instance to connect to, defaults to system"}, bus));
+    flag(cli::make_flag(cli::Name{"config"}, cli::Description{"daemon configuration"}, config));
+    flag(cli::make_flag(cli::Name{"settings"}, cli::Description{"path to runtime persistent state data"}, settings));
+
+    action([this](const Context& ctxt)
+    {
+        account_for_lp1447110();
+
+        // We exit cleanly for SIGINT and SIGTERM.
+        auto trap = core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_int, core::posix::Signal::sig_term});
+        trap->signal_raised().connect([trap](core::posix::Signal)
+        {
+            trap->stop();
+        });
+
+        // The engine instance is the core piece of functionality.
+        auto engine = std::make_shared<location::Engine>(
+            // We default to a fusion provider selection policy, providing
+            // fusioned and filtered updates to sessions.
+            std::make_shared<location::FusionProviderSelectionPolicy>(),
+            // We default to a location::Settings implementation that reads state from
+            // an ini file, immediately syncing back changes to the underlying file whenever
+            // parameters change.
+            std::make_shared<location::SyncingSettings>(std::make_shared<location::BoostPtreeSettings>(settings.string())));
+
+        auto rt = location::Runtime::create();
+
+        auto incoming = std::make_shared<core::dbus::Bus>(bus);
+        auto outgoing = std::make_shared<core::dbus::Bus>(bus);
+
+        incoming->install_executor(core::dbus::asio::make_executor(incoming, rt->service()));
+        outgoing->install_executor(core::dbus::asio::make_executor(outgoing, rt->service()));
+
+        auto service = core::dbus::Service::add_service<location::dbus::Service>(incoming);
+
+        location::dbus::skeleton::Service::Configuration config
+        {
+            std::make_shared<location::ServiceWithEngine>(engine),
+            incoming,
+            outgoing,
+            service,
+            // We resolve credentials of incoming calls by talking back to the dbus daemon and subsequently
+            // querying apparmor for the confinement profile.
+            std::make_shared<location::dbus::skeleton::Service::DBusDaemonCredentialsResolver>(outgoing),
+            std::make_shared<location::dbus::skeleton::Service::ObjectPathGenerator>(),
+            // Incoming requests are verified by talking to a trust-store instance.
+            location::TrustStorePermissionManager::create_default_instance_with_bus(outgoing)
+        };
+
+        rt->start();
+
+        auto skeleton = std::make_shared<location::dbus::skeleton::Service>(config);
+
+        trap->run();
+
+        incoming->stop(); outgoing->stop(); rt->stop();
+
+        return EXIT_SUCCESS;
+    });
+}
+
+void location::cmds::Run::account_for_lp1447110() const
+{
+    static const boost::filesystem::path old_log_dir{"/var/log/ubuntu-location-service"};
+    boost::system::error_code ec;
+    boost::filesystem::remove_all(old_log_dir, ec);
+}

=== added file 'src/location/cmds/run.h'
--- src/location/cmds/run.h	1970-01-01 00:00:00 +0000
+++ src/location/cmds/run.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_CMDS_RUN_H_
+#define LOCATION_CMDS_RUN_H_
+
+#include <location/optional.h>
+#include <location/util/cli.h>
+
+#include <location/util/well_known_bus.h>
+
+#include <boost/filesystem.hpp>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace cmds
+{
+// Run executes locationd, exposing the service via DBus.
+class Run : public util::cli::CommandWithFlagsAndAction
+{
+public:
+    // Run initializes a new instance.
+    Run();
+
+private:
+    // Ensure that log files dating back to before the fix
+    // for lp:1447110 are removed and do not waste space.
+    void account_for_lp1447110() const;
+
+    core::dbus::WellKnownBus bus;               // The bus we should connect to.
+    Optional<boost::filesystem::path> config;   // Optionally load configuration from this config file.
+    boost::filesystem::path settings;           // Runtime persistent state settings are loaded from this file.
+};
+}
+}
+
+#endif // LOCATION_CMDS_RUN_H_

=== added file 'src/location/cmds/status.cpp'
--- src/location/cmds/status.cpp	1970-01-01 00:00:00 +0000
+++ src/location/cmds/status.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/cmds/status.h>
+#include <location/dbus/stub/service.h>
+#include <location/service/runtime.h>
+#include <location/util/well_known_bus.h>
+
+#include <core/dbus/asio/executor.h>
+
+namespace cli = location::util::cli;
+
+location::cmds::Status::Status()
+    : CommandWithFlagsAndAction{cli::Name{"status"}, cli::Usage{"status"}, cli::Description{"queries the status of the daemon"}},
+      bus{core::dbus::WellKnownBus::system}
+{
+    flag(cli::make_flag(cli::Name{"bus"}, cli::Description{"bus instance to connect to, defaults to system"}, bus));
+    action([this](const Context& ctxt)
+    {
+        auto rt = location::service::Runtime::create();
+
+        auto conn = std::make_shared<core::dbus::Bus>(bus);
+
+        conn->install_executor(core::dbus::asio::make_executor(conn, rt->service()));
+
+        auto service = core::dbus::Service::use_service<location::dbus::Service>(conn);
+        auto stub = std::make_shared<location::dbus::stub::Service>(conn, service, service->object_for_path(core::dbus::types::ObjectPath{location::dbus::Service::path()}));
+
+        rt->start();
+
+        ctxt.cout << "  is online:                   " << std::boolalpha << stub->is_online() << std::endl
+                  << "  state:                       " << stub->state() << std::endl
+                  << "  satellite based positioning: " << std::boolalpha << stub->does_satellite_based_positioning() << std::endl
+                  << "  reports cell & wifi ids:     " << std::boolalpha << stub->does_report_cell_and_wifi_ids() << std::endl;
+        auto svs = stub->visible_space_vehicles().get();
+        if (svs.size() > 0)
+        {
+            ctxt.cout << "  svs:" << std::endl;
+            for (const auto& pair : svs)
+                ctxt.cout << "    " << pair.second << std::endl;
+        }
+        else
+        {
+            ctxt.cout << "  svs:                         " << "none";
+        }
+
+        ctxt.cout << std::endl;
+
+        conn->stop(); rt->stop();
+
+        return EXIT_SUCCESS;
+    });
+}

=== added file 'src/location/cmds/status.h'
--- src/location/cmds/status.h	1970-01-01 00:00:00 +0000
+++ src/location/cmds/status.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_CMDS_STATUS_H_
+#define LOCATION_CMDS_STATUS_H_
+
+#include <location/optional.h>
+#include <location/util/cli.h>
+
+#include <core/dbus/well_known_bus.h>
+
+#include <boost/filesystem.hpp>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace cmds
+{
+// Status queries the status of the daemon
+class Status : public util::cli::CommandWithFlagsAndAction
+{
+public:
+    // Status initializes a new instance.
+    Status();
+
+private:
+    core::dbus::WellKnownBus bus; // The bus we should connect to.
+};
+}
+}
+
+#endif // LOCATION_CMDS_STATUS_H_

=== added file 'src/location/cmds/test.cpp'
--- src/location/cmds/test.cpp	1970-01-01 00:00:00 +0000
+++ src/location/cmds/test.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/cmds/test.h>
+#include <location/runtime_tests.h>
+
+namespace cli = location::util::cli;
+
+location::cmds::Test::Test()
+    : CommandWithFlagsAndAction{cli::Name{"test"}, cli::Usage{"test"}, cli::Description{"executes runtime tests against the gps provider."}}
+{
+    action([this](const Context& ctxt)
+    {
+        return location::execute_runtime_tests(ctxt.cout, ctxt.cout);
+    });
+}

=== added file 'src/location/cmds/test.h'
--- src/location/cmds/test.h	1970-01-01 00:00:00 +0000
+++ src/location/cmds/test.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_CMDS_TEST_H_
+#define LOCATION_CMDS_TEST_H_
+
+#include <location/util/cli.h>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace cmds
+{
+// Test executes runtime tests against the gps provider.
+class Test : public util::cli::CommandWithFlagsAndAction
+{
+public:
+    // List initializes a new instance.
+    Test();
+};
+}
+}
+
+#endif // LOCATION_CMDS_TEST_H_

=== added file 'src/location/daemon.cpp'
--- src/location/daemon.cpp	1970-01-01 00:00:00 +0000
+++ src/location/daemon.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/daemon.h>
+
+#include <location/cmds/list.h>
+#include <location/cmds/provider.h>
+#include <location/cmds/run.h>
+#include <location/cmds/status.h>
+#include <location/cmds/test.h>
+
+#include <glog/logging.h>
+
+#include <iostream>
+
+namespace cli = location::util::cli;
+
+location::Daemon::Daemon()
+    : cmd{cli::Name{"locationd"}, cli::Usage{"locationd"}, cli::Description{"locationd"}}
+{    
+    cmd.command(std::make_shared<location::cmds::List>());
+    cmd.command(std::make_shared<location::cmds::Provider>());
+    cmd.command(std::make_shared<location::cmds::Run>());
+    cmd.command(std::make_shared<location::cmds::Status>());
+    cmd.command(std::make_shared<location::cmds::Test>());
+}
+
+int location::Daemon::run(const std::vector<std::string> &args)
+{
+    // Setup logging for the daemon.
+    FLAGS_logtostderr = true;
+    FLAGS_stop_logging_if_full_disk = true;
+    FLAGS_max_log_size = 5;
+
+    google::InitGoogleLogging("locationd");
+
+    return cmd.run(cli::Command::Context{std::cin, std::cout, args});
+}

=== added file 'src/location/daemon.h'
--- src/location/daemon.h	1970-01-01 00:00:00 +0000
+++ src/location/daemon.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_DAEMON_H_
+#define LOCATION_DAEMON_H_
+
+#include <location/util/cli.h>
+#include <location/util/do_not_copy_or_move.h>
+
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace location
+{
+/// @brief Daemon implements biometryd.
+class Daemon : private util::DoNotCopyOrMove
+{
+public:
+    /// @brief Daemon creates a new instance, populating the map of known commands.
+    Daemon();
+
+    /// @brief run executes the daemon.
+    int run(const std::vector<std::string>& args);
+
+private:
+    util::cli::CommandWithSubcommands cmd;
+};
+}
+
+#endif // LOCATION_DAEMON_H_

=== added file 'src/location/daemon_main.cpp'
--- src/location/daemon_main.cpp	1970-01-01 00:00:00 +0000
+++ src/location/daemon_main.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/daemon.h>
+
+int main(int argc, char** argv)
+{
+    location::Daemon daemon;
+    return daemon.run(location::util::cli::args(argc, argv));
+}

=== modified file 'src/location/dbus/skeleton/service.cpp'
--- src/location/dbus/skeleton/service.cpp	2016-06-28 11:53:34 +0000
+++ src/location/dbus/skeleton/service.cpp	2016-06-30 09:21:49 +0000
@@ -42,17 +42,17 @@
 {
 }
 
-location::service::Credentials
+location::Credentials
 location::dbus::skeleton::Service::DBusDaemonCredentialsResolver::resolve_credentials_for_incoming_message(const core::dbus::Message::Ptr& msg)
 {
-    return location::service::Credentials
+    return location::Credentials
     {
         static_cast<pid_t>(daemon.get_connection_unix_process_id(msg->sender())),
         static_cast<uid_t>(daemon.get_connection_unix_user(msg->sender()))
     };
 }
 
-core::dbus::types::ObjectPath location::dbus::skeleton::Service::ObjectPathGenerator::object_path_for_caller_credentials(const location::service::Credentials&)
+core::dbus::types::ObjectPath location::dbus::skeleton::Service::ObjectPathGenerator::object_path_for_caller_credentials(const location::Credentials&)
 {
     static std::uint32_t index{0};
     std::stringstream ss; ss << "/sessions/" << index++;
@@ -76,22 +76,42 @@
       },
       connections
       {
-          properties.state->changed().connect([this](State state)
-          {
-              on_state_changed(state);
-          }),
-          properties.does_satellite_based_positioning->changed().connect([this](bool value)
-          {
-              on_does_satellite_based_positioning_changed(value);
-          }),
-          properties.does_report_cell_and_wifi_ids->changed().connect([this](bool value)
-          {
-              on_does_report_cell_and_wifi_ids_changed(value);
-          }),
-          properties.is_online->changed().connect([this](bool value)
-          {
-              on_is_online_changed(value);
-          })
+          {
+              properties.state->changed().connect([this](State state)
+              {
+                  on_state_changed(state);
+              }),
+              properties.does_satellite_based_positioning->changed().connect([this](bool value) mutable
+              {
+                  on_does_satellite_based_positioning_changed(value); Service::configuration.impl->does_satellite_based_positioning() = value;
+              }),
+              properties.does_report_cell_and_wifi_ids->changed().connect([this](bool value) mutable
+              {
+                  on_does_report_cell_and_wifi_ids_changed(value); Service::configuration.impl->does_report_cell_and_wifi_ids() = value;
+              }),
+              properties.is_online->changed().connect([this](bool value) mutable
+              {
+                  on_is_online_changed(value); Service::configuration.impl->is_online() = value;
+              })
+          },
+          {
+              Service::configuration.impl->state().changed().connect([this](State state) mutable
+              {
+                  properties.state->set(state);
+              }),
+              Service::configuration.impl->does_satellite_based_positioning().changed().connect([this](bool value) mutable
+              {
+                  properties.does_satellite_based_positioning->set(value);
+              }),
+              Service::configuration.impl->does_report_cell_and_wifi_ids().changed().connect([this](bool value) mutable
+              {
+                  properties.does_report_cell_and_wifi_ids->set(value);
+              }),
+              Service::configuration.impl->is_online().changed().connect([this](bool value) mutable
+              {
+                  properties.is_online->set(value);
+              })
+          }
       }
 {
     object->install_method_handler<location::dbus::Service::CreateSessionForCriteria>([this](const core::dbus::Message::Ptr& msg)
@@ -129,7 +149,7 @@
         auto result =
             configuration.permission_manager->check_permission_for_credentials(criteria, credentials);
 
-        if (service::PermissionManager::Result::rejected == result) throw std::runtime_error
+        if (PermissionManager::Result::rejected == result) throw std::runtime_error
         {
             "Client lacks permissions to access the service with the given criteria"
         };
@@ -306,3 +326,8 @@
 {
     return *properties.visible_space_vehicles;
 }
+
+location::Service::Session::Ptr location::dbus::skeleton::Service::create_session_for_criteria(const Criteria& criteria)
+{
+    return configuration.impl->create_session_for_criteria(criteria);
+}

=== modified file 'src/location/dbus/skeleton/service.h'
--- src/location/dbus/skeleton/service.h	2016-06-28 11:53:34 +0000
+++ src/location/dbus/skeleton/service.h	2016-06-30 09:21:49 +0000
@@ -20,11 +20,10 @@
 #define LOCATION_DBUS_SKELETON_SERVICE_H_
 
 #include <location/service.h>
+#include <location/permission_manager.h>
 
 #include <location/dbus/service.h>
 
-#include <location/service/permission_manager.h>
-
 #include <core/dbus/dbus.h>
 #include <core/dbus/object.h>
 #include <core/dbus/property.h>
@@ -55,7 +54,7 @@
         virtual ~CredentialsResolver() = default;
 
         // Resolves the sender of msg to the respective credentials.
-        virtual service::Credentials resolve_credentials_for_incoming_message(const core::dbus::Message::Ptr& msg) = 0;
+        virtual Credentials resolve_credentials_for_incoming_message(const core::dbus::Message::Ptr& msg) = 0;
     };
 
     // Implements CredentialsResolver by reaching out to the dbus daemon and
@@ -68,7 +67,7 @@
         DBusDaemonCredentialsResolver(const core::dbus::Bus::Ptr& bus);
 
         // Resolves the sender of msg to pid, uid by calling out to the dbus daemon.
-        service::Credentials resolve_credentials_for_incoming_message(const core::dbus::Message::Ptr& msg);
+        Credentials resolve_credentials_for_incoming_message(const core::dbus::Message::Ptr& msg);
 
         // Stub for accessing the dbus daemon.
         core::dbus::DBus daemon;
@@ -90,36 +89,30 @@
         //    [1.] Query the AppArmor profile name for pid in credentials.
         //    [1.1] If the process is running unconfined, rely on a counter to assemble the session name.
         //    [1.2] If the process is confined, use the AppArmor profile name to generate the path.
-        virtual core::dbus::types::ObjectPath object_path_for_caller_credentials(const service::Credentials& credentials);
+        virtual core::dbus::types::ObjectPath object_path_for_caller_credentials(const Credentials& credentials);
     };
 
     struct Configuration
     {
-        // DBus connection set up for handling requests to the service.
-        core::dbus::Bus::Ptr incoming;
-        // DBus connection for reaching out to other services in a non-blocking way.
-        core::dbus::Bus::Ptr outgoing;
-        // Service instance that the skeleton should be exposed upon.
-        core::dbus::Service::Ptr service;
-        // An implementation of CredentialsResolver for resolving incoming message sender
-        // to Credentials = uid, pid.
-        CredentialsResolver::Ptr credentials_resolver;
-        // An implementation of ObjectPathGenerator for generating session names.
-        ObjectPathGenerator::Ptr object_path_generator;
-        // Permission manager implementation for verifying incoming requests.
-        service::PermissionManager::Ptr permission_manager;
+        location::Service::Ptr impl;                        // The actual service implementation.
+        core::dbus::Bus::Ptr incoming;                      // DBus connection set up for handling requests to the service.
+        core::dbus::Bus::Ptr outgoing;                      // DBus connection for reaching out to other services in a non-blocking way.
+        core::dbus::Service::Ptr service;                   // Service instance that the skeleton should be exposed upon.
+        CredentialsResolver::Ptr credentials_resolver;      // An implementation of CredentialsResolver.
+        ObjectPathGenerator::Ptr object_path_generator;     // An implementation of ObjectPathGenerator.
+        PermissionManager::Ptr permission_manager; // A permission manager implementation.
     };
 
     Service(const Configuration& configuration);
     ~Service() noexcept;
 
     // From location::service::Interface
-    const core::Property<State>& state() const;
-    core::Property<bool>& does_satellite_based_positioning();
-    core::Property<bool>& does_report_cell_and_wifi_ids();
-    core::Property<bool>& is_online();
-    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>>& visible_space_vehicles();
-
+    const core::Property<State>& state() const override;
+    core::Property<bool>& does_satellite_based_positioning() override;
+    core::Property<bool>& does_report_cell_and_wifi_ids() override;
+    core::Property<bool>& is_online() override;
+    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>>& visible_space_vehicles() override;
+    Session::Ptr create_session_for_criteria(const Criteria& criteria) override;
 protected:
     // Enable subclasses to alter the state.
     core::Property<State>& mutable_state();
@@ -172,10 +165,21 @@
     // We sign up to property changes here, to be able to report them to the bus
     struct
     {
-        core::ScopedConnection state;
-        core::ScopedConnection does_satellite_based_positioning;
-        core::ScopedConnection does_report_cell_and_wifi_ids;
-        core::ScopedConnection is_online;
+        struct
+        {
+            core::ScopedConnection state;
+            core::ScopedConnection does_satellite_based_positioning;
+            core::ScopedConnection does_report_cell_and_wifi_ids;
+            core::ScopedConnection is_online;
+        } dbus;
+
+        struct
+        {
+            core::ScopedConnection state;
+            core::ScopedConnection does_satellite_based_positioning;
+            core::ScopedConnection does_report_cell_and_wifi_ids;
+            core::ScopedConnection is_online;
+        } impl;
     } connections;
     // Guards the session store.
     std::mutex guard;

=== added file 'src/location/dummy_service.cpp'
--- src/location/dummy_service.cpp	1970-01-01 00:00:00 +0000
+++ src/location/dummy_service.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/dummy_service.h>
+
+location::Service::Session::Updates& location::DummyService::Session::updates()
+{
+    return updates_;
+}
+
+const core::Property<location::Service::State>& location::DummyService::state() const
+{
+    return state_;
+}
+
+core::Property<bool>& location::DummyService::does_satellite_based_positioning()
+{
+    return does_satellite_based_positioning_;
+}
+
+core::Property<bool>& location::DummyService::is_online()
+{
+    return is_online_;
+}
+
+core::Property<bool>& location::DummyService::does_report_cell_and_wifi_ids()
+{
+    return does_report_cell_and_wifi_ids_;
+}
+
+core::Property<std::map<location::SpaceVehicle::Key, location::SpaceVehicle>>& location::DummyService::visible_space_vehicles()
+{
+    return visible_space_vehicles_;
+}
+
+location::Service::Session::Ptr location::DummyService::create_session_for_criteria(const Criteria&)
+{
+    return std::make_shared<DummyService::Session>();
+}

=== added file 'src/location/dummy_service.h'
--- src/location/dummy_service.h	1970-01-01 00:00:00 +0000
+++ src/location/dummy_service.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_DUMMY_SERVICE_H_
+#define LOCATION_DUMMY_SERVICE_H_
+
+#include <location/service.h>
+
+namespace location
+{
+class DummyService : public Service
+{
+public:
+    class Session : public Service::Session
+    {
+    public:
+        Updates& updates() override;
+
+    private:
+        Updates updates_;
+    };
+
+    const core::Property<State>& state() const override;
+    core::Property<bool>& does_satellite_based_positioning() override;
+    core::Property<bool>& is_online() override;
+    core::Property<bool>& does_report_cell_and_wifi_ids() override;
+    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>>& visible_space_vehicles() override;
+    Session::Ptr create_session_for_criteria(const Criteria& criteria) override;
+
+private:
+    core::Property<State> state_;
+    core::Property<bool> does_satellite_based_positioning_;
+    core::Property<bool> is_online_;
+    core::Property<bool> does_report_cell_and_wifi_ids_;
+    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>> visible_space_vehicles_;
+};
+}
+
+#endif // LOCATION_DUMMY_SERVICE_H_

=== added file 'src/location/permission_manager.h'
--- src/location/permission_manager.h	1970-01-01 00:00:00 +0000
+++ src/location/permission_manager.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,73 @@
+/*
+ * 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_PERMISSION_MANAGER_H_
+#define LOCATION_PERMISSION_MANAGER_H_
+
+#include <memory>
+
+namespace location
+{
+struct Criteria;
+/** @brief Credentials of a remote session. */
+struct Credentials
+{
+    /** @brief The process id of the remote peer. */
+    pid_t pid;
+    /** @brief The user id the remote peer runs under. */
+    uid_t uid;
+};
+
+/**
+ * @brief The PermissionManager class is an interface to check whether an application
+ * is allowed to access the location services.
+ */
+class PermissionManager
+{
+public:
+    /** Manager pointer type. */
+    typedef std::shared_ptr<PermissionManager> Ptr;
+
+    /**
+     * @brief The Result enum summarizes the results of a query for permissions.
+     */
+    enum class Result
+    {
+        granted, ///< The app is allowed to access the location service.
+        rejected ///< The app is not allowed to access the location service.
+    };
+
+    virtual ~PermissionManager() = default;
+    PermissionManager(const PermissionManager&) = delete;
+    PermissionManager& operator=(const PermissionManager&) = delete;
+
+    /**
+     * @brief Checks whether the app with the given credentials is allowed to access the service for the given criteria.
+     * @param criteria The requirements of the remote peer.
+     * @param credentials The credentials identifying the remote peer.
+     * @return Result::granted if the remote peer is allowed to access the location service, Result::rejected otherwise.
+     */
+    virtual Result check_permission_for_credentials(
+        const Criteria& criteria,
+        const Credentials& credentials) = 0;
+    
+protected:
+    PermissionManager() = default;
+};
+}
+
+#endif // LOCATION_PERMISSION_MANAGER_H_

=== modified file 'src/location/providers/gps/sntp_reference_time_source.cpp'
--- src/location/providers/gps/sntp_reference_time_source.cpp	2016-06-26 21:17:03 +0000
+++ src/location/providers/gps/sntp_reference_time_source.cpp	2016-06-30 09:21:49 +0000
@@ -19,7 +19,7 @@
 #include <location/providers/gps/sntp_reference_time_source.h>
 
 #include <location/configuration.h>
-#include <location/service/runtime.h>
+#include <location/runtime.h>
 
 #include <boost/property_tree/ini_parser.hpp>
 
@@ -46,7 +46,7 @@
 
 gps::HardwareAbstractionLayer::ReferenceTimeSample gps::SntpReferenceTimeSource::sample()
 {
-    auto rt = location::service::Runtime::create();
+    auto rt = location::Runtime::create();
     rt->start();
 
     location::providers::gps::sntp::Client sntp_client;

=== added file 'src/location/runtime.cpp'
--- src/location/runtime.cpp	1970-01-01 00:00:00 +0000
+++ src/location/runtime.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,107 @@
+/*
+ * Copyright © 2015 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 PARTIlocationAR 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 <location/runtime.h>
+
+#include <location/logging.h>
+
+namespace
+{
+// exception_safe_run runs service, catching all exceptions and
+// restarting operation until an explicit shutdown has been requested.
+//
+// TODO(tvoss): Catching all exceptions is risky as they might signal unrecoverable
+// errors. We should enable calling code to decide whether an exception should be considered
+// fatal or not.
+void exception_safe_run(boost::asio::io_service& service)
+{
+    while (true)
+    {
+        try
+        {
+            service.run();
+            // a clean return from run only happens in case of
+            // stop() being called (we are keeping the service alive with
+            // a service::work instance).
+            break;
+        }
+        catch (const std::exception& e)
+        {
+            LOG(WARNING) << e.what();
+        }
+        catch (...)
+        {
+            LOG(WARNING) << "Unknown exception caught while executing boost::asio::io_service";
+        }
+    }
+}
+}
+
+std::shared_ptr<location::Runtime> location::Runtime::create(std::uint32_t pool_size)
+{
+    return std::shared_ptr<location::Runtime>(new location::Runtime(pool_size));
+}
+
+location::Runtime::Runtime(std::uint32_t pool_size)
+    : pool_size_{pool_size},
+      service_{pool_size_},
+      strand_{service_},
+      keep_alive_{service_}
+{
+}
+
+location::Runtime::~Runtime()
+{
+    try
+    {
+        stop();
+    } catch(...)
+    {
+        // Dropping all exceptions to satisfy the nothrow guarantee.
+    }
+}
+
+void location::Runtime::start()
+{
+    for (unsigned int i = 0; i < pool_size_; i++)
+        workers_.push_back(std::thread{exception_safe_run, std::ref(service_)});
+}
+
+void location::Runtime::stop()
+{
+    service_.stop();
+
+    for (auto& worker : workers_)
+        if (worker.joinable())
+            worker.join();
+}
+
+std::function<void(std::function<void()>)> location::Runtime::to_dispatcher_functional()
+{
+    // We have to make sure that we stay alive for as long as
+    // calling code requires the dispatcher to work.
+    auto sp = shared_from_this();
+    return [sp](std::function<void()> task)
+    {
+        sp->strand_.post(task);
+    };
+}
+
+boost::asio::io_service& location::Runtime::service()
+{
+    return service_;
+}

=== added file 'src/location/runtime.h'
--- src/location/runtime.h	1970-01-01 00:00:00 +0000
+++ src/location/runtime.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright © 2015 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 PARTIlocationAR 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_RUNTIME_H_
+#define LOCATION_RUNTIME_H_
+
+#include <boost/asio.hpp>
+
+#include <functional>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include <cstdint>
+
+namespace location
+{
+// We bundle our "global" runtime dependencies here, specifically
+// a dispatcher to decouple multiple in-process providers from one
+// another , forcing execution to a well known set of threads.
+class Runtime : public std::enable_shared_from_this<Runtime>
+{
+public:
+    // Our default concurrency setup.
+    static constexpr const std::uint32_t worker_threads = 4;
+
+    // create returns a Runtime instance with pool_size worker threads
+    // executing the underlying service.
+    static std::shared_ptr<Runtime> create(std::uint32_t pool_size = worker_threads);
+
+    Runtime(const Runtime&) = delete;
+    Runtime(Runtime&&) = delete;
+    // Tears down the runtime, stopping all worker threads.
+    ~Runtime() noexcept(true);
+    Runtime& operator=(const Runtime&) = delete;
+    Runtime& operator=(Runtime&&) = delete;
+
+    // start executes the underlying io_service on a thread pool with
+    // the size configured at creation time.
+    void start();
+
+    // stop cleanly shuts down a Runtime instance,
+    // joining all worker threads.
+    void stop();
+
+    // to_dispatcher_functional returns a function for integration 
+    // with components that expect a dispatcher for operation. 
+    std::function<void(std::function<void()>)> to_dispatcher_functional();
+
+    // service returns the underlying boost::asio::io_service that is executed
+    // by the Runtime.
+    boost::asio::io_service& service();
+
+private:
+    // Runtime constructs a new instance, firing up pool_size 
+    // worker threads.
+    Runtime(std::uint32_t pool_size);
+
+    std::uint32_t pool_size_;
+    boost::asio::io_service service_;
+    boost::asio::io_service::strand strand_;
+    boost::asio::io_service::work keep_alive_;
+    std::vector<std::thread> workers_;
+};
+}
+
+#endif // LOCATION_RUNTIME_H_

=== added file 'src/location/runtime_tests.cpp'
--- src/location/runtime_tests.cpp	1970-01-01 00:00:00 +0000
+++ src/location/runtime_tests.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,185 @@
+/*
+ * Copyright © 2015 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 <location/runtime.h>
+#include <location/runtime_tests.h>
+
+#include <location/clock.h>
+#include <location/providers/gps/hardware_abstraction_layer.h>
+
+#include <boost/accumulators/accumulators.hpp>
+#include <boost/accumulators/statistics/stats.hpp>
+#include <boost/accumulators/statistics/mean.hpp>
+#include <boost/accumulators/statistics/variance.hpp>
+
+#include <cstdlib>
+
+#include <chrono>
+#include <condition_variable>
+#include <iostream>
+#include <mutex>
+#include <thread>
+
+namespace gps = location::providers::gps;
+
+namespace
+{
+template<bool expected, typename Exception>
+void expect(bool value, const std::string& what)
+{
+    if (value != expected) throw Exception{what};
+}
+
+// Poor man's testing fixture, taking care of shutting down the currently
+// running service instance and restarting it after the tests have been run.
+struct Fixture
+{
+    Fixture()
+    {
+        // We need to make sure that we are running as root. In addition, we will stop
+        // any running location service instance prior to executing the test.
+        expect<true, std::logic_error>(::getuid() == 0, "This test has to be run as root.");
+
+        int rc = ::system("service ubuntu-location-service stop");
+        // We consciously ignore any issues and assume that we are good to go.
+        (void) rc;
+    }
+
+    ~Fixture()
+    {
+        int rc = ::system("service ubuntu-location-service start");
+        // We consciously ignore any issues reported by the call to system
+        // as we would make an otherwise fine test-suite failing just because
+        // an "uninteresting" post-condition is not satisfied.
+        (void) rc;
+    }
+};
+
+#if defined(LOCATION_PROVIDERS_GPS)
+int snr_and_ttff(std::ostream& cout, std::ostream& cerr)
+{
+    typedef boost::accumulators::accumulator_set<
+        double,
+        boost::accumulators::stats<
+            boost::accumulators::tag::mean,
+            boost::accumulators::tag::variance
+        >
+    > Statistics;
+
+    using boost::accumulators::mean;
+    using boost::accumulators::variance;
+
+    static const unsigned int trials = 3;
+
+    Statistics stats;
+    auto hal = gps::HardwareAbstractionLayer::create_default_instance();
+
+    struct State
+    {
+        State() : fix_received(false)
+        {
+        }
+
+        bool wait_for_fix_for(const std::chrono::seconds& seconds)
+        {
+            std::unique_lock<std::mutex> ul(guard);
+            return wait_condition.wait_for(
+                        ul,
+                        seconds,
+                        [this]() {return fix_received == true;});
+        }
+
+        void on_position_updated(const location::Position&)
+        {
+            fix_received = true;
+            wait_condition.notify_all();
+        }
+
+        void reset()
+        {
+            fix_received = false;
+        }
+
+        std::mutex guard;
+        std::condition_variable wait_condition;
+        bool fix_received;
+    } state;
+
+    // We want to run in standalone mode
+    hal->set_assistance_mode(gps::AssistanceMode::standalone);
+
+    // We wire up our state to position updates from the hal.
+    hal->position_updates().connect([&state](const location::Position& pos)
+    {
+        state.on_position_updated(pos);
+    });
+
+    // We report updates to the visible space vehicles here.
+    hal->space_vehicle_updates().connect([&cout](const std::set<location::SpaceVehicle>& svs)
+    {
+        cout << std::scientific;
+        cout << "key snr has_almanac_data has_ephimeris_data used_in_fix azimuth elevation" << std::endl;
+        for (const auto& sv : svs)
+            cout << sv.key.id << " " << sv.snr << " " << sv.has_almanac_data << " " << sv.has_ephimeris_data << " " << sv.used_in_fix << " " << sv.azimuth.value() << " " << sv.elevation.value() << std::endl;
+    });
+
+    for (unsigned int i = 0; i < trials; i++)
+    {
+        // We want to force a cold start per trial.
+        hal->delete_all_aiding_data();
+
+        state.reset();
+        auto start = std::chrono::duration_cast<std::chrono::microseconds>(location::Clock::now().time_since_epoch());
+        {
+            hal->start_positioning();
+            // We expect a maximum cold start time of 15 minutes. The theoretical
+            // limit is 12.5 minutes, and we add up some grace period to make the
+            // test more robust (see http://en.wikipedia.org/wiki/Time_to_first_fix).
+            expect<true, std::runtime_error>(state.wait_for_fix_for(std::chrono::seconds{15 * 60}), "Wait for fix timed out.");
+            hal->stop_positioning();
+        }
+        auto stop = std::chrono::duration_cast<std::chrono::microseconds>(location::Clock::now().time_since_epoch());
+
+        stats((stop - start).count());
+    }
+
+    cout << "Mean time to first fix in [ms]: "
+              << std::chrono::duration_cast<std::chrono::milliseconds>(
+                     std::chrono::microseconds(
+                         static_cast<std::uint64_t>(mean(stats)))).count()
+              << std::endl;
+    cout << "Variance in time to first fix in [ms]: "
+              << std::chrono::duration_cast<std::chrono::milliseconds>(
+                     std::chrono::microseconds(
+                         static_cast<std::uint64_t>(variance(stats)))).count()
+              << std::endl;
+
+    return 0;
+}
+#else
+int snr_and_ttff(std::ostream&, std::ostream&) { return 0; }
+#endif // LOCATION_PROVIDERS_GPS
+}
+
+int location::execute_runtime_tests(std::ostream& cout, std::ostream& cerr)
+{
+    Fixture fixture; // This throws in case of issues.
+    auto rc = snr_and_ttff(cout, cerr); if (rc != 0) return rc;
+    // Other runtime tests go here;
+    return rc;
+}

=== added file 'src/location/runtime_tests.h'
--- src/location/runtime_tests.h	1970-01-01 00:00:00 +0000
+++ src/location/runtime_tests.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2015 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_RUNTIME_TESTS_H_
+#define LOCATION_RUNTIME_TESTS_H_
+
+#include <iosfwd>
+
+namespace location
+{
+// execute_runtime_tests runs all configured runtime tests.
+// Returns 0 if successful.
+int execute_runtime_tests(std::ostream& cout, std::ostream& cerr);
+}
+
+#endif // LOCATION_RUNTIME_TESTS_H_

=== added file 'src/location/service_with_engine.cpp'
--- src/location/service_with_engine.cpp	1970-01-01 00:00:00 +0000
+++ src/location/service_with_engine.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,129 @@
+/*
+ * 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 <location/proxy_provider.h>
+#include <location/service_with_engine.h>
+#include <location/session_with_provider.h>
+
+location::ServiceWithEngine::ServiceWithEngine(const Engine::Ptr& engine)
+    : engine{engine},
+      connections
+      {
+          is_online_.changed().connect(
+              [this](bool value)
+              {
+                  ServiceWithEngine::engine->configuration.engine_state
+                        = value ?
+                            Engine::Status::on :
+                            Engine::Status::off;
+              }),
+          does_report_cell_and_wifi_ids_.changed().connect(
+              [this](bool value)
+              {
+                  ServiceWithEngine::engine->configuration.wifi_and_cell_id_reporting_state
+                      = value ?
+                          location::WifiAndCellIdReportingState::on :
+                          location::WifiAndCellIdReportingState::off;
+              }),
+          does_satellite_based_positioning_.changed().connect(
+              [this](bool value)
+              {
+                  ServiceWithEngine::engine->configuration.satellite_based_positioning_state
+                          = value ?
+                              location::SatelliteBasedPositioningState::on :
+                              location::SatelliteBasedPositioningState::off;
+              }),
+          engine->configuration.engine_state.changed().connect(
+              [this](Engine::Status status)
+              {
+                  switch (status)
+                  {
+                      case Engine::Status::off:
+                          is_online_ = false;
+                          state_ = State::disabled;
+                          break;
+                      case Engine::Status::on:
+                          is_online_ = true;
+                          state_ = State::enabled;
+                          break;
+                      case Engine::Status::active:
+                          is_online_ = true;
+                          state_ = State::active;
+                          break;
+                  }
+              }),
+          engine->configuration.satellite_based_positioning_state.changed().connect(
+              [this](location::SatelliteBasedPositioningState state)
+              {
+                  does_satellite_based_positioning_ =
+                          state == location::SatelliteBasedPositioningState::on;
+              }),
+          engine->updates.visible_space_vehicles.changed().connect(
+              [this](const std::map<location::SpaceVehicle::Key, location::SpaceVehicle>&svs)
+              {
+                  visible_space_vehicles_ = svs;
+              })
+      }
+{
+}
+
+const core::Property<location::Service::State>& location::ServiceWithEngine::state() const
+{
+    return state_;
+}
+
+core::Property<bool>& location::ServiceWithEngine::does_satellite_based_positioning()
+{
+    return does_satellite_based_positioning_;
+}
+
+core::Property<bool>& location::ServiceWithEngine::is_online()
+{
+    return is_online_;
+}
+
+core::Property<bool>& location::ServiceWithEngine::does_report_cell_and_wifi_ids()
+{
+    return does_report_cell_and_wifi_ids_;
+}
+
+core::Property<std::map<location::SpaceVehicle::Key, location::SpaceVehicle>>& location::ServiceWithEngine::visible_space_vehicles()
+{
+    return visible_space_vehicles_;
+}
+
+location::Service::Session::Ptr location::ServiceWithEngine::create_session_for_criteria(const Criteria& criteria)
+{
+    auto proxy_provider = std::make_shared<ProxyProvider>(engine->determine_provider_selection_for_criteria(criteria));
+    auto session = std::make_shared<SessionWithProvider>(proxy_provider);
+    std::weak_ptr<Session> wp{session};
+
+    session->updates().position_status.changed().connect([this, wp](const Session::Updates::Status& status)
+    {
+        location::Optional<location::Update<location::Position>> last_known_position = engine->updates.last_known_location.get();
+        bool has_last_known_position = last_known_position ? true : false;
+        bool is_session_enabled = status == Session::Updates::Status::enabled;
+        bool is_session_on_or_active = engine->configuration.engine_state != Engine::Status::off;
+
+        if (has_last_known_position && is_session_enabled && is_session_on_or_active)
+            if (auto sp = wp.lock()) // Immediately send the last known position to the client
+                sp->updates().position = last_known_position.get();
+    });
+
+    return session;
+}

=== added file 'src/location/service_with_engine.h'
--- src/location/service_with_engine.h	1970-01-01 00:00:00 +0000
+++ src/location/service_with_engine.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,61 @@
+/*
+ * 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 LOCATION_SERVICE_WITH_ENGINE_H_
+#define LOCATION_SERVICE_WITH_ENGINE_H_
+
+#include <location/engine.h>
+#include <location/service.h>
+
+namespace location
+{
+class ServiceWithEngine : public Service
+{
+public:
+    ServiceWithEngine(const Engine::Ptr& engine);
+
+    // From Service
+    const core::Property<State>& state() const override;
+    core::Property<bool>& does_satellite_based_positioning() override;
+    core::Property<bool>& is_online() override;
+    core::Property<bool>& does_report_cell_and_wifi_ids() override;
+    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>>& visible_space_vehicles() override;
+    Session::Ptr create_session_for_criteria(const Criteria& criteria) override;
+
+private:
+    Engine::Ptr engine; // The engine instance we use for positioning.
+
+    // Properties of the service implementation.
+    core::Property<State> state_;
+    core::Property<bool> does_satellite_based_positioning_;
+    core::Property<bool> is_online_;
+    core::Property<bool> does_report_cell_and_wifi_ids_;
+    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>> visible_space_vehicles_;
+
+    struct
+    {
+        core::ScopedConnection is_online;
+        core::ScopedConnection does_report_cell_and_wifi_ids;
+        core::ScopedConnection does_satellite_based_positioning;
+        core::ScopedConnection engine_state;
+        core::ScopedConnection satellite_based_positioning_state;
+        core::ScopedConnection visible_space_vehicles;
+    } connections;      // All event connections are automatically cut on destruction.
+};
+}
+
+#endif // LOCATION_SERVICE_WITH_ENGINE_H_

=== added file 'src/location/session_with_provider.cpp'
--- src/location/session_with_provider.cpp	1970-01-01 00:00:00 +0000
+++ src/location/session_with_provider.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,111 @@
+/*
+ * 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 <location/session_with_provider.h>
+
+location::SessionWithProvider::SessionWithProvider(const Provider::Ptr& provider)
+    : provider_{provider},
+      connections_
+      {
+          provider_->updates().position.connect(
+              [this](const Update<Position>& update)
+              {
+                  updates().position = update;
+              }),
+          provider_->updates().heading.connect(
+              [this](const Update<Heading>& update)
+              {
+                  updates().heading = update;
+              }),
+          provider_->updates().velocity.connect(
+              [this](const Update<Velocity>& update)
+              {
+                  updates().velocity = update;
+              }),
+          updates().position_status.changed().connect(
+              [this](const Updates::Status& status)
+              {
+                  switch(status)
+                  {
+                  case Updates::Status::enabled:
+                      start_position_updates(); break;
+                  case Updates::Status::disabled:
+                      stop_position_updates(); break;
+                  }
+              }),
+          updates().velocity_status.changed().connect(
+              [this](const Updates::Status& status)
+              {
+                  switch(status)
+                  {
+                  case Updates::Status::enabled:
+                      start_velocity_updates(); break;
+                  case Updates::Status::disabled:
+                      stop_velocity_updates(); break;
+                  }
+              }),
+          updates().heading_status.changed().connect(
+              [this](const Updates::Status& status)
+              {
+                  switch(status)
+                  {
+                  case Updates::Status::enabled:
+                      start_heading_updates(); break;
+                  case Updates::Status::disabled:
+                      stop_heading_updates(); break;
+                  }
+              })
+      }
+{
+}
+
+location::Service::Session::Updates& location::SessionWithProvider::updates()
+{
+    return updates_;
+}
+
+void location::SessionWithProvider::start_position_updates()
+{
+    provider_->state_controller()->start_position_updates();
+}
+
+void location::SessionWithProvider::stop_position_updates()
+{
+    provider_->state_controller()->stop_position_updates();
+}
+
+void location::SessionWithProvider::start_velocity_updates()
+{
+    provider_->state_controller()->start_velocity_updates();
+}
+
+void location::SessionWithProvider::stop_velocity_updates()
+{
+    provider_->state_controller()->stop_velocity_updates();
+}
+
+void location::SessionWithProvider::start_heading_updates()
+{
+    provider_->state_controller()->start_heading_updates();
+}
+
+void location::SessionWithProvider::stop_heading_updates()
+{
+    provider_->state_controller()->stop_heading_updates();
+}
+

=== added file 'src/location/session_with_provider.h'
--- src/location/session_with_provider.h	1970-01-01 00:00:00 +0000
+++ src/location/session_with_provider.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,60 @@
+/*
+ * 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 LOCATION_SESSION_WITH_PROVIDER_H_
+#define LOCATION_SESSION_WITH_PROVIDER_H_
+
+#include <location/provider.h>
+#include <location/service.h>
+
+namespace location
+{
+class SessionWithProvider : public Service::Session
+{
+public:
+    SessionWithProvider(const Provider::Ptr& provider);
+
+    // From Session::Service.
+    Updates& updates() override;
+
+private:
+    void start_position_updates();
+    void stop_position_updates();
+
+    void start_velocity_updates();
+    void stop_velocity_updates();
+
+    void start_heading_updates();
+    void stop_heading_updates();
+
+    Updates updates_;
+    Provider::Ptr provider_;
+
+    struct
+    {
+        core::ScopedConnection position_updates;
+        core::ScopedConnection velocity_updates;
+        core::ScopedConnection heading_updates;
+
+        core::ScopedConnection position_status_updates;
+        core::ScopedConnection heading_status_updates;
+        core::ScopedConnection velocity_status_updates;
+    } connections_;
+};
+}
+
+#endif // LOCATION_SESSION_WITH_PROVIDER_H_

=== added file 'src/location/trust_store_permission_manager.cpp'
--- src/location/trust_store_permission_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/location/trust_store_permission_manager.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,179 @@
+/*
+ * 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]>
+ */
+
+#include <location/trust_store_permission_manager.h>
+#include <location/logging.h>
+
+#include <core/trust/dbus_agent.h>
+
+#include <core/dbus/bus.h>
+#include <core/dbus/asio/executor.h>
+
+#include <core/posix/this_process.h>
+
+#include <boost/format.hpp>
+
+#include <sys/apparmor.h>
+
+namespace
+{
+bool is_running_under_testing()
+{
+    return core::posix::this_process::env::get(
+                "TRUST_STORE_PERMISSION_MANAGER_IS_RUNNING_UNDER_TESTING",
+                "0") == "1";
+
+}
+
+namespace i18n
+{
+// We only tag strings that should be translated but do not do the actual translation.
+// Point is: The service might run in a system context, without correct locale information.
+// We leave the translation to in-session trust-store instances.
+std::string tr(const std::string& msg)
+{
+    return msg;
+}
+}
+
+// At least make the name a constant, no need to expose it, though.
+static constexpr const char* trust_store_service_name{"UbuntuLocationService"};
+}
+
+location::TrustStorePermissionManager::AppArmorProfileResolver location::TrustStorePermissionManager::libapparmor_profile_resolver()
+{
+    return [](core::trust::Pid pid)
+    {
+        static const int app_armor_error{-1};
+
+        // We make sure to clean up the returned string.
+        struct Scope
+        {
+            ~Scope()
+            {
+                if (con) ::free(con);
+            }
+
+            char* con{nullptr};
+            char* mode{nullptr};
+        } scope;
+
+        // Reach out to apparmor
+        auto rc = aa_gettaskcon(pid.value, &scope.con, &scope.mode);
+
+        // From man aa_gettaskcon:
+        // On success size of data placed in the buffer is returned, this includes the mode if
+        //present and any terminating characters. On error, -1 is returned, and errno(3) is
+        //set appropriately.
+        if (rc == app_armor_error) throw std::system_error
+        {
+            errno,
+            std::system_category()
+        };
+
+        // Safely construct the string
+        return std::string
+        {
+            scope.con ? scope.con : ""
+        };
+    };
+}
+
+core::trust::Feature location::TrustStorePermissionManager::default_feature()
+{
+    return core::trust::Feature{0};
+}
+
+location::TrustStorePermissionManager::Ptr location::TrustStorePermissionManager::create_default_instance_with_bus(const std::shared_ptr<core::dbus::Bus>& bus)
+{
+    return Ptr
+    {
+        new TrustStorePermissionManager
+        {
+            core::trust::dbus::create_multi_user_agent_for_bus_connection(
+                        bus,
+                        trust_store_service_name),
+            TrustStorePermissionManager::libapparmor_profile_resolver()
+        }
+    };
+}
+
+location::TrustStorePermissionManager::TrustStorePermissionManager(
+        const std::shared_ptr<core::trust::Agent>& agent,
+        location::TrustStorePermissionManager::AppArmorProfileResolver app_armor_profile_resolver)
+    : agent{agent},
+      app_armor_profile_resolver{app_armor_profile_resolver}
+{
+}
+
+location::PermissionManager::Result location::TrustStorePermissionManager::check_permission_for_credentials(
+        const location::Criteria&,
+        const location::Credentials& credentials)
+{
+    // This is ugly and we should get rid of it. Ideally, we would be able
+    // inject a mocked trust-store into our acceptance testing.
+    if (is_running_under_testing())
+        return Result::granted;
+
+    std::string profile;
+    try
+    {
+        profile = app_armor_profile_resolver(core::trust::Pid{credentials.pid});
+    } catch(const std::exception& e)
+    {
+        SYSLOG(ERROR) << "Could not resolve PID " << credentials.pid << " to apparmor profile: " << e.what();
+        return location::PermissionManager::Result::rejected;
+    } catch(...)
+    {
+        SYSLOG(ERROR) << "Could not resolve PID " << credentials.pid << " to apparmor profile.";
+        return location::PermissionManager::Result::rejected;
+    }
+
+    std::string description = i18n::tr("wants to access your current location.");
+
+    core::trust::Agent::RequestParameters params
+    {
+        core::trust::Uid{credentials.uid},
+        core::trust::Pid{credentials.pid},
+        profile,
+        TrustStorePermissionManager::default_feature(),
+        description
+    };
+
+    Result result{Result::rejected};
+
+    try
+    {
+        auto answer = agent->authenticate_request_with_parameters(params);
+        switch(answer)
+        {
+        case core::trust::Request::Answer::granted:
+            result = Result::granted;
+            break;
+        case core::trust::Request::Answer::denied:
+            result = Result::rejected;
+            break;
+        }
+    } catch(...)
+    {
+        // We silently drop all issues here and return rejected.
+        result = Result::rejected;
+    }
+
+    return result;
+}

=== added file 'src/location/trust_store_permission_manager.h'
--- src/location/trust_store_permission_manager.h	1970-01-01 00:00:00 +0000
+++ src/location/trust_store_permission_manager.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,76 @@
+/*
+ * 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_TRUST_STORE_PERMISSION_MANAGER_H_
+#define LOCATION_SERVICE_TRUST_STORE_PERMISSION_MANAGER_H_
+
+#include <location/permission_manager.h>
+
+#include <core/trust/agent.h>
+
+namespace core
+{
+namespace dbus
+{
+class Bus;
+}
+}
+
+namespace location
+{
+// A PermmissionManager implementation leveraging the trust-store
+// infrastructure to cache a user's answer and to dispatch
+// to user-specific trust-store instances.
+class TrustStorePermissionManager : public PermissionManager
+{
+public:
+    // Just a convenience typedef.
+    typedef std::shared_ptr<TrustStorePermissionManager> Ptr;
+
+    // Functor for resolving a process id to an app-armor profile name.
+    typedef std::function<std::string(const core::trust::Pid&)> AppArmorProfileResolver;
+
+    // Returns an AppArmorProfileResolver leveraging libapparmor.
+    static AppArmorProfileResolver libapparmor_profile_resolver();
+
+    // The default feature tag we use when calling out to the agent.
+    static core::trust::Feature default_feature();
+
+    // Creates a default instance, initializing the agent and resolver
+    // fields to sensible default choices.
+    static Ptr create_default_instance_with_bus(const std::shared_ptr<core::dbus::Bus>& bus);
+
+    // Sets up the manager for operation and stores the agent and resolver
+    // instances given to the ctor.
+    TrustStorePermissionManager(
+            const std::shared_ptr<core::trust::Agent>& agent,
+            AppArmorProfileResolver app_armor_profile_resolver);
+
+    // From PermissionManager
+    Result check_permission_for_credentials(const Criteria&, const Credentials& credentials) override;
+
+private:
+    // The agent instance we leverage to authenticate
+    // permission requests.
+    std::shared_ptr<core::trust::Agent> agent;
+
+    // Helper to resolve an application's pid to an app-armor profile name.
+    AppArmorProfileResolver app_armor_profile_resolver;
+};
+}
+
+#endif // LOCATION_SERVICE_TRUST_STORE_PERMISSION_MANAGER_H_

=== added directory 'src/location/util'
=== added file 'src/location/util/cli.cpp'
--- src/location/util/cli.cpp	1970-01-01 00:00:00 +0000
+++ src/location/util/cli.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/util/cli.h>
+
+#include <boost/format.hpp>
+#include <boost/program_options.hpp>
+
+#include <iomanip>
+
+namespace cli = location::util::cli;
+namespace po = boost::program_options;
+
+namespace
+{
+namespace pattern
+{
+static constexpr const char* help_for_command_with_subcommands =
+"NAME:\n"
+"    %1% - %2%\n"
+"\n"
+"USAGE:\n"
+"    %3% [command options] [arguments...]";
+
+static constexpr const char* commands   = "COMMANDS:";
+static constexpr const char* command    = "    %1% %2%";
+
+static constexpr const char* options    = "OPTIONS:";
+static constexpr const char* option     = "    --%1% %2%";
+}
+
+void add_to_desc_for_flags(po::options_description& desc, const std::set<cli::Flag::Ptr>& flags)
+{
+    for (auto flag : flags)
+    {
+        auto v = po::value<std::string>()->notifier([flag](const std::string& s)
+        {
+            flag->notify(s);
+        });
+        desc.add_options()(flag->name().as_string().c_str(), v, flag->description().as_string().c_str());
+    }
+}
+}
+
+location::util::cli::ProgressBar::ProgressBar(std::ostream& out, const std::string& prefix, std::uint32_t width)
+    : prefix{prefix}, width{width}, out{out}
+{
+}
+
+location::util::cli::ProgressBar::~ProgressBar()
+{
+    out << std::endl;
+}
+
+void location::util::cli::ProgressBar::update(double percentage)
+{
+    struct CursorState
+    {
+        CursorState(std::ostream& out) : out{out} { out << "\33[?25l"; }
+        ~CursorState()                            { out << "\33[?25h"; }
+        std::ostream& out;
+    } cs{out};
+
+    out << "\r" << prefix << "[" << std::setw(width) << std::left << std::setfill(' ') << std::string(percentage * width, '=') << "] " << std::setw(5) << std::fixed << std::setprecision(2) << percentage * 100 << " %" << std::flush;
+}
+
+std::vector<std::string> cli::args(int argc, char **argv)
+{
+    std::vector<std::string> result;
+    for (int i = 1; i < argc; i++) result.push_back(argv[i]);
+    return result;
+}
+
+const cli::Name& cli::Flag::name() const
+{
+    return name_;
+}
+
+const cli::Description& cli::Flag::description() const
+{
+    return description_;
+}
+
+cli::Flag::Flag(const Name& name, const Description& description)
+    : name_{name},
+      description_{description}
+{
+}
+
+cli::Command::FlagsWithInvalidValue::FlagsWithInvalidValue() : std::runtime_error{"Flags with invalid value"}
+{
+}
+
+cli::Command::FlagsMissing::FlagsMissing() : std::runtime_error{"Flags are missing in command invocation"}
+{
+}
+
+cli::Name cli::Command::name() const
+{
+    return name_;
+}
+
+cli::Usage cli::Command::usage() const
+{
+    return usage_;
+}
+
+cli::Description cli::Command::description() const
+{
+    return description_;
+}
+
+cli::Command::Command(const cli::Name& name, const cli::Usage& usage, const cli::Description& description)
+    : name_(name),
+      usage_(usage),
+      description_(description)
+{
+}
+
+cli::CommandWithSubcommands::CommandWithSubcommands(const Name& name, const Usage& usage, const Description& description)
+    : Command{name, usage, description}
+{
+    command(std::make_shared<cmd::Help>(*this));
+}
+
+cli::CommandWithSubcommands& cli::CommandWithSubcommands::command(const Command::Ptr& command)
+{
+    commands_[command->name().as_string()] = command;
+    return *this;
+}
+
+cli::CommandWithSubcommands& cli::CommandWithSubcommands::flag(const Flag::Ptr& flag)
+{
+    flags_.insert(flag);
+    return *this;
+}
+
+void cli::CommandWithSubcommands::help(std::ostream& out)
+{
+    out << boost::format(pattern::help_for_command_with_subcommands)
+           % name().as_string() % usage().as_string()
+           % name().as_string() << std::endl;
+
+    if (flags_.size() > 0)
+    {
+        out << std::endl << pattern::options << std::endl;
+        for (const auto& flag : flags_)
+            out << boost::format(pattern::option) % flag->name() % flag->description() << std::endl;
+    }
+
+    if (commands_.size() > 0)
+    {
+        out << std::endl << pattern::commands << std::endl;
+        for (const auto& cmd : commands_)
+            out << boost::format(pattern::command) % cmd.second->name() % cmd.second->description() << std::endl;
+    }
+}
+
+int cli::CommandWithSubcommands::run(const cli::Command::Context& ctxt)
+{
+    po::positional_options_description pdesc;
+    pdesc.add("command", 1);
+
+    po::options_description desc("Options");
+    desc.add_options()("command", po::value<std::string>()->required(), "the command to be executed");
+
+    add_to_desc_for_flags(desc, flags_);
+
+    try
+    {
+        po::variables_map vm;
+        auto parsed = po::command_line_parser(ctxt.args)
+                .options(desc)
+                .positional(pdesc)
+                .style(po::command_line_style::unix_style)
+                .allow_unregistered()
+                .run();
+
+        po::store(parsed, vm);
+        po::notify(vm);
+
+        return commands_[vm["command"].as<std::string>()]->run(cli::Command::Context
+        {
+            ctxt.cin,
+            ctxt.cout,
+            po::collect_unrecognized(parsed.options, po::include_positional)
+        });
+    }
+    catch (const po::error& e)
+    {
+        ctxt.cout << e.what() << std::endl;
+        help(ctxt.cout);
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_FAILURE;
+}
+
+cli::CommandWithFlagsAndAction::CommandWithFlagsAndAction(const Name& name, const Usage& usage, const Description& description)
+    : Command{name, usage, description}
+{
+}
+
+cli::CommandWithFlagsAndAction& cli::CommandWithFlagsAndAction::flag(const Flag::Ptr& flag)
+{
+    flags_.insert(flag);
+    return *this;
+}
+
+cli::CommandWithFlagsAndAction& cli::CommandWithFlagsAndAction::action(const Action& action)
+{
+    action_ = action;
+    return *this;
+}
+
+int cli::CommandWithFlagsAndAction::run(const Context& ctxt)
+{
+    po::options_description cd(name().as_string());
+
+    bool help_requested{false};
+    cd.add_options()("help", po::bool_switch(&help_requested), "produces a help message");
+
+    add_to_desc_for_flags(cd, flags_);
+
+    try
+    {
+        po::variables_map vm;
+        auto parsed = po::command_line_parser(ctxt.args).options(cd).style(po::command_line_style::unix_style).allow_unregistered().run();
+        po::store(parsed, vm);
+        po::notify(vm);
+
+        if (help_requested)
+        {
+            help(ctxt.cout);
+            return EXIT_SUCCESS;
+        }
+
+        return action_(cli::Command::Context
+        {
+            ctxt.cin,
+            ctxt.cout,
+            po::collect_unrecognized(parsed.options, po::exclude_positional)
+        });
+    }
+    catch (const po::error& e)
+    {
+        ctxt.cout << e.what() << std::endl;
+        help(ctxt.cout);
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_FAILURE;
+}
+
+void cli::CommandWithFlagsAndAction::help(std::ostream& out)
+{
+    out << boost::format(pattern::help_for_command_with_subcommands)
+           % name().as_string() % description().as_string()
+           % name().as_string() << std::endl;
+
+    if (flags_.size() > 0)
+    {
+        out << std::endl << boost::format(pattern::options) << std::endl;
+        for (const auto& flag : flags_)
+            out << boost::format(pattern::option) % flag->name() % flag->description() << std::endl;
+    }
+}
+
+cli::cmd::Help::Help(Command& cmd)
+    : Command{cli::Name{"help"}, cli::Usage{"prints a short help message"}, cli::Description{"prints a short help message"}},
+      command{cmd}
+{
+}
+
+// From Command
+int cli::cmd::Help::run(const Context &context)
+{
+    command.help(context.cout);
+    return EXIT_FAILURE;
+}
+
+void cli::cmd::Help::help(std::ostream &out)
+{
+    command.help(out);
+}

=== added file 'src/location/util/cli.h'
--- src/location/util/cli.h	1970-01-01 00:00:00 +0000
+++ src/location/util/cli.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,387 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_UTIL_CLI_H_
+#define LOCATION_UTIL_CLI_H_
+
+#include <location/util/do_not_copy_or_move.h>
+#include <location/optional.h>
+
+// TODO(tvoss): Reenable once we introduce visibility of symbols
+// #include <biometry/visibility.h>
+#define LOCATION_DLL_PUBLIC
+
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace location
+{
+namespace util
+{
+namespace cli
+{
+/// @brief ProgressBar prints a progress bar on the terminal.
+///
+/// Looks like:
+/// Prefix[===============----------] xxx.xx %
+///         |--------------- width ------------|
+class LOCATION_DLL_PUBLIC ProgressBar
+{
+public:
+    /// @brief ProgressBar initializes an instance with out, prefix and width.
+    ProgressBar(std::ostream& out, const std::string& prefix = std::string{}, std::uint32_t width = 80);
+    /// @brief ~ProgressBar cleans up and inserts a std::endl into out.
+    ~ProgressBar();
+
+    /// @brief update updates the terminal output for the given percentage.
+    void update(double percentage);
+
+private:
+    /// @cond
+    std::string prefix;
+    std::uint32_t width;
+    std::ostream& out;
+    /// @endcond
+};
+
+template<std::size_t max>
+class LOCATION_DLL_PUBLIC SizeConstrainedString
+{
+public:
+    SizeConstrainedString(const std::string& s) : s{s}
+    {
+        if(s.size() > max)
+            throw std::logic_error{"Max size exceeded " + std::to_string(max)};
+    }
+
+    const std::string& as_string() const
+    {
+        return s;
+    }
+
+    operator std::string() const
+    {
+        return s;
+    }
+
+private:
+    std::string s;
+};
+
+template<std::size_t max>
+LOCATION_DLL_PUBLIC bool operator<(const SizeConstrainedString<max>& lhs, const SizeConstrainedString<max>& rhs)
+{
+    return lhs.as_string() < rhs.as_string();
+}
+
+template<std::size_t max>
+LOCATION_DLL_PUBLIC bool operator==(const SizeConstrainedString<max>& lhs, const SizeConstrainedString<max>& rhs)
+{
+    return lhs.as_string() == rhs.as_string();
+}
+
+template<std::size_t max>
+LOCATION_DLL_PUBLIC std::ostream& operator<<(std::ostream& out, const SizeConstrainedString<max>& scs)
+{
+    return out << std::setw(max) << std::left << scs.as_string();
+}
+
+// We are imposing size constraints to ensure a consistent CLI layout.
+typedef SizeConstrainedString<15> Name;
+typedef SizeConstrainedString<60> Usage;
+typedef SizeConstrainedString<60> Description;
+
+/// @brief Flag models an input parameter to a command.
+class LOCATION_DLL_PUBLIC Flag : public DoNotCopyOrMove
+{
+public:
+    // Safe us some typing.
+    typedef std::shared_ptr<Flag> Ptr;
+
+    /// @brief notify announces a new value to the flag.
+    virtual void notify(const std::string& value) = 0;
+    /// @brief name returns the name of the Flag.
+    const Name& name() const;
+    /// @brief description returns a human-readable description of the flag.
+    const Description& description() const;
+
+protected:
+    /// @brief Flag creates a new instance, initializing name and description
+    /// from the given values.
+    Flag(const Name& name, const Description& description);
+
+private:
+    Name name_;
+    Description description_;
+};
+
+/// @brief TypedFlag implements Flag relying on operator<< and operator>> to read/write values to/from strings.
+template<typename T>
+class LOCATION_DLL_PUBLIC TypedFlag : public Flag
+{
+public:
+    typedef std::shared_ptr<TypedFlag<T>> Ptr;
+
+    TypedFlag(const Name& name, const Description& description) : Flag{name, description}
+    {
+    }
+
+    /// @brief value installs the given value in the flag.
+    TypedFlag& value(const T& value)
+    {
+        value_ = value;
+        return *this;
+    }
+
+    /// @brief value returns the optional value associated with the flag.
+    const Optional<T>& value() const
+    {
+        return value_;
+    }
+
+    /// @brief notify tries to unwrap a value of type T from value.
+    void notify(const std::string& s) override
+    {
+        std::stringstream ss{s};
+        T value; ss >> value;
+        value_ = value;
+    }
+
+private:
+    Optional<T> value_;
+};
+
+/// @brief TypedReferenceFlag implements Flag, relying on operator<</>> to convert to/from string representations,
+/// updating the given mutable reference to a value of type T.
+template<typename T>
+class LOCATION_DLL_PUBLIC TypedReferenceFlag : public Flag
+{
+public:
+    // Safe us some typing.
+    typedef std::shared_ptr<TypedReferenceFlag<T>> Ptr;
+
+    /// @brief TypedReferenceFlag initializes a new instance with name, description and value.
+    TypedReferenceFlag(const Name& name, const Description& description, T& value)
+        : Flag{name, description},
+          value_{value}
+    {
+    }
+
+    /// @brief notify tries to unwrap a value of type T from value,
+    /// relying on operator>> to read from given string s.
+    void notify(const std::string& s) override
+    {
+        std::stringstream ss{s};
+        ss >> value_.get();
+    }
+
+private:
+    std::reference_wrapper<T> value_;
+};
+
+/// @brief OptionalTypedReferenceFlag handles Optional<T> references, making sure that
+/// a value is always read on notify, even if the Optional<T> wasn't initialized previously.
+template<typename T>
+class LOCATION_DLL_PUBLIC OptionalTypedReferenceFlag : public Flag
+{
+public:
+    typedef std::shared_ptr<OptionalTypedReferenceFlag<T>> Ptr;
+
+    OptionalTypedReferenceFlag(const Name& name, const Description& description, Optional<T>& value)
+        : Flag{name, description},
+          value_{value}
+    {
+    }
+
+    /// @brief notify tries to unwrap a value of type T from value.
+    void notify(const std::string& s) override
+    {
+        std::stringstream ss{s}; T value; ss >> value;
+        value_.get() = value;
+    }
+
+private:
+    std::reference_wrapper<Optional<T>> value_;
+};
+
+/// @brief Command abstracts an individual command available from the daemon.
+class LOCATION_DLL_PUBLIC Command : public DoNotCopyOrMove
+{
+public:
+    // Safe us some typing
+    typedef std::shared_ptr<Command> Ptr;    
+
+    /// @brief FlagsMissing is thrown if at least one required flag is missing.
+    struct FlagsMissing : public std::runtime_error
+    {
+        /// @brief FlagsMissing initializes a new instance.
+        FlagsMissing();
+    };
+
+    /// @brief FlagsWithWrongValue is thrown if a value passed on the command line is invalid.
+    struct FlagsWithInvalidValue : public std::runtime_error
+    {
+        /// @brief FlagsWithInvalidValue initializes a new instance.
+        FlagsWithInvalidValue();
+    };
+
+    /// @brief Context bundles information passed to Command::run invocations.
+    struct Context
+    {
+        std::istream& cin;              ///< The std::istream that should be used for reading.
+        std::ostream& cout;             ///< The std::ostream that should be used for writing.
+        std::vector<std::string> args;  ///< The command line args.
+    };
+
+    /// @brief name returns the Name of the command.
+    virtual Name name() const;
+
+    /// @brief usage returns a short usage string for the command.
+    virtual Usage usage() const;
+
+    /// @brief description returns a longer string explaining the command.
+    virtual Description description() const;
+
+    /// @brief run puts the command to execution.
+    virtual int run(const Context& context) = 0;
+
+    /// @brief help prints information about a command to out.
+    virtual void help(std::ostream& out) = 0;
+
+protected:
+    /// @brief Command initializes a new instance with the given name, usage and description.
+    Command(const Name& name, const Usage& usage, const Description& description);
+
+    /// @brief name adjusts the name of the command to n.
+    // virtual void name(const Name& n);
+    /// @brief usage adjusts the usage string of the comand to u.
+    // virtual void usage(const Usage& u);
+    /// @brief description adjusts the description string of the command to d.
+    // virtual void description(const Description& d);
+
+private:
+    Name name_;
+    Usage usage_;
+    Description description_;
+};
+
+/// @brief CommandWithSubcommands implements Command, selecting one of a set of actions.
+class LOCATION_DLL_PUBLIC CommandWithSubcommands : public Command
+{
+public:
+    typedef std::shared_ptr<CommandWithSubcommands> Ptr;
+    typedef std::function<int(const Context&)> Action;
+
+    /// @brief CommandWithSubcommands initializes a new instance with the given name, usage and description
+    CommandWithSubcommands(const Name& name, const Usage& usage, const Description& description);
+
+    /// @brief command adds the given command to the set of known commands.
+    CommandWithSubcommands& command(const Command::Ptr& command);
+
+    /// @brief flag adds the given flag to the set of known flags.
+    CommandWithSubcommands& flag(const Flag::Ptr& flag);
+
+    // From Command
+    int run(const Context& context) override;
+    void help(std::ostream &out) override;
+
+private:
+    std::unordered_map<std::string, Command::Ptr> commands_;
+    std::set<Flag::Ptr> flags_;
+};
+
+/// @brief CommandWithFlagsAction implements Command, executing an Action after handling
+class LOCATION_DLL_PUBLIC CommandWithFlagsAndAction : public Command
+{
+public:
+    typedef std::shared_ptr<CommandWithFlagsAndAction> Ptr;
+    typedef std::function<int(const Context&)> Action;
+
+    /// @brief CommandWithFlagsAndAction initializes a new instance with the given name, usage and description
+    CommandWithFlagsAndAction(const Name& name, const Usage& usage, const Description& description);
+
+    /// @brief flag adds the given flag to the set of known flags.
+    CommandWithFlagsAndAction& flag(const Flag::Ptr& flag);
+
+    /// @brief action installs the given action.
+    CommandWithFlagsAndAction& action(const Action& action);
+
+    // From Command
+    int run(const Context& context) override;
+    void help(std::ostream &out) override;
+
+private:
+    std::set<Flag::Ptr> flags_;
+    Action action_;
+};
+
+namespace cmd
+{
+/// @brief HelpFor prints a help message for the given command on execution.
+class Help : public Command
+{
+public:
+    /// @brief HelpFor initializes a new instance with the given reference to a cmd.
+    explicit Help(Command& cmd);
+
+    // From Command
+    int run(const Context &context) override;
+    void help(std::ostream &out) override;
+
+private:
+    /// @cond
+    Command& command;
+    /// @endcond
+};
+}
+
+/// @brief args returns a vector of strings assembled from argc and argv.
+LOCATION_DLL_PUBLIC std::vector<std::string> args(int argc, char** argv);
+
+/// @brief make_flag returns a flag with the given name and description.
+template<typename T>
+LOCATION_DLL_PUBLIC typename TypedFlag<T>::Ptr make_flag(const Name& name, const Description& description)
+{
+    return std::make_shared<TypedFlag<T>>(name, description);
+}
+
+/// @brief make_flag returns a flag with the given name and description, notifying updates to value.
+template<typename T>
+LOCATION_DLL_PUBLIC typename TypedReferenceFlag<T>::Ptr make_flag(const Name& name, const Description& desc, T& value)
+{
+    return std::make_shared<TypedReferenceFlag<T>>(name, desc, value);
+}
+
+/// @brief make_flag returns a flag with the given name and description, updating the given optional value.
+template<typename T>
+LOCATION_DLL_PUBLIC typename OptionalTypedReferenceFlag<T>::Ptr make_flag(const Name& name, const Description& desc, Optional<T>& value)
+{
+    return std::make_shared<OptionalTypedReferenceFlag<T>>(name, desc, value);
+}
+}
+}
+}
+
+#endif // LOCATION_UTIL_CLI_H_

=== added file 'src/location/util/do_not_copy_or_move.h'
--- src/location/util/do_not_copy_or_move.h	1970-01-01 00:00:00 +0000
+++ src/location/util/do_not_copy_or_move.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_UTIL_DO_NOT_COPY_OR_MOVE_H_
+#define LOCATION_UTIL_DO_NOT_COPY_OR_MOVE_H_
+
+namespace location
+{
+namespace util
+{
+/// @cond
+class DoNotCopyOrMove
+{
+public:
+    DoNotCopyOrMove(const DoNotCopyOrMove&) = delete;
+    DoNotCopyOrMove(DoNotCopyOrMove&&) = delete;
+    virtual ~DoNotCopyOrMove() = default;
+    DoNotCopyOrMove& operator=(const DoNotCopyOrMove&) = delete;
+    DoNotCopyOrMove& operator=(DoNotCopyOrMove&&) = delete;
+
+protected:
+    DoNotCopyOrMove() = default;
+};
+/// @endcond
+}
+}
+
+#endif // LOCATION_UTIL_DO_NOT_COPY_OR_MOVE_H_

=== added file 'src/location/util/well_known_bus.cpp'
--- src/location/util/well_known_bus.cpp	1970-01-01 00:00:00 +0000
+++ src/location/util/well_known_bus.cpp	2016-06-30 09:21:49 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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 <location/util/well_known_bus.h>
+
+#include <boost/assign/list_of.hpp>
+#include <boost/bimap.hpp>
+
+namespace
+{
+typedef boost::bimap<std::string, core::dbus::WellKnownBus> Lut;
+const Lut& lut()
+{
+    static Lut instance = boost::assign::list_of<Lut::relation>
+            ("session", core::dbus::WellKnownBus::session)
+            ("system",  core::dbus::WellKnownBus::system)
+            ("starter", core::dbus::WellKnownBus::starter);
+
+    return instance;
+}
+}
+
+std::ostream& core::dbus::operator<<(std::ostream& out, core::dbus::WellKnownBus bus)
+{
+    return out << lut().right.at(bus);
+}
+
+std::istream& core::dbus::operator>>(std::istream& in, core::dbus::WellKnownBus& bus)
+{
+    std::string s; in >> s; bus = lut().left.at(s);
+    return in;
+}

=== added file 'src/location/util/well_known_bus.h'
--- src/location/util/well_known_bus.h	1970-01-01 00:00:00 +0000
+++ src/location/util/well_known_bus.h	2016-06-30 09:21:49 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU 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_UTIL_WELL_KNOWN_BUS_H_
+#define LOCATION_UTIL_WELL_KNOWN_BUS_H_
+
+#include <core/dbus/well_known_bus.h>
+
+#include <iosfwd>
+
+namespace core
+{
+namespace dbus
+{
+// operator<< inserts bus into out.
+std::ostream& operator<<(std::ostream& out, WellKnownBus bus);
+// operator>> extracts bus from in.
+std::istream& operator>>(std::istream& in, WellKnownBus& bus);
+}
+}
+
+#endif // LOCATION_UTIL_WELL_KNOWN_BUS_H_