Merge lp:~thomas-voss/dbus-cpp/fix-race-and-add-tests into lp:~phablet-team/dbus-cpp/soname_bump

[Thomas Voß]

Add a test for racyness and provide an alternative to _and_block.

[lp:~thomas-voss/dbus-cpp/fix-race-and-add-tests]

51. By Thomas Voß on 2014-03-05

Remove obsolete std::cout's.

52. By Thomas Voß on 2014-03-05

Cleanup whitespace.

53. By Thomas Voß on 2014-03-05

Remove obsolete std::this_thread::sleep_for in tests/bus_test.cpp.

54. By Thomas Voß on 2014-03-05

Fix racyness in signal-delivery test.

55. By Thomas Voß on 2014-03-05

Add missing symbols for coverage build.

56. By Thomas Voß on 2014-03-05

Add a linker script to force the linker to only export symbols that are in namespace core::dbus::*.
Adjust symbol files accordingly.

57. By Thomas Voß on 2014-03-05

Adjust symbol file for 32bit platforms to account for difference in size of integer types.

58. By Thomas Voß on 2014-03-05

Add specific symbols file for coverage builds, only containing optional symbols.

59. By Thomas Voß on 2014-03-05

Add missing coverage-specific symbols for armhf.

60. By Thomas Voß on 2014-03-10

Make sure that -fstack-protector is stripped from the compiler flags to avoid build failures on arm64.

61. By Thomas Voß on 2014-03-10

Move stripping of -fstack-protector before include.

Unmerged revisions

61. By Thomas Voß on 2014-03-10

Move stripping of -fstack-protector before include.

60. By Thomas Voß on 2014-03-10

Make sure that -fstack-protector is stripped from the compiler flags to avoid build failures on arm64.

59. By Thomas Voß on 2014-03-05

Add missing coverage-specific symbols for armhf.

58. By Thomas Voß on 2014-03-05

Add specific symbols file for coverage builds, only containing optional symbols.

57. By Thomas Voß on 2014-03-05

Adjust symbol file for 32bit platforms to account for difference in size of integer types.

56. By Thomas Voß on 2014-03-05

Add a linker script to force the linker to only export symbols that are in namespace core::dbus::*.
Adjust symbol files accordingly.

55. By Thomas Voß on 2014-03-05

Add missing symbols for coverage build.

54. By Thomas Voß on 2014-03-05

Fix racyness in signal-delivery test.

53. By Thomas Voß on 2014-03-05

Remove obsolete std::this_thread::sleep_for in tests/bus_test.cpp.

52. By Thomas Voß on 2014-03-05

Cleanup whitespace.

=== modified file 'include/core/dbus/impl/object.h'
--- include/core/dbus/impl/object.h	2014-01-24 11:23:09 +0000
+++ include/core/dbus/impl/object.h	2014-03-05 07:16:59 +0000
@@ -85,6 +85,12 @@
 }
 
 template<typename Method, typename ResultType, typename... Args>
+inline Result<ResultType> Object::transact_method(const Args& ... args)
+{
+    return invoke_method_asynchronously<Method, ResultType, Args...>(args...).get();
+}
+
+template<typename Method, typename ResultType, typename... Args>
 inline std::future<Result<ResultType>> Object::invoke_method_asynchronously(const Args& ... args)
 {
     auto msg_factory = parent->get_connection()->message_factory();
@@ -97,41 +103,22 @@
     if (!msg)
         throw std::runtime_error("No memory available to allocate DBus message");
     
-    msg->writer().append(args...);    
+    auto writer = msg->writer();
+    encode_message(writer, args...);
 
     auto pending_call =
             parent->get_connection()->send_with_reply_and_timeout(
-                msg->get(), Method::default_timeout());
+                msg, Method::default_timeout());
     
-    auto cb = 
-            [](DBusPendingCall* pending, void* user_data)
-            {
-                auto promise = static_cast<std::promise<Result<ResultType>>*>(user_data);
-                
-                auto msg = dbus_pending_call_steal_reply(pending);
-                if (msg)
-                {
-                    auto result = Result<ResultType>::from_message(msg);
-                    promise->set_value(result);
-                }
-                else
-                {
-                    promise->set_exception(std::make_exception_ptr(std::runtime_error("Method invocation timed out")));
-                }
-            };
-
-    auto promise = new std::promise<Result<ResultType>>();
-
-    dbus_pending_call_set_notify(
-        pending_call,
-        cb,
-        promise,
-        [](void* p)
-        {
-            delete static_cast<std::promise<Result<ResultType>>*>(p);
-        });
-
-    return promise->get_future();
+    auto promise = std::make_shared<std::promise<Result<ResultType>>>();
+    auto future = promise->get_future();
+
+    pending_call->then([promise](const Message::Ptr& reply)
+    {
+        promise->set_value(Result<ResultType>::from_message(reply));
+    });
+
+    return future;
 }
 
 template<typename PropertyDescription>

