Merge lp:~thomas-voss/location-service/robustify-event-propagation-in-case-of-multiple-providers-running into lp:location-service/15.04

[Thomas Voß]

Introduce a dispatching provider that leverages a functor to hand over updates and invocations to/from providers.
Adjust acceptance tests to account for multiple providers.

Introduce a dispatching provider that leverages a functor to hand over updates and invocations to/from providers.
Adjust acceptance tests to account for multiple providers.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:129
http://jenkins.qa.ubuntu.com/job/location-service-ci/316/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/location-service-utopic-amd64-ci/223/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/location-service-utopic-armhf-ci/223/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/location-service-utopic-i386-ci/223/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:130
http://jenkins.qa.ubuntu.com/job/location-service-ci/317/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/location-service-utopic-amd64-ci/224
    SUCCESS: http://jenkins.qa.ubuntu.com/job/location-service-utopic-armhf-ci/224
        deb: http://jenkins.qa.ubuntu.com/job/location-service-utopic-armhf-ci/224/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/location-service-utopic-i386-ci/224

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

review: Approve (continuous-integration)

[Loïc Minier (lool)]

LGTM

review: Approve

[lp:~thomas-voss/location-service/robustify-event-propagation-in-case-of-multiple-providers-running]

131. By Thomas Voß on 2015-11-18

[ Alberto Mardegan ]
* Make sure that injected time is given in milliseconds
[ Thomas Voß ]
* Cherry-pick rev. 196 and 199 from lp:location-service. The changes
  got accidentally removed by merging the outstanding documentation
  branch.