=== modified file 'include/core/dbus/object.h'
--- include/core/dbus/object.h	2014-01-24 11:17:26 +0000
+++ include/core/dbus/object.h	2014-03-05 07:16:59 +0000
@@ -97,7 +97,7 @@
     inline void emit_signal(const Args& ... args);
 
     /**
-     * @brief Invokes a method of a remote object blocking while waiting for the result.
+     * @brief Invokes a method of a remote object blocking the bus instance while waiting for the result.
      * @tparam Method The method to invoke.
      * @tparam ResultType The expected type of the result.
      * @tparam Args Parameter pack of arguments passed to the invocation.
@@ -108,6 +108,17 @@
     inline Result<ResultType> invoke_method_synchronously(const Args& ... args);
 
     /**
+     * @brief Invokes a method of a remote object blocking the current thread while waiting for the result.
+     * @tparam Method The method to invoke.
+     * @tparam ResultType The expected type of the result.
+     * @tparam Args Parameter pack of arguments passed to the invocation.
+     * @param [in] args Argument instances passed to the invocation.
+     * @return A future wrapping an invocation result, either signalling an error or containing the result of the invocation.
+     */
+    template<typename Method, typename ResultType, typename... Args>
+    inline Result<ResultType> transact_method(const Args& ... args);
+
+    /**
      * @brief Invokes a method of a remote object returning a std::future to synchronize with the result
      * @tparam Method The method to invoke.
      * @tparam ResultType The expected type of the result.

=== modified file 'include/core/dbus/pending_call.h'
--- include/core/dbus/pending_call.h	2013-11-27 18:57:42 +0000
+++ include/core/dbus/pending_call.h	2014-03-05 07:16:59 +0000
@@ -63,12 +63,6 @@
     bool operator==(const PendingCall&) const = delete;
 
     /**
-     * @brief Suspends the current thread until a reply has arrived.
-     * @return Pointer to a message.
-     */
-    virtual std::shared_ptr<Message> wait_for_reply() = 0;
-
-    /**
      * @brief Cancels the outstanding call.
      */
     virtual void cancel() = 0;

=== modified file 'src/core/dbus/asio/executor.cpp'
--- src/core/dbus/asio/executor.cpp	2013-11-27 18:57:42 +0000
+++ src/core/dbus/asio/executor.cpp	2014-03-05 07:16:59 +0000
@@ -25,7 +25,12 @@
 #include <boost/asio/io_service.hpp>
 
 #include <stdexcept>
+
+#include <condition_variable>
 #include <memory>
+#include <mutex>
+#include <future>
+#include <thread>
 
 namespace core
 {
@@ -40,7 +45,7 @@
 
     static inline bool is_timeout_enabled(DBusTimeout* timeout)
     {
-        return dbus_timeout_get_enabled(timeout);
+        return TRUE == dbus_timeout_get_enabled(timeout);
     }
 
     static inline int get_timeout_interval(DBusTimeout* timeout)
@@ -64,7 +69,7 @@
 
     static inline bool is_watch_enabled(DBusWatch* watch)
     {
-        return dbus_watch_get_enabled(watch);
+        return TRUE == dbus_watch_get_enabled(watch);
     }
 
     static inline int get_watch_unix_fd(DBusWatch* watch)
@@ -105,9 +110,9 @@
                 throw std::runtime_error("Precondition violated: timeout has to be non-null");
         }
 
-        ~Timeout() noexcept
+        ~Timeout()
         {
-            timer.cancel();
+            // cancel();
         }
 
         void start()
@@ -117,37 +122,36 @@
                 return;
             }
 
-            timer.expires_from_now(boost::posix_time::milliseconds(traits::Timeout<UnderlyingTimeoutType>::get_timeout_interval(timeout)));
-            timer.async_wait(std::bind(&Timeout::on_timeout, Timeout<UnderlyingTimeoutType>::shared_from_this(), std::placeholders::_1));
+            timer.expires_from_now(
+                        boost::posix_time::milliseconds(
+                            traits::Timeout<UnderlyingTimeoutType>::get_timeout_interval(
+                                timeout)));
+            timer.async_wait(
+                        std::bind(&Timeout::on_timeout,
+                                  Timeout<UnderlyingTimeoutType>::shared_from_this(),
+                                  std::placeholders::_1));
         }
 