* Handle responses of clients to updates asynchronously. Rely on
  dummy::ConnectivityManager as harvesting is disabled anyway. (LP:
  #1462664, #1387643)
[ Thomas Voß ]
* Add documentation for debugging, hacking and debugging the location
  service. Pull manual testing instructions over from the wiki. Add
  tools for formatting the source.
[ thomas-voss ]
* Add documentation for debugging, hacking and debugging the location
  service. Pull manual testing instructions over from the wiki. Add
  tools for formatting the source.
[ CI Train Bot ]
* New rebuild forced.
[ Manuel de la Pena ]
* Make sure that cached modems are considered as well when calculating
  connection characteristics.
[ CI Train Bot ]
* New rebuild forced.
[ Manuel de la Pena ]
* Improve the selection of the bag of providers to ensure that the
  locations used are within a reasonable time margin.
* Remove the pimpl implementation from the providers and hide their
  public headers because they should only be used within the project.
[ Thomas Voß ]
* Increase default timeout for downloading gps xtra data. (LP:
  #1447161)
[ CI Train Bot ]
* New rebuild forced.
[ Manuel de la Pena ]
* If an exception is thrown from the io_executor run method it must be
  caught, logger and continued with the main loop.
[ CI Train Bot ]
* Launchpad automatic translations update. added: po/af.po po/bg.po
  po/sk.po
* New rebuild forced.
[ thomas-voss ]
* Account for dbus interface breakage in NM from 0.9.8.8 -> 0.9.10.0.
[ thomas-voss ]
* Automatically clean up session store for dead clients. (LP:
  #1418033)
[ thomas-voss ]
* Make the remote::Provider::Stub fail loudly on construction if the
  other side is not reachable. Relax the exception in
  location::Daemon::main and do not exit if instantiating a provider
  fails. (LP: #1414591)
[ CI Train Bot ]
* Resync trunk
[ thomas-voss ]
* Add an interface for querying settings by key. Add an implementation
  leveraging boost::property_tree to provide settings. (LP: #1362765)
* Allow for enabling/disabling providers. Wire up engine state changes
  to enabling/disabling of providers. (LP: #1392399)
[ thomas-voss ]
* Print details about visible space vehicles to the gps provider test
  case. (LP: #1408984)
[ thomas-voss ]
* Fix #1394204 by: (LP: #1394204)
[ Ubuntu daily release ]
* New rebuild forced
[ thomas-voss ]
* Make sure that devices being added/removed by NetworkManager are
  handled correctly. (LP: #1390490)
[ CI bot ]
* Resync trunk
[ Kevin DuBois ]
* The headers shipped in libubuntu-location-service-dev contain
  includes that are provided in the libboost-dev package (specifically
  headers like boost/units/cmath.hpp). Make the dev package depend on
  libboost-dev so the downstreams get what they need to compile
  against the libubuntu-location-service-dev headers
* New rebuild forced
[ thomas-voss ]
* Bump build dependency.
* Disconnect event connections for bag of providers. (LP: #1387572)
[ thomas-voss ]
* Prevent multiple invocations of start positioning on android GPS HAL
  to prevent buggy HAL implementations from blocking. Allow for
  decorated provider names to enable moving providers OOP. (LP:
  #1382501)

132. By Thomas Voß on 2015-11-18

Revert accidental change to debian/source/format.

[Alberto Mardegan (mardy)]

The code looks good to me, but I feel that this makes the logic even more complicated.

I would much rather force all providers to be out of process. This would lead to a simpler design, and might also make it possible to free some memory when the GPS is not in use.

I'm approving this because code-wise it's fine, but if it were for me, I would not merge it.

review: Approve

[lp:~thomas-voss/location-service/robustify-event-propagation-in-case-of-multiple-providers-running]

133. By Thomas Voß on 2015-11-25

Explicitly stop bus instances on shut down.

[Michał Karnicki (karni)]

Was browsing this out of curiosity and to learn. Tiny comment - the license headers should probably contain 2015?

Unmerged revisions

133. By Thomas Voß on 2015-11-25

Explicitly stop bus instances on shut down.

=== modified file 'src/location_service/com/ubuntu/location/CMakeLists.txt'
--- src/location_service/com/ubuntu/location/CMakeLists.txt	2015-04-23 14:48:44 +0000
+++ src/location_service/com/ubuntu/location/CMakeLists.txt	2015-11-25 08:29:55 +0000
@@ -19,6 +19,7 @@
   non_selecting_provider_selection_policy.cpp
 
   criteria.cpp
+  dispatching_provider.cpp
   engine.cpp
   init_and_shutdown.cpp
   position.cpp
 
=== added file 'src/location_service/com/ubuntu/location/dispatching_provider.cpp'
--- src/location_service/com/ubuntu/location/dispatching_provider.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/dispatching_provider.cpp	2015-11-25 08:29:55 +0000
@@ -0,0 +1,325 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <com/ubuntu/location/dispatching_provider.h>
+
+#include <com/ubuntu/location/logging.h>
+
+#include <future>
+
+namespace location = com::ubuntu::location;
+
+location::DispatchingProvider::Ptr location::DispatchingProvider::create(
+        const location::DispatchingProvider::Dispatcher& dispatcher,
+        const location::Provider::Ptr& fwd)
+{
+    std::shared_ptr<location::DispatchingProvider> sp
+    {
+        new location::DispatchingProvider{dispatcher, fwd}
+    };
+    return sp->init();
+}
+
+location::DispatchingProvider::DispatchingProvider(const location::DispatchingProvider::Dispatcher& dispatcher, const location::Provider::Ptr& fwd)
+    : dispatcher{dispatcher},
+      fwd{fwd}
+{
+    if (not dispatcher) throw std::logic_error
+    {
+        "com::ubuntu::location::DispatchingProvider: Cannot operate without valid dispatcher"
+    };
+
+    if (not fwd) throw std::logic_error
+    {
+        "com::ubuntu::location::DispatchingProvider: Cannot operate without valid Provider"
+    };
+}
+
+location::DispatchingProvider::~DispatchingProvider()
+{
+}
+
+bool location::DispatchingProvider::supports(const location::Provider::Features& f) const
+{
+    std::promise<bool> promise;
+    std::future<bool> future = promise.get_future();
+
+    dispatcher([&]()
+    {
+        try
+        {
+            promise.set_value(fwd->supports(f));
+        } catch(const std::exception& e)
+        {
+            LOG(WARNING) << e.what();
+            promise.set_exception(std::current_exception());
+        } catch(...)
+        {
+            promise.set_exception(std::current_exception());
+        }
+    });
+
+    return future.get();
+}
+
+bool location::DispatchingProvider::requires(const location::Provider::Requirements& r) const
+{
+    std::promise<bool> promise;
+    std::future<bool> future = promise.get_future();
+
+    dispatcher([&]()
+    {
+        try
+        {
+            promise.set_value(fwd->requires(r));
+        } catch(const std::exception& e)
+        {
+            LOG(WARNING) << e.what();
+            promise.set_exception(std::current_exception());
+        } catch(...)
+        {
+            promise.set_exception(std::current_exception());
+        }
+    });
+
+    return future.get();
+}
+
+bool location::DispatchingProvider::matches_criteria(const location::Criteria& criteria)
+{
+    std::promise<bool> promise;
+    std::future<bool> future = promise.get_future();
+
+    dispatcher([&]()
+    {
+        try
+        {
+            promise.set_value(fwd->matches_criteria(criteria));
+        } catch(const std::exception& e)
+        {
+            LOG(WARNING) << e.what();
+            promise.set_exception(std::current_exception());
+        } catch(...)
+        {
+            promise.set_exception(std::current_exception());
+        }
+    });
+
+    return future.get();
+}
+
+// We forward all events to the other providers.
+void location::DispatchingProvider::on_wifi_and_cell_reporting_state_changed(location::WifiAndCellIdReportingState state)
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp, state]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->on_wifi_and_cell_reporting_state_changed(state);
+    });
+}
+
+void location::DispatchingProvider::on_reference_location_updated(const location::Update<location::Position>& position)
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp, position]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->on_reference_location_updated(position);
+    });
+}
+
+void location::DispatchingProvider::on_reference_velocity_updated(const location::Update<location::Velocity>& velocity)
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp, velocity]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->on_reference_velocity_updated(velocity);
+    });
+}
+
+void location::DispatchingProvider::on_reference_heading_updated(const location::Update<location::Heading>& heading)
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp, heading]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            sp->fwd->on_reference_heading_updated(heading);
+    });
+}
+
+// As well as the respective state change requests.
+void location::DispatchingProvider::start_position_updates()
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->state_controller()->start_position_updates();
+    });
+}
+
+void location::DispatchingProvider::stop_position_updates()
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->state_controller()->stop_position_updates();
+    });
+}
+
+void location::DispatchingProvider::start_heading_updates()
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->state_controller()->start_heading_updates();
+    });
+}
+
+void location::DispatchingProvider::stop_heading_updates()
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->state_controller()->stop_heading_updates();
+    });
+}
+
+void location::DispatchingProvider::start_velocity_updates()
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->state_controller()->start_velocity_updates();
+    });
+}
+
+void location::DispatchingProvider::stop_velocity_updates()
+{
+    std::weak_ptr<location::DispatchingProvider> wp{shared_from_this()};
+    dispatcher([wp]()
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->fwd->state_controller()->stop_velocity_updates();
+    });
+}
+
+location::DispatchingProvider::Ptr location::DispatchingProvider::init()
+{
+    auto sp = shared_from_this();
+    std::weak_ptr<location::DispatchingProvider> wp{sp};
+    connections.push_back(fwd->updates().position.connect([wp](const location::Update<location::Position>& update)
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->dispatcher([wp, update]()
+        {
+            auto sp = wp.lock();
+
+            if (not sp)
+                return;
+
+            sp->mutable_updates().position(update);
+        });
+    }));
+
+    connections.push_back(fwd->updates().heading.connect([wp](const location::Update<location::Heading>& update)
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->dispatcher([wp, update]()
+        {
+            auto sp = wp.lock();
+
+            if (not sp)
+                return;
+
+            sp->mutable_updates().heading(update);
+        });
+    }));
+
+    connections.push_back(fwd->updates().velocity.connect([wp](const location::Update<location::Velocity>& update)
+    {
+        auto sp = wp.lock();
+
+        if (not sp)
+            return;
+
+        sp->dispatcher([wp, update]()
+        {
+            auto sp = wp.lock();
+
+            if (not sp)
+                return;
+
+            sp->mutable_updates().velocity(update);
+        });
+    }));
+
+    return sp;
+}
 
=== added file 'src/location_service/com/ubuntu/location/dispatching_provider.h'
--- src/location_service/com/ubuntu/location/dispatching_provider.h	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/dispatching_provider.h	2015-11-25 08:29:55 +0000
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef LOCATION_SERVICE_COM_UBUNTU_LOCATION_DISPATCHING_PROVIDER_H_
+#define LOCATION_SERVICE_COM_UBUNTU_LOCATION_DISPATCHING_PROVIDER_H_
+
+#include <com/ubuntu/location/provider.h>
+
+#include <functional>
+#include <memory>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace location
+{
+// A Provider implementation that wraps another provider implementation
+// dispatching events/invocations via a Dispatcher functor. The dispatcher
+// can either immediately process the given task or hand it over to a runtime
+// with an associated event loop.
+class DispatchingProvider : public Provider, public std::enable_shared_from_this<DispatchingProvider>
+{
+public:
+    // To safe us some typing.
+    typedef std::shared_ptr<DispatchingProvider> Ptr;
+
+    // The Dispatcher functor that is invoked for all incoming
+    // invocations and for all events, with both of them being
+    // wrapped as a task.
+    typedef std::function<void()> Task;
+    typedef std::function<void(Task)> Dispatcher;
+
+    // Create a new instance wired up to the given Provider instance.
+    static DispatchingProvider::Ptr create(const Dispatcher& dispatcher, const Provider::Ptr& fwd);
+
+    ~DispatchingProvider() noexcept;
+
+    bool supports(const location::Provider::Features& f) const override;
+    bool requires(const location::Provider::Requirements& r) const override;
+    bool matches_criteria(const location::Criteria&) override;
+
+    // We forward all events to the other providers.
+    void on_wifi_and_cell_reporting_state_changed(WifiAndCellIdReportingState state) override;
+    void on_reference_location_updated(const location::Update<location::Position>& position) override;
+    void on_reference_velocity_updated(const location::Update<location::Velocity>& velocity) override;
+    void on_reference_heading_updated(const location::Update<location::Heading>& heading) override;
+
+    // As well as the respective state change requests.
+    void start_position_updates() override;
+    void stop_position_updates() override;
+    void start_heading_updates() override;
+    void stop_heading_updates() override;
+    void start_velocity_updates() override;
+    void stop_velocity_updates() override;
+
+private:
+    // We want to pass ourselves around.
+    DispatchingProvider(const Dispatcher& dispatcher, const Provider::Ptr& fwd);
+
+    // Two stage initialization is evil, but we are somewhat forced to do it.
+    DispatchingProvider::Ptr init();
+
+    // The dispatcher we rely on to dispatch events/invocations.
+    Dispatcher dispatcher;
+    // The provider that we relay to/from.
+    Provider::Ptr fwd;
+    // We store all connections that should be cut on destruction.
+    std::vector<core::ScopedConnection> connections;
+};
+}
+}
+}
+
+#endif // LOCATION_SERVICE_COM_UBUNTU_LOCATION_DISPATCHING_PROVIDER_H_
 