-        void restart_or_cancel()
+        void cancel()
         {
-            if (!traits::Timeout<UnderlyingTimeoutType>::is_timeout_enabled(timeout))
+            try
             {
                 timer.cancel();
-                return;
+            } catch(...)
+            {
+                // Really not sure what we should do about exceptions here.
             }
-
-            timer.expires_from_now(boost::posix_time::milliseconds(traits::Timeout<UnderlyingTimeoutType>::get_timeout_interval(timeout)));
-            timer.async_wait(std::bind(&Timeout::on_timeout, Timeout<UnderlyingTimeoutType>::shared_from_this(), std::placeholders::_1));
-        }
-
-        void cancel()
-        {
-            timer.cancel();
         }
 
         void on_timeout(const boost::system::error_code& ec)
         {
+            if (ec == boost::asio::error::operation_aborted)
+                return;
+
             if (ec)
                 return;
 
-            if (ec != boost::asio::error::operation_aborted)
-            {
-                traits::Timeout<UnderlyingTimeoutType>::invoke_timeout_handler(timeout);
-                restart_or_cancel();
-            }
+            traits::Timeout<UnderlyingTimeoutType>::invoke_timeout_handler(timeout);
         }
 
         boost::asio::io_service& io_service;
@@ -299,7 +303,7 @@
                     Holder<std::shared_ptr<Timeout<>>>::ptr_delete);
 
         t->start();
-        return true;
+        return TRUE;
     }
 
     static void on_dbus_remove_timeout(DBusTimeout* timeout, void*)
@@ -310,13 +314,20 @@
     static void on_dbus_timeout_toggled(DBusTimeout* timeout, void*)
     {
         auto holder = static_cast<Holder<std::shared_ptr<Timeout<>>>*>(dbus_timeout_get_data(timeout));
-        holder->value->restart_or_cancel();
+        holder->value->start();
     }
 
     static void on_dbus_wakeup_event_loop(void* data)
     {
         auto thiz = static_cast<Executor*>(data);
-        thiz->io_service.post(std::bind(dbus_connection_dispatch, thiz->bus->raw()));
+        auto bus = thiz->bus;
+        thiz->io_service.post([bus]()
+        {
+            while (dbus_connection_get_dispatch_status(bus->raw()) == DBUS_DISPATCH_DATA_REMAINS)
+            {
+                dbus_connection_dispatch(bus->raw());
+            }
+        });
     }
 
 public:

=== removed file 'src/core/dbus/asio_executor.cpp'
--- src/core/dbus/asio_executor.cpp	2013-11-27 18:57:42 +0000
+++ src/core/dbus/asio_executor.cpp	1970-01-01 00:00:00 +0000
@@ -1,376 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- */
-
-#include <core/dbus/bus.h>
-#include <core/dbus/executor.h>
-#include <core/dbus/traits/timeout.h>
-#include <core/dbus/traits/watch.h>
-
-#include <boost/asio.hpp>
-#include <boost/asio/io_service.hpp>
-
-#include <stdexcept>
-#include <memory>
-
-namespace core
-{
-namespace dbus
-{
-namespace traits
-{
-template<>
-struct Timeout<DBusTimeout>
-{
-    typedef int DurationType;
-
-    static inline bool is_timeout_enabled(DBusTimeout* timeout)
-    {
-        return dbus_timeout_get_enabled(timeout);
-    }
-
-    static inline int get_timeout_interval(DBusTimeout* timeout)
-    {
-        return DurationType(dbus_timeout_get_interval(timeout));
-    }
-
-    static inline void invoke_timeout_handler(DBusTimeout* timeout)
-    {
-        dbus_timeout_handle(timeout);
-    }
-};
-
-template<>
-struct Watch<DBusWatch>
-{
-    inline static int readable_event() { return DBUS_WATCH_READABLE; }
-    inline static int writeable_event() { return DBUS_WATCH_WRITABLE; }
-    inline static int error_event() { return DBUS_WATCH_ERROR; }
-    inline static int hangup_event() { return DBUS_WATCH_HANGUP; }
-
-    static inline bool is_watch_enabled(DBusWatch* watch)
-    {
-        return dbus_watch_get_enabled(watch);
-    }
-
-    static inline int get_watch_unix_fd(DBusWatch* watch)
-    {
-        return dbus_watch_get_unix_fd(watch);
-    }
-
-    static inline bool is_watch_monitoring_fd_for_readable(DBusWatch* watch)
-    {
-        return dbus_watch_get_flags(watch) & DBUS_WATCH_READABLE;
-    }
-
-    static bool is_watch_monitoring_fd_for_writable(DBusWatch* watch)
-    {
-        return dbus_watch_get_flags(watch) & DBUS_WATCH_WRITABLE;
-    }
-
-    static bool invoke_watch_handler_for_event(DBusWatch* watch, int event)
-    {
-        return dbus_watch_handle(watch, event);
-    }
-};
-}
-namespace asio
-{
-class Executor : public core::dbus::Executor
-{
-  public:
-    template<typename UnderlyingTimeoutType = DBusTimeout>
-    struct Timeout : std::enable_shared_from_this<Timeout<UnderlyingTimeoutType>>
-    {
-        Timeout(boost::asio::io_service& io_service, UnderlyingTimeoutType* timeout) 
-                : io_service(io_service),
-                timer(io_service),
-                timeout(timeout)
-                {
-                    if (!timeout)
-                        throw std::runtime_error("Precondition violated: timeout has to be non-null");
-                }
-
-        ~Timeout() noexcept
-        {
-            timer.cancel();
-        }
-
-        void start()
-        {
-            if (!traits::Timeout<UnderlyingTimeoutType>::is_timeout_enabled(timeout))
-            {
-                return;
-            }
-
-            timer.expires_from_now(boost::posix_time::milliseconds(traits::Timeout<UnderlyingTimeoutType>::get_timeout_interval(timeout)));
-            timer.async_wait(std::bind(&Timeout::on_timeout, Timeout<UnderlyingTimeoutType>::shared_from_this(), std::placeholders::_1));
-        }
-
-        void restart_or_cancel()
-        {
-            if (!traits::Timeout<UnderlyingTimeoutType>::is_timeout_enabled(timeout))
-            {
-                timer.cancel();
-                return;
-            }
-
-            timer.expires_from_now(boost::posix_time::milliseconds(traits::Timeout<UnderlyingTimeoutType>::get_timeout_interval(timeout)));
-            timer.async_wait(std::bind(&Timeout::on_timeout, Timeout<UnderlyingTimeoutType>::shared_from_this(), std::placeholders::_1));
-        }
-
-        void cancel()
-        {
-            timer.cancel();
-        }
-
-        void on_timeout(const boost::system::error_code& ec)
-        {
-            if (ec)
-                return;
-
-            if (ec != boost::asio::error::operation_aborted)
-            {
-                traits::Timeout<UnderlyingTimeoutType>::invoke_timeout_handler(timeout);
-                restart_or_cancel();
-            }
-        }
-
-        boost::asio::io_service& io_service;
-        boost::asio::deadline_timer timer;
-        UnderlyingTimeoutType* timeout;
-    };
-
-    template<typename UnderlyingWatchType = DBusWatch>
-    struct Watch : std::enable_shared_from_this<Watch<UnderlyingWatchType>>
-    {
-        Watch(boost::asio::io_service& io_service, UnderlyingWatchType* watch) : io_service(io_service),
-                stream_descriptor(io_service),
-                watch(watch)
-                {
-                    if (!watch)
-                        throw std::runtime_error("Precondition violated: watch has to be non-null");
-                }
-
-        ~Watch() noexcept
-        {
-            stream_descriptor.cancel();
-            stream_descriptor.release();
-        }
-
-        void start()
-        {
-            stream_descriptor.assign(traits::Watch<UnderlyingWatchType>::get_watch_unix_fd(watch));
-            restart();
-        }
-
-        void restart()
-        {
-            if (traits::Watch<UnderlyingWatchType>::is_watch_monitoring_fd_for_readable(watch))
-            {
-                stream_descriptor.async_read_some(
-                    boost::asio::null_buffers(),
-                    std::bind(
-                        &Watch::on_stream_descriptor_event,
-                        Watch<UnderlyingWatchType>::shared_from_this(),
-                        traits::Watch<UnderlyingWatchType>::readable_event(),
-                        std::placeholders::_1,
-                        std::placeholders::_2));
-            }
-            if (traits::Watch<UnderlyingWatchType>::is_watch_monitoring_fd_for_writable(watch))
-            {
-                stream_descriptor.async_write_some(
-                    boost::asio::null_buffers(),
-                    std::bind(
-                        &Watch::on_stream_descriptor_event,
-                        Watch<UnderlyingWatchType>::shared_from_this(),
-                        traits::Watch<UnderlyingWatchType>::writeable_event(),
-                        std::placeholders::_1,
-                        std::placeholders::_2));
-            }
-        }
-
-        void cancel()
-        {
-            try
-            {
-                stream_descriptor.cancel();
-            }
-            catch (...)
-            {
-            }
-        }
-
-        void on_stream_descriptor_event(int event, const boost::system::error_code& error, std::size_t)
-        {
-            if (error == boost::asio::error::operation_aborted)
-            {
-                return;
-            }
-
-            if (error)
-            {
-                traits::Watch<UnderlyingWatchType>::invoke_watch_handler_for_event(
-                    watch,
-                    traits::Watch<UnderlyingWatchType>::error_event());
-            }
-            else
-            {
-                if (!traits::Watch<UnderlyingWatchType>::invoke_watch_handler_for_event(watch, event))
-                    throw std::runtime_error("Insufficient memory while handling watch event");
-
-                restart();
-            }
-        }
-
-        boost::asio::io_service& io_service;
-        boost::asio::posix::stream_descriptor stream_descriptor;
-        UnderlyingWatchType* watch;
-    };
-
-    template<typename T>
-    struct Holder
-    {
-        static void ptr_delete(void* p)
-        {
-            delete static_cast<Holder<T>*>(p);
-        }
-
-        Holder(const T& t) : value(t)
-        {
-        }
-
-        T value;
-    };
-
-    static dbus_bool_t on_dbus_add_watch(DBusWatch* watch, void* data)
-    {
-        if (dbus_watch_get_enabled(watch) == FALSE)
-            return TRUE;
-
-        auto thiz = static_cast<Executor*>(data);
-        auto w = std::shared_ptr<Watch<>>(new Watch<>(thiz->io_service, watch));
-        auto holder = new Holder<std::shared_ptr<Watch<>>>(w);
-        dbus_watch_set_data(watch, holder, Holder<std::shared_ptr<Watch<>>>::ptr_delete);
-
-        w->start();
-
-        return TRUE;
-    }
-
-    static void on_dbus_remove_watch(DBusWatch* watch, void*)
-    {
-        auto w = static_cast<Holder<std::shared_ptr<Watch<>>>*>(dbus_watch_get_data(watch));
-        if (!w)
-            return;
-        w->value->cancel();
-    }
-
-    static void on_dbus_watch_toggled(DBusWatch* watch, void*)
-    {
-        auto holder = static_cast<Holder<std::shared_ptr<Watch<>>>*>(dbus_watch_get_data(watch));
-        if (!holder)
-            return;
-        dbus_watch_get_enabled(watch) == TRUE ? holder->value->restart() : holder->value->cancel();
-    }
-
-    static dbus_bool_t on_dbus_add_timeout(DBusTimeout* timeout, void* data)
-    {
-        auto thiz = static_cast<Executor*>(data);
-        auto t = std::shared_ptr<Timeout<>>(new Timeout<>(thiz->io_service, timeout));
-        auto holder = new Holder<std::shared_ptr<Timeout<>>>(t);
-        dbus_timeout_set_data(
-            timeout,
-            holder,
-            Holder<std::shared_ptr<Timeout<>>>::ptr_delete);
-
-        t->start();
-        return true;
-    }
-
-    static void on_dbus_remove_timeout(DBusTimeout* timeout, void*)
-    {
-        static_cast<Holder<std::shared_ptr<Timeout<>>>*>(dbus_timeout_get_data(timeout))->value->cancel();
-    }
-
-    static void on_dbus_timeout_toggled(DBusTimeout* timeout, void*)
-    {
-        auto holder = static_cast<Holder<std::shared_ptr<Timeout<>>>*>(dbus_timeout_get_data(timeout));
-        holder->value->restart_or_cancel();
-    }
-
-    static void on_dbus_wakeup_event_loop(void* data)
-    {
-        auto thiz = static_cast<Executor*>(data);
-        thiz->io_service.post(std::bind(dbus_connection_dispatch, thiz->bus->raw()));
-    }
-
-  public:
-    explicit Executor(const Bus::Ptr& bus) : bus(bus), work(io_service)
-    {
-        if (!bus)
-            throw std::runtime_error("Precondition violated, cannot construct executor for null bus.");
-
-        if (!dbus_connection_set_watch_functions(
-                    bus->raw(),
-                    on_dbus_add_watch,
-                    on_dbus_remove_watch,
-                    on_dbus_watch_toggled,
-                    this,
-                    nullptr))
-            throw std::runtime_error("Problem installing watch functions.");
-
-        if (!dbus_connection_set_timeout_functions(
-                    bus->raw(),
-                    on_dbus_add_timeout,
-                    on_dbus_remove_timeout,
-                    on_dbus_timeout_toggled,
-                    this,
-                    nullptr))
-            throw std::runtime_error("Problem installing timeout functions.");
-
-        dbus_connection_set_wakeup_main_function(
-            bus->raw(),
-            on_dbus_wakeup_event_loop,
-            this,
-            nullptr);
-    }
-
-    ~Executor() noexcept
-    {
-        stop();
-    }
-
-    void run()
-    {
-        io_service.run();
-    }
-
-    void stop()
-    {
-        io_service.stop();
-    }
-
-  private:
-    Bus::Ptr bus;
-    boost::asio::io_service io_service;
-    boost::asio::io_service::work work;
-};
-}
-}
-}
-}