=== modified file 'src/location_service/com/ubuntu/location/service/daemon.cpp'
--- src/location_service/com/ubuntu/location/service/daemon.cpp	2015-10-23 13:43:32 +0000
+++ src/location_service/com/ubuntu/location/service/daemon.cpp	2015-11-25 08:29:55 +0000
@@ -20,6 +20,8 @@
 #include <com/ubuntu/location/boost_ptree_settings.h>
 #include <com/ubuntu/location/provider_factory.h>
 
+#include <com/ubuntu/location/logging.h>
+#include <com/ubuntu/location/dispatching_provider.h>
 #include <com/ubuntu/location/connectivity/dummy_connectivity_manager.h>
 
 #include <com/ubuntu/location/service/default_configuration.h>
@@ -39,6 +41,8 @@
 
 #include <core/posix/signal.h>
 
+#include <boost/asio.hpp>
+
 #include <system_error>
 #include <thread>
 
@@ -74,6 +78,88 @@
     }
 };
 
+// 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.
+struct Runtime
+{
+    // Our default concurrency setup.
+    static constexpr const std::uint32_t worker_threads = 2;
+
+    // Our global singleton instance.
+    static Runtime& instance()
+    {
+        static Runtime runtime;
+        return runtime;
+    }
+
+    Runtime()
+        : running{true},
+          service{worker_threads},
+          strand{service},
+          keep_alive{service}
+    {
+        for (unsigned int i = 0; i < worker_threads; i++)
+            workers.push_back(std::thread
+            {
+                [this]()
+                {
+                    while(running)
+                    {
+                        try
+                        {
+                            service.run();
+                            break;
+                        }
+                        catch (const std::exception& e)
+                        {
+                            LOG(WARNING) << e.what();
+                        }
+                        catch (...)
+                        {
+                            LOG(WARNING) << "Unknown exception caught while executing boost::asio::io_service";
+                        }
+                    }
+                }
+            });
+    }
+
+    ~Runtime()
+    {
+        stop();
+    }
+
+    void stop()
+    {
+        VLOG(1) << __PRETTY_FUNCTION__;
+        running = false;
+        service.stop();
+        VLOG(1) << "\t Service stopped.";
+
+        for (auto& worker : workers)
+            if (worker.joinable())
+                worker.join();
+
+        VLOG(1) << "\t Worker threads joined.";
+    }
+
+    // Allows for reusing the runtime in components that require a dispatcher
+    // to control execution of tasks.
+    std::function<void(std::function<void()>)> to_dispatcher_functional()
+    {
+        return [this](std::function<void()> task)
+        {
+            strand.post(task);
+        };
+    }
+
+    bool running;
+    boost::asio::io_service service;
+    boost::asio::io_service::strand strand;
+    boost::asio::io_service::work keep_alive;
+    std::vector<std::thread> workers;
+};
+
 location::ProgramOptions init_daemon_options()
 {
     location::ProgramOptions options;
@@ -193,7 +279,9 @@
                             config.provider_options.at(provider) : empty_provider_configuration);
 
             if (p)
-                instantiated_providers.insert(p);
+                instantiated_providers.insert(
+                            location::DispatchingProvider::create(
+                                Runtime::instance().to_dispatcher_functional(), p));
             else
                 throw std::runtime_error("Problem instantiating provider");
 
@@ -203,8 +291,8 @@
         }
     }
 
-    config.incoming->install_executor(dbus::asio::make_executor(config.incoming));
-    config.outgoing->install_executor(dbus::asio::make_executor(config.outgoing));
+    config.incoming->install_executor(dbus::asio::make_executor(config.incoming, Runtime::instance().service));
+    config.outgoing->install_executor(dbus::asio::make_executor(config.outgoing, Runtime::instance().service));
 
     location::service::DefaultConfiguration dc;
 
@@ -222,50 +310,12 @@
     };
 
     auto location_service = std::make_shared<location::service::Implementation>(configuration);
-    // We need to ensure that any exception raised by the executor does not crash the app
-    // and also gets logged.
-    auto execute = [] (std::shared_ptr<core::dbus::Bus> bus) {
-        while(true)
-        {
-            try
-            {
-                VLOG(10) << "Starting a bus executor";
-                bus->run();
-                break; // run() exited normally
-            }
-            catch (const std::exception& e)
-            {
-                LOG(WARNING) << e.what();
-            }
-            catch (...)
-            {
-                LOG(WARNING) << "Unexpected exception was raised by the bus executor";
-            }
-        }
-    };
-
-    std::thread t1{execute, config.incoming};
-    std::thread t2{execute, config.incoming};
-    std::thread t3{execute, config.incoming};
-    std::thread t4{execute, config.outgoing};
 
     trap->run();
 
     config.incoming->stop();
     config.outgoing->stop();
 
-    if (t1.joinable())
-        t1.join();
-
-    if (t2.joinable())
-        t2.join();
-
-    if (t3.joinable())
-        t3.join();
-
-    if (t4.joinable())
-        t4.join();
-
     return EXIT_SUCCESS;
 }
 
 
=== modified file 'tests/acceptance_tests.cpp'
--- tests/acceptance_tests.cpp	2015-02-13 13:19:18 +0000
+++ tests/acceptance_tests.cpp	2015-11-25 08:29:55 +0000
@@ -708,7 +708,7 @@
 
         options.add(Keys::update_period,
                     "Update period length for dummy::Provider setup.",
-                    std::uint32_t{100});
+                    std::uint32_t{10});
 
         options.add(Keys::client_count,
                     "Number of clients that should be fired up.",
@@ -761,6 +761,8 @@
 };
 }
 
+#include "did_finish_successfully.h"
+
 TEST_F(LocationServiceStandaloneLoad, MultipleClientsConnectingAndDisconnectingWorks)
 {
     EXPECT_TRUE(trust_store_is_set_up_for_testing);
@@ -829,7 +831,7 @@
                     status;
     }, core::posix::StandardStream::empty);
 
-    std::this_thread::sleep_for(std::chrono::seconds{2});
+    std::this_thread::sleep_for(std::chrono::seconds{15});
 
     auto client = [this]()
     {
@@ -957,17 +959,11 @@
     {
         VLOG(1) << "Stopping client...: " << client.pid();
         client.send_signal_or_throw(core::posix::Signal::sig_term);
-        auto result = client.wait_for(core::posix::wait::Flags::untraced);
-
-        EXPECT_EQ(core::posix::wait::Result::Status::exited, result.status);
-        EXPECT_EQ(core::posix::exit::Status::success, result.detail.if_exited.status);
+        EXPECT_TRUE(did_finish_successfully(client.wait_for(core::posix::wait::Flags::untraced)));
     }
 
     VLOG(1) << "Cleaned up clients, shutting down the service...";
 
     server.send_signal_or_throw(core::posix::Signal::sig_term);
-    auto result = server.wait_for(core::posix::wait::Flags::untraced);
-
-    EXPECT_EQ(core::posix::wait::Result::Status::exited, result.status);
-    EXPECT_EQ(core::posix::exit::Status::success, result.detail.if_exited.status);
+    EXPECT_TRUE(did_finish_successfully(server.wait_for(core::posix::wait::Flags::untraced)));
 }