=== modified file 'src/core/dbus/bus.cpp'
--- src/core/dbus/bus.cpp	2014-01-25 16:08:10 +0000
+++ src/core/dbus/bus.cpp	2014-03-05 07:16:59 +0000
@@ -252,6 +252,16 @@
         const std::shared_ptr<Message>& msg,
         const std::chrono::milliseconds& milliseconds)
 {
+    // TODO(tvoss): Enable this once method handlers have been adjusted to
+    // operate on contexts.
+    // if (d->executor)
+    // {
+    //    throw std::logic_error("Calling Bus::send_with_reply_and_block_for_at_most on a "
+    //                           "connection that is run by an executor, i.e., an event loop "
+    //                           "is not supported as the underlying implementation in libdbus "
+    //                           "is racy");
+    //}
+
     Error se;
 
     auto result = dbus_connection_send_with_reply_and_block(
@@ -277,7 +287,7 @@
                 std::addressof(pending_call),
                 timeout.count());
 
-    if (!result)
+    if (result == FALSE)
         throw Errors::NoMemory{};
 
     if (!pending_call)

=== modified file 'src/core/dbus/dbus.cpp'
--- src/core/dbus/dbus.cpp	2014-01-27 15:09:15 +0000
+++ src/core/dbus/dbus.cpp	2014-03-05 07:16:59 +0000
@@ -146,6 +146,7 @@
 
 std::string DBus::hello() const
 {
+    // TODO: We really should switch to method transaction here.
     return object->invoke_method_synchronously<Hello, std::string>().value();
 }
 

=== modified file 'src/core/dbus/pending_call_impl.h'
--- src/core/dbus/pending_call_impl.h	2013-11-27 18:57:42 +0000
+++ src/core/dbus/pending_call_impl.h	2014-03-05 07:16:59 +0000
@@ -24,6 +24,7 @@
 
 #include <dbus/dbus.h>
 
+#include <condition_variable>
 #include <mutex>
 
 namespace core
@@ -37,54 +38,73 @@
 private:
     struct Wrapper
     {
-        std::shared_ptr<PendingCall> pending_call;
+        std::shared_ptr<core::dbus::impl::PendingCall> pending_call;
     };
 
     static void on_pending_call_completed(DBusPendingCall* call,
                                           void* cookie)
     {
         auto wrapper = static_cast<Wrapper*>(cookie);
-        std::lock_guard<std::mutex> lg(wrapper->pending_call->callback_guard);
-        if (wrapper->pending_call->callback)
+
+        auto message = dbus_pending_call_steal_reply(call);
+
+        if (message)
         {
-            auto message = dbus_pending_call_steal_reply(call);
-            if (message)
-                wrapper->pending_call->callback(Message::from_raw_message(message));
+            wrapper->pending_call->notify(Message::from_raw_message(message));
         }
     }
 
+    void notify(const Message::Ptr& msg)
+    {
+        std::lock_guard<std::mutex> lg(guard);
+
+        message = msg;
+
+        if (callback)
+            callback(message);
+
+    }
+
     DBusPendingCall* pending_call;
-    std::mutex callback_guard;
-    core::dbus::PendingCall::Notification callback;
+    std::mutex guard;
+    Message::Ptr message;
+    PendingCall::Notification callback;
 
 public:
     inline static core::dbus::PendingCall::Ptr create(DBusPendingCall* call)
     {
-        auto result = std::shared_ptr<core::dbus::impl::PendingCall>(
-                    new core::dbus::impl::PendingCall(call));
-
-        dbus_pending_call_set_notify(
-                    result->pending_call,
-                    PendingCall::on_pending_call_completed,
-                    new Wrapper{result},
-                    [](void* data) { delete static_cast<Wrapper*>(data); });
+        auto result = std::shared_ptr<core::dbus::impl::PendingCall>
+        {
+            new core::dbus::impl::PendingCall{call}
+        };
+
+        if (FALSE == dbus_pending_call_set_notify(
+                result->pending_call,
+                PendingCall::on_pending_call_completed,
+                new Wrapper{result},
+                [](void* data)
+                {
+                    delete static_cast<Wrapper*>(data);
+                }))
+        {
+            throw std::runtime_error("Error setting up pending call notification.");
+        }
+
+        // And here comes the beauty of libdbus, and its racy architecture:
+        {
+            std::lock_guard<std::mutex> lg(result->guard);
+            if (TRUE == dbus_pending_call_get_completed(call))
+            {
+                // We took too long while setting up the pending call notification.
+                // For that we now have to inject the message here.
+                auto msg = dbus_pending_call_steal_reply(call);
+                result->message = Message::from_raw_message(msg);
+            }
+        }
 
         return std::dynamic_pointer_cast<core::dbus::PendingCall>(result);
     }
 
-    inline std::shared_ptr<Message> wait_for_reply()
-    {
-        dbus_pending_call_block(pending_call);
-        auto reply = dbus_pending_call_steal_reply(pending_call);
-
-        if (!reply)
-        {
-            // TODO(tvoss): Throw PendingCallYieldedEmptyReply.
-        }
-
-        return Message::from_raw_message(reply);
-    }
-
     void cancel()
     {
         dbus_pending_call_cancel(pending_call);
@@ -92,14 +112,20 @@
 
     void then(const core::dbus::PendingCall::Notification& notification)
     {
-        std::lock_guard<std::mutex> lg{callback_guard};
+        std::lock_guard<std::mutex> lg(guard);
         callback = notification;
+
+        // We already have a reply and invoke the callback directly.
+        if (message)
+            callback(message);
     }
 
 private:
     PendingCall(DBusPendingCall* call)
         : pending_call(call)
     {
+
+
     }
 };
 }

=== modified file 'tests/bus_test.cpp'
--- tests/bus_test.cpp	2014-01-10 07:34:59 +0000
+++ tests/bus_test.cpp	2014-03-05 07:16:59 +0000
@@ -88,13 +88,28 @@
                 "ListNames");
 
     auto bus = session_bus();
+    bus->install_executor(dbus::asio::make_executor(bus));
+    std::thread t{[bus](){bus->run();}};
+
+    std::this_thread::sleep_for(std::chrono::seconds{1});
+
     const std::chrono::milliseconds timeout = std::chrono::seconds(10);
 
     auto call = bus->send_with_reply_and_timeout(msg, timeout);
-    auto reply = call->wait_for_reply();
-    EXPECT_EQ(dbus::Message::Type::method_return, reply->type());
-    std::vector<std::string> result; reply->reader() >> result;
-    EXPECT_TRUE(result.size() > 0);
+    auto promise = std::make_shared<std::promise<std::vector<std::string>>>();
+    auto future = promise->get_future();
+    call->then([promise](const core::dbus::Message::Ptr& reply)
+    {
+        std::vector<std::string> result; reply->reader() >> result;
+        promise->set_value(result);
+    });
+
+    EXPECT_TRUE(future.get().size() > 0);
+
+    bus->stop();
+
+    if (t.joinable())
+        t.join();
 }
 
 TEST_F(Bus, HasOwnerForNameReturnsTrueForExistingName)

=== modified file 'tests/dbus_test.cpp'
--- tests/dbus_test.cpp	2014-02-18 06:43:55 +0000
+++ tests/dbus_test.cpp	2014-03-05 07:16:59 +0000
@@ -98,12 +98,16 @@
         object->install_method_handler<test::Service::Method>(handler);
         barrier.try_signal_ready_for(std::chrono::milliseconds{500});
 
-        std::thread t{[bus](){ bus->run(); }};
+        std::thread t1{[bus](){ bus->run(); }};
+        std::thread t2{[bus](){ bus->run(); }};
 
         sc.wait_for_signal();
 
-        if (t.joinable())
-            t.join();
+        if (t1.joinable())
+            t1.join();
+
+        if (t2.joinable())
+            t2.join();
 
         EXPECT_EQ(pid, sender_pid);
         EXPECT_EQ(uid, sender_uid);

=== modified file 'tests/executor_test.cpp'
--- tests/executor_test.cpp	2014-02-18 06:43:55 +0000
+++ tests/executor_test.cpp	2014-03-05 07:16:59 +0000
@@ -36,6 +36,22 @@
 
 namespace
 {
+// A very simple wrapper for flipping a coin whether something should go wrong.
+// Please note that we are considering an unfair coin here, with a probability of 0.2
+// for failure.
+struct ChaosMonkey
+{
+    constexpr static const double probability_for_failure{0.2};
+
+    bool thinks_that_something_should_go_wrong()
+    {
+        return coin(rng) == 1;
+    }
+
+    std::mt19937 rng{42};
+    std::binomial_distribution<> coin{1, 1.-probability_for_failure};
+};
+
 struct Executor : public core::dbus::testing::Fixture
 {
 };
@@ -127,6 +143,125 @@
     EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
 }
 
+TEST_F(Executor, TimeoutsAreHandledCorrectly)
+{
+    core::testing::CrossProcessSync cross_process_sync;
+
+    const int64_t expected_value = 42;
+    auto service = [this, expected_value, &cross_process_sync]()
+    {
+        ChaosMonkey chaos_monkey;
+        core::testing::SigTermCatcher sc;
+        auto bus = session_bus();
+        bus->install_executor(dbus::asio::make_executor(bus));
+        auto service = dbus::Service::add_service<test::Service>(bus);
+        auto skeleton = service->add_object_for_path(dbus::types::ObjectPath("/this/is/unlikely/to/exist/Service"));
+        skeleton->install_method_handler<test::Service::Method>(
+            [bus, skeleton, expected_value, &chaos_monkey](const dbus::Message::Ptr& msg)
+        {
+            // Let's add some randomness to this test and see if things are still stable.
+            // In this case, chaos means an early return and no reply being sent.
+            if (chaos_monkey.thinks_that_something_should_go_wrong())
+                return;
+
+            auto reply = dbus::Message::make_method_return(msg);
+            reply->writer() << expected_value;
+            bus->send(reply);
+        });
+
+        cross_process_sync.try_signal_ready_for(std::chrono::milliseconds{500});
+
+        std::thread w1([bus]() { bus->run(); });
+        std::thread w2([bus]() { bus->run(); });
+
+        sc.wait_for_signal();
+
+        bus->stop();
+
+        if (w1.joinable())
+            w1.join();
+
+        if (w2.joinable())
+            w2.join();
+
+        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
+    };
+
+    auto client = [this, expected_value, &cross_process_sync]() -> core::posix::exit::Status
+    {
+        auto bus = session_bus();
+        bus->install_executor(dbus::asio::make_executor(bus));
+        std::thread t{[bus](){bus->run();}};
+
+        // If you encounter failures in the client, uncomment the following two lines
+        // and follow the instructions on the terminal.
+        // std::cout << "Invoke gdb with: sudo gdb -p " << getpid() << std::endl;
+        // sleep(10);
+
+        EXPECT_EQ(std::uint32_t(1), cross_process_sync.wait_for_signal_ready_for(std::chrono::milliseconds{500}));
+
+        auto stub_service = dbus::Service::use_service(bus, dbus::traits::Service<test::Service>::interface_name());
+        auto stub = stub_service->object_for_path(dbus::types::ObjectPath("/this/is/unlikely/to/exist/Service"));
+
+        std::thread updater1([bus, stub]()
+        {
+            for (unsigned int counter = 0; counter < 1000; counter++)
+            {
+                try
+                {
+                    auto result = stub->transact_method<test::Service::Method, int64_t>();
+
+                    if (result.is_error())
+                        std::cout << result.error().print() << std::endl;
+                    else
+                        EXPECT_EQ(42, result.value());
+
+                } catch(const std::runtime_error& e)
+                {
+                    std::cout << e.what() << std::endl;
+                }
+            }
+        });
+
+        std::thread updater2([bus, stub]()
+        {
+            for (unsigned int counter = 0; counter < 1000; counter++)
+            {
+                try
+                {
+                    auto result = stub->transact_method<test::Service::Method, int64_t>();
+
+                    if (result.is_error())
+                        std::cout << result.error().print() << std::endl;
+                    else
+                        EXPECT_EQ(42, result.value());
+
+                } catch(const std::runtime_error& e)
+                {
+                    std::cout << e.what() << std::endl;
+                }
+            }
+        });
+
+        if (updater1.joinable())
+            updater1.join();
+
+        if (updater2.joinable())
+            updater2.join();
+
+        bus->stop();
+
+        if (t.joinable())
+            t.join();
+
+        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
+    };
+
+    EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
+}
+
+
+
 /*TEST(Bus, TimeoutThrowsForNullDBusWatch)
 {
     boost::asio::io_service io_service;

=== modified file 'tests/signal_delivery_test.cpp'
--- tests/signal_delivery_test.cpp	2014-02-18 06:43:55 +0000
+++ tests/signal_delivery_test.cpp	2014-03-05 07:16:59 +0000
@@ -323,8 +323,8 @@
         if (t.joinable())
             t.join();
 
-        EXPECT_EQ(std::uint32_t(1), received1);
-        EXPECT_EQ(std::uint32_t(1), received2);
+        EXPECT_EQ(std::uint32_t(2), received1);
+        EXPECT_EQ(std::uint32_t(2), received2);
 
         return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
     };

=== modified file 'tests/test_service.h'
--- tests/test_service.h	2014-02-18 06:43:55 +0000
+++ tests/test_service.h	2014-03-05 07:16:59 +0000
@@ -38,7 +38,7 @@
 
         inline static const std::chrono::milliseconds default_timeout()
         {
-            return std::chrono::seconds{1};
+            return std::chrono::milliseconds{10};
         }
     };
 
@@ -126,7 +126,6 @@
         {
             "this.is.unlikely.to.exist.Service"
         };
-        std::cout << __PRETTY_FUNCTION__ << ": " << s << std::endl;
         return s;
     }
 };