Merge lp:~thomas-voss/dbus-cpp/decouple-executor-and-bus into lp:dbus-cpp/15.04

[Thomas Voß]

Decouple dbus::Executor/dbus::Bus and prevent from ownership loops.

Decouple dbus::Executor/dbus::Bus and prevent from ownership loops.

Unmerged revisions

107. By Thomas Voß on 2016-01-18

Fixes lp:1501864.

106. By Thomas Voß on 2016-01-18

Decouple dbus::Executor/dbus::Bus and prevent from ownership loops.

105. By Thomas Voß on 2016-01-05

Decouple dbus::Executor and dbus::Bus.

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

Add interface headers such that IDEs can pick them up.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-11-10 08:35:29 +0000
+++ CMakeLists.txt	2016-01-18 16:49:39 +0000
@@ -67,6 +67,8 @@
 
 include(CTest)
 
+file(GLOB_RECURSE DBUS_CPP_INTERFACE_HEADERS include/*.h)
+
 include_directories(
   include
   ${LIBXML2_INCLUDE_DIR}

=== renamed file 'include/core/dbus/asio/executor.h' => 'include/core/dbus/asio/make_executor.h'
--- include/core/dbus/asio/executor.h	2014-06-09 08:56:57 +0000
+++ include/core/dbus/asio/make_executor.h	2016-01-18 16:49:39 +0000
@@ -15,8 +15,8 @@
  *
  * Authored by: Thomas Voß <[e-mail]>
  */
-#ifndef CORE_DBUS_ASIO_EXECUTOR_H_
-#define CORE_DBUS_ASIO_EXECUTOR_H_
+#ifndef CORE_DBUS_ASIO_MAKE_EXECUTOR_H_
+#define CORE_DBUS_ASIO_MAKE_EXECUTOR_H_
 
 #include <core/dbus/bus.h>
 #include <core/dbus/executor.h>
@@ -36,10 +36,10 @@
 {
 namespace asio
 {
-ORG_FREEDESKTOP_DBUS_DLL_PUBLIC Executor::Ptr make_executor(const Bus::Ptr& bus);
-ORG_FREEDESKTOP_DBUS_DLL_PUBLIC Executor::Ptr make_executor(const Bus::Ptr& bus, boost::asio::io_service& io);
+ORG_FREEDESKTOP_DBUS_DLL_PUBLIC core::dbus::Executor::Ptr make_executor(const Bus::Ptr& bus);
+ORG_FREEDESKTOP_DBUS_DLL_PUBLIC core::dbus::Executor::Ptr make_executor(const Bus::Ptr& bus, const std::shared_ptr<boost::asio::io_service>& io);
 }
 }
 }
 
-#endif // CORE_DBUS_ASIO_EXECUTOR_H_
+#endif // CORE_DBUS_ASIO_MAKE_EXECUTOR_H_

=== modified file 'include/core/dbus/executor.h'
--- include/core/dbus/executor.h	2013-11-27 18:57:42 +0000
+++ include/core/dbus/executor.h	2016-01-18 16:49:39 +0000
@@ -20,6 +20,10 @@
 
 #include <core/dbus/visibility.h>
 
+#include <core/signal.h>
+
+#include <functional>
+#include <iosfwd>
 #include <memory>
 
 namespace core
@@ -34,25 +38,97 @@
 public:
     typedef std::shared_ptr<Executor> Ptr;
     
+    /** @brief Task models an arbitrary function to be executed by an Executor. */
+    typedef std::function<void()> Task;
+
+    /** @brief A Timeout models an individual recurring timer. */
+    class Timeout
+    {
+    public:
+        /** @cond */
+        typedef std::shared_ptr<Timeout> Ptr;
+
+        Timeout(Timeout&&) = delete;
+        Timeout(const Timeout&) = delete;
+        Timeout&& operator=(Timeout&&) = delete;
+        Timeout& operator=(const Timeout&) = delete;
+        virtual ~Timeout() = default;
+        /** @endcond */
+
+        /** @brief start enables the timer. */
+        virtual void start() = 0;
+        /** @brief stop stops the timer. */
+        virtual void stop() = 0;
+        /** @brief triggered returns a signal that is emitted whenever the timer expires. */
+        virtual const core::Signal<void>& on_triggered() = 0;
+
+    protected:
+        Timeout() = default;
+    };
+
+    /** @brief A Timeout models a recurring timer. */
+    class Watch
+    {
+    public:
+        /** @cond */
+        typedef std::shared_ptr<Watch> Ptr;
+        /** @endcond */
+
+        /** @brief Flags enumerates all possible operations and result codes when watching file descriptors. */
+        enum class Flags : std::uint8_t
+        {
+            none        = 0,
+            readable    = 1 << 0,
+            writable    = 1 << 1,
+            error       = 1 << 2,
+            hangup      = 1 << 3
+        };
+
+        /** @cond */
+        Watch(Watch&&) = delete;
+        Watch(const Watch&) = delete;
+        Watch&& operator=(Watch&&) = delete;
+        Watch& operator=(const Watch&) = delete;
+        virtual ~Watch() = default;
+        /** @endcond */
+
+        /** @brief start enables the watch. */
+        virtual void start_with_flags(Watch::Flags flags) = 0;
+        /** @brief stop stops the watch. */
+        virtual void stop() = 0;
+        /** @brief triggered returns a signal that is emitted when the underlying fd becomes read/writable. */
+        virtual const core::Signal<Flags>& on_triggered() = 0;
+
+    protected:
+        Watch() = default;
+    };
+
     virtual ~Executor() = default;
 
+    /** @brief add_watch returns a Watch instance monitoring fd. */
+    virtual Watch::Ptr add_watch(int fd) = 0;
+    /** @brief add_timeout returns a Timeout instance. */
+    virtual Timeout::Ptr add_timeout(const std::chrono::milliseconds& duration) = 0;
+    /** @brief dispatch takes task and executes it either now or later. */
+    virtual void dispatch(const Task& task) = 0;
+
+    /** @brief Start the event loop and block until stop is called. */
+    virtual void run() = 0;
+
+    /** @brief Stop the event loop. */
+    virtual void stop() = 0;
+
 protected:
     friend class Bus;
 
     Executor() = default;
     Executor(const Executor&) = delete;
     Executor& operator=(const Executor&) = delete;
-
-    /**
-     * @brief Start the event loop and block until stop is called.
-     */
-    virtual void run() = 0;
-
-    /**
-     * @brief Stop the event loop.
-     */
-    virtual void stop() = 0;
 };
+
+ORG_FREEDESKTOP_DBUS_DLL_PUBLIC std::ostream& operator<<(std::ostream& out, Executor::Watch::Flags flags);
+ORG_FREEDESKTOP_DBUS_DLL_PUBLIC Executor::Watch::Flags operator|(Executor::Watch::Flags lhs, Executor::Watch::Flags rhs);
+ORG_FREEDESKTOP_DBUS_DLL_PUBLIC Executor::Watch::Flags operator&(Executor::Watch::Flags lhs, Executor::Watch::Flags rhs);
 }
 }
 

=== modified file 'src/core/dbus/CMakeLists.txt'
--- src/core/dbus/CMakeLists.txt	2014-03-05 15:02:12 +0000
+++ src/core/dbus/CMakeLists.txt	2016-01-18 16:49:39 +0000
@@ -21,6 +21,7 @@
 
 include_directories(
   ${CMAKE_SOURCE_DIR}/include
+  ${CMAKE_SOURCE_DIR}/src
   ${DBUS_INCLUDE_DIRS}
   ${Boost_INCLUDE_DIRS}
   ${PROCESS_CPP_INCLUDE_DIR}
@@ -33,17 +34,20 @@
 add_library(
   dbus-cpp SHARED
 
+  ${DBUS_CPP_INTERFACE_HEADERS}
   ${CMAKE_CURRENT_BINARY_DIR}/fixture.cpp
 
   bus.cpp
   dbus.cpp
+  executor.cpp
   error.cpp
   match_rule.cpp
   message.cpp
   service.cpp
   service_watcher.cpp
 
-  asio/executor.cpp
+  asio/asio.h
+  asio/asio.cpp
 
   types/object_path.cpp
 )

=== renamed file 'src/core/dbus/asio/executor.cpp' => 'src/core/dbus/asio/asio.cpp'
--- src/core/dbus/asio/executor.cpp	2014-09-28 21:27:09 +0000
+++ src/core/dbus/asio/asio.cpp	2016-01-18 16:49:39 +0000
@@ -16,10 +16,9 @@
  * 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 <core/dbus/asio/asio.h>
+#include <core/dbus/asio/make_executor.h>
 
 #include <boost/asio.hpp>
 #include <boost/asio/io_service.hpp>
@@ -32,383 +31,173 @@
 #include <future>
 #include <thread>
 
-namespace core
-{
-namespace dbus
-{
-namespace traits
-{
-template<>
-struct Timeout<DBusTimeout>
-{
-    typedef int DurationType;
-
-    static inline bool is_timeout_enabled(DBusTimeout* timeout)
-    {
-        return TRUE == 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 TRUE == 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()
-        {
-            // cancel();
-        }
-
-        void start()
-        {
-            if (!traits::Timeout<UnderlyingTimeoutType>::is_timeout_enabled(timeout))
-            {
-                return;
-            }
-
-            // We do not keep ourselves alive to prevent from races during destruction.
-            std::weak_ptr<Timeout<UnderlyingTimeoutType>> wp{this->shared_from_this()};
-
-            timer.expires_from_now(
-                        boost::posix_time::milliseconds(
-                            traits::Timeout<UnderlyingTimeoutType>::get_timeout_interval(
-                                timeout)));
-            timer.async_wait([wp](const boost::system::error_code& ec)
-            {
-                auto sp = wp.lock();
-
-                if (sp)
-                    sp->on_timeout(ec);
-            });
-        }
-
-        void cancel()
-        {
-            try
-            {
-                timer.cancel();
-            } catch(...)
-            {
-                // Really not sure what we should do about exceptions here.
-            }
-        }
-
-        void on_timeout(const boost::system::error_code& ec)
-        {
-            if (ec == boost::asio::error::operation_aborted)
-                return;
-
-            if (ec)
-                return;
-
-            traits::Timeout<UnderlyingTimeoutType>::invoke_timeout_handler(timeout);
-        }
-
-        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()
-        {
-            // We do not keep ourselves alive to prevent from races during destruction.
-            std::weak_ptr<Watch<UnderlyingWatchType>> wp{this->shared_from_this()};
-
-            if (traits::Watch<UnderlyingWatchType>::is_watch_monitoring_fd_for_readable(watch))
-            {
-                stream_descriptor.async_read_some(boost::asio::null_buffers(), [wp](boost::system::error_code ec, std::size_t bytes_transferred)
-                {
-                    auto sp = wp.lock();
-
-                    if (sp)
-                        sp->on_stream_descriptor_event(
-                                    traits::Watch<UnderlyingWatchType>::readable_event(),
-                                    ec,
-                                    bytes_transferred);
-                });
-            }
-
-            if (traits::Watch<UnderlyingWatchType>::is_watch_monitoring_fd_for_writable(watch))
-            {
-                stream_descriptor.async_write_some(boost::asio::null_buffers(), [wp](boost::system::error_code ec, std::size_t bytes_transferred)
-                {
-                    auto sp = wp.lock();
-
-                    if (sp)
-                        sp->on_stream_descriptor_event(
-                                    traits::Watch<UnderlyingWatchType>::writeable_event(),
-                                    ec,
-                                    bytes_transferred);
-                });
-            }
-        }
-
-        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->start();
-    }
-
-    static void on_dbus_wakeup_event_loop(void* data)
-    {
-        auto thiz = static_cast<Executor*>(data);
-        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:
-
-    Executor(const Bus::Ptr& bus, boost::asio::io_service& io) : bus(bus), io_service(io), 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;
-};
-
-ORG_FREEDESKTOP_DBUS_DLL_PUBLIC Executor::Ptr make_executor(const Bus::Ptr& bus)
-{
-    static boost::asio::io_service io;
-    return std::make_shared<core::dbus::asio::Executor>(bus, io);
-}
-
-ORG_FREEDESKTOP_DBUS_DLL_PUBLIC Executor::Ptr make_executor(const Bus::Ptr& bus, boost::asio::io_service& io)
-{
-    return std::make_shared<core::dbus::asio::Executor>(bus, io);
-}
-
-}
-}
-}
-
+core::dbus::asio::Executor::Timeout::Ptr core::dbus::asio::Executor::Timeout::create(const std::shared_ptr<boost::asio::io_service>& io_service, const std::chrono::milliseconds& period)
+{
+    return Executor::Timeout::Ptr(new Executor::Timeout(io_service, period));
+}
+
+core::dbus::asio::Executor::Timeout::Timeout(const std::shared_ptr<boost::asio::io_service>& ios, const std::chrono::milliseconds& ms)
+    : ios(ios),
+      timer(*ios),
+      period(ms)
+{
+}
+
+core::dbus::asio::Executor::Timeout::~Timeout()
+{
+    // cancel();
+}
+
+void core::dbus::asio::Executor::Timeout::start()
+{
+    // We do not keep ourselves alive to prevent from races during destruction.
+    std::weak_ptr<Timeout> wp{this->shared_from_this()};
+
+    timer.expires_from_now(boost::posix_time::milliseconds(period.count()));
+    timer.async_wait([wp](const boost::system::error_code& ec)
+    {
+        if (auto sp = wp.lock())
+            sp->on_timeout(ec);
+    });
+}
+
+void core::dbus::asio::Executor::Timeout::stop()
+{
+    try
+    {
+        timer.cancel();
+    } catch(...)
+    {
+        // Really not sure what we should do about exceptions here.
+    }
+}
+
+const core::Signal<void>& core::dbus::asio::Executor::Timeout::on_triggered()
+{
+    return triggered;
+}
+
+void core::dbus::asio::Executor::Timeout::on_timeout(const boost::system::error_code& ec)
+{
+    if (not ec)
+        triggered();
+}
+
+core::dbus::asio::Executor::Watch::Ptr core::dbus::asio::Executor::Watch::create(const std::shared_ptr<boost::asio::io_service>& io_service, int fd)
+{
+    return Executor::Watch::Ptr(new Executor::Watch(io_service, fd));
+}
+
+core::dbus::asio::Executor::Watch::Watch(const std::shared_ptr<boost::asio::io_service>& ios, int fd)
+    : ios(ios),
+      stream_descriptor(*ios, ::dup(fd))
+{
+}
+
+core::dbus::asio::Executor::Watch::~Watch()
+{
+}
+
+void core::dbus::asio::Executor::Watch::start_with_flags(Watch::Flags flags)
+{
+    // We do not keep ourselves alive to prevent from races during destruction.
+    std::weak_ptr<Watch> wp{this->shared_from_this()};
+
+    if ((flags & Flags::readable) == Flags::readable)
+    {
+        stream_descriptor.async_read_some(boost::asio::null_buffers(), [wp, flags](boost::system::error_code ec, std::size_t bytes_transferred)
+        {
+            if (auto sp = wp.lock())
+            {
+                if (ec != boost::asio::error::operation_aborted)
+                    sp->on_stream_descriptor_event(ec ? Flags::error : Flags::readable, flags, bytes_transferred);
+            }
+        });
+    }
+
+    if ((flags & Flags::writable) == Flags::writable)
+    {
+        stream_descriptor.async_write_some(boost::asio::null_buffers(), [wp, flags](boost::system::error_code ec, std::size_t bytes_transferred)
+        {
+            if (auto sp = wp.lock())
+            {
+                if (ec != boost::asio::error::operation_aborted)
+                    sp->on_stream_descriptor_event(ec ? Flags::error : Flags::writable, flags, bytes_transferred);
+            }
+        });
+    }
+}
+
+void core::dbus::asio::Executor::Watch::stop()
+{
+    try
+    {
+        stream_descriptor.cancel();
+    }
+    catch (...)
+    {
+    }
+}
+
+const core::Signal<core::dbus::Executor::Watch::Flags>& core::dbus::asio::Executor::Watch::on_triggered()
+{
+    return triggered;
+}
+
+void core::dbus::asio::Executor::Watch::on_stream_descriptor_event(Watch::Flags flags, Watch::Flags requested, std::size_t)
+{
+    const bool has_error = (flags & Flags::error) == Flags::error;
+
+    triggered(flags);
+
+    if (not has_error)
+        start_with_flags(requested);
+}
+
+core::dbus::asio::Executor::Executor(const std::shared_ptr<boost::asio::io_service>& ios) : ios(ios), work(*ios)
+{
+}
+
+core::dbus::asio::Executor::~Executor()
+{
+    stop();
+}
+
+core::dbus::Executor::Watch::Ptr core::dbus::asio::Executor::add_watch(int fd)
+{
+    return asio::Executor::Watch::create(ios, fd);
+}
+
+core::dbus::Executor::Timeout::Ptr core::dbus::asio::Executor::add_timeout(const std::chrono::milliseconds& duration)
+{
+    return asio::Executor::Timeout::create(ios, duration);
+}
+
+void core::dbus::asio::Executor::dispatch(const Executor::Task& task)
+{
+    ios->post([task]()
+    {
+        task();
+    });
+}
+
+void core::dbus::asio::Executor::run()
+{
+    ios->run();
+}
+
+void core::dbus::asio::Executor::stop()
+{
+    ios->stop();
+}
+
+core::dbus::Executor::Ptr core::dbus::asio::make_executor(const Bus::Ptr&)
+{
+    static auto ios = std::make_shared<boost::asio::io_service>();
+    return std::make_shared<core::dbus::asio::Executor>(ios);
+}
+
+core::dbus::Executor::Ptr core::dbus::asio::make_executor(const Bus::Ptr&, const std::shared_ptr<boost::asio::io_service>& ios)
+{
+    return std::make_shared<core::dbus::asio::Executor>(ios);
+}

=== added file 'src/core/dbus/asio/asio.h'
--- src/core/dbus/asio/asio.h	1970-01-01 00:00:00 +0000
+++ src/core/dbus/asio/asio.h	2016-01-18 16:49:39 +0000
@@ -0,0 +1,108 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef CORE_DBUS_ASIO_EXECUTOR_H_
+#define CORE_DBUS_ASIO_EXECUTOR_H_
+
+#include <core/dbus/bus.h>
+#include <core/dbus/executor.h>
+#include <core/dbus/visibility.h>
+
+#include <boost/asio.hpp>
+
+#include <dbus/dbus.h>
+
+namespace core
+{
+namespace dbus
+{
+namespace asio
+{
+class ORG_FREEDESKTOP_DBUS_DLL_PUBLIC Executor : public core::dbus::Executor
+{
+public:
+    typedef std::shared_ptr<Executor> Ptr;
+
+    class Timeout : public std::enable_shared_from_this<Timeout>, public core::dbus::Executor::Timeout
+    {
+    public:
+        typedef std::shared_ptr<Timeout> Ptr;
+
+        static Ptr create(const std::shared_ptr<boost::asio::io_service>& io_service, const std::chrono::milliseconds& period);
+
+        ~Timeout();
+
+        void start() override;
+        void stop() override;
+        const core::Signal<void>& on_triggered() override;
+
+    private:
+        Timeout(const std::shared_ptr<boost::asio::io_service>& io_service, const std::chrono::milliseconds& period);
+        void on_timeout(const boost::system::error_code& ec);
+
+        std::shared_ptr<boost::asio::io_service> ios;
+        core::Signal<void> triggered;
+        boost::asio::deadline_timer timer;
+        std::chrono::milliseconds period;
+    };
+
+    class Watch : public std::enable_shared_from_this<Watch>,
+                  public core::dbus::Executor::Watch
+    {
+    public:
+        typedef std::shared_ptr<Watch> Ptr;
+        static Ptr create(const std::shared_ptr<boost::asio::io_service>& io_service, int fd);
+
+        ~Watch() noexcept(true);
+
+        void start_with_flags(Watch::Flags flags) override;
+        void stop() override;
+        const core::Signal<Flags>& on_triggered() override;
+
+    private:
+        Watch(const std::shared_ptr<boost::asio::io_service>& io_service, int fd);
+        void restart();
+        void on_stream_descriptor_event(Watch::Flags flags, Watch::Flags requested, std::size_t);
+
+        std::shared_ptr<boost::asio::io_service> ios;
+        core::Signal<Watch::Flags> triggered;
+        boost::asio::posix::stream_descriptor stream_descriptor;
+    };
+
+public:
+    Executor(const std::shared_ptr<boost::asio::io_service>& ios);
+
+    ~Executor() noexcept(true);
+
+    core::dbus::Executor::Watch::Ptr add_watch(int fd) override;
+    core::dbus::Executor::Timeout::Ptr add_timeout(const std::chrono::milliseconds& duration) override;
+    void dispatch(const Task& task) override;
+
+    void run() override;
+    void stop() override;
+
+private:
+    std::shared_ptr<boost::asio::io_service> ios;
+    boost::asio::io_service::work work;
+};
+
+}
+}
+}
+
+#endif // CORE_DBUS_ASIO_EXECUTOR_H_

=== modified file 'src/core/dbus/bus.cpp'
--- src/core/dbus/bus.cpp	2016-01-02 22:02:10 +0000
+++ src/core/dbus/bus.cpp	2016-01-18 16:49:39 +0000
@@ -21,8 +21,7 @@
 #include <core/dbus/match_rule.h>
 #include <core/dbus/object.h>
 
-#include <core/dbus/traits/timeout.h>
-#include <core/dbus/traits/watch.h>
+#include <dbus/dbus.h>
 
 #include <core/posix/this_process.h>
 
@@ -32,6 +31,112 @@
 
 namespace
 {
+namespace timeout
+{
+bool is_enabled(DBusTimeout* timeout)
+{
+    return TRUE == dbus_timeout_get_enabled(timeout);
+}
+
+std::chrono::milliseconds get_interval(DBusTimeout* timeout)
+{
+    return std::chrono::milliseconds{dbus_timeout_get_interval(timeout)};
+}
+
+void set_data(DBusTimeout* timeout, void* data, void (*deleter)(void*))
+{
+    dbus_timeout_set_data(timeout, data, deleter);
+}
+
+void invoke_handler_or_throw(DBusTimeout* timeout)
+{
+    if (not dbus_timeout_handle(timeout))
+        throw std::runtime_error{"Error invoking dbus timeout handler"};
+}
+}
+
+namespace watch
+{
+constexpr int readable_event()
+{
+    return DBUS_WATCH_READABLE;
+}
+
+constexpr int writeable_event()
+{
+    return DBUS_WATCH_WRITABLE;
+}
+
+constexpr int error_event()
+{
+    return DBUS_WATCH_ERROR;
+}
+
+constexpr int hangup_event()
+{
+    return DBUS_WATCH_HANGUP;
+}
+
+bool is_watch_enabled(DBusWatch* watch)
+{
+    return TRUE == dbus_watch_get_enabled(watch);
+}
+
+int get_unix_fd(DBusWatch* watch)
+{
+    return dbus_watch_get_unix_fd(watch);
+}
+
+bool is_monitoring_fd_for_readable(DBusWatch* watch)
+{
+    return dbus_watch_get_flags(watch) & DBUS_WATCH_READABLE;
+}
+
+bool is_monitoring_fd_for_writable(DBusWatch* watch)
+{
+    return dbus_watch_get_flags(watch) & DBUS_WATCH_WRITABLE;
+}
+
+void* get_data(DBusWatch* watch)
+{
+    return dbus_watch_get_data(watch);
+}
+
+void set_data(DBusWatch* watch, void* data, void (*deleter)(void*))
+{
+    dbus_watch_set_data(watch, data, deleter);
+}
+
+void invoke_handler_or_throw(DBusWatch* watch, int event)
+{
+    if (not dbus_watch_handle(watch, event))
+    {
+        throw std::runtime_error{"Error invoking DBus watch handler."};
+    }
+}
+}
+
+template<typename T>
+struct Holder
+{
+    static void ptr_delete(void* p)
+    {
+        delete static_cast<T*>(p);
+    }
+
+    Holder(const T& t) : value(t)
+    {
+    }
+
+    T value;
+};
+
+template<typename T>
+Holder<T>* make_holder(const T& value)
+{
+    return new Holder<T>(value);
+}
+
 struct VTable
 {
     static void unregister_object_path(DBusConnection*, void* data)
@@ -127,6 +232,126 @@
         init_libdbus_thread_support_and_install_shutdown_handler();
     }
 
+    static dbus_bool_t on_dbus_add_watch(DBusWatch* watch, void* data)
+    {
+        auto thiz = static_cast<Private*>(data);
+
+        if (not thiz)
+            return FALSE;
+
+        Executor::Watch::Flags f{Executor::Watch::Flags::none};
+
+        if (watch::is_monitoring_fd_for_readable(watch))
+            f = f | Executor::Watch::Flags::readable;
+        if (watch::is_monitoring_fd_for_writable(watch))
+            f = f | Executor::Watch::Flags::writable;
+
+        auto w = thiz->executor->add_watch(watch::get_unix_fd(watch));
+
+        w->on_triggered().connect([watch](Executor::Watch::Flags flags)
+        {
+            int event = 0;
+
+            if ((flags & Executor::Watch::Flags::readable) == Executor::Watch::Flags::readable)
+                event |= watch::readable_event();
+            if ((flags & Executor::Watch::Flags::writable) == Executor::Watch::Flags::writable)
+                event |= watch::writeable_event();
+            if ((flags & Executor::Watch::Flags::error) == Executor::Watch::Flags::error)
+                event |= watch::error_event();
+            if ((flags & Executor::Watch::Flags::hangup) == Executor::Watch::Flags::hangup)
+                event |= watch::hangup_event();
+
+            watch::invoke_handler_or_throw(watch, event);
+        });
+
+        watch::set_data(watch, make_holder(w), Holder<Executor::Watch::Ptr>::ptr_delete);
+
+        if (watch::is_watch_enabled(watch))
+            w->start_with_flags(f);
+
+        return TRUE;
+    }
+
+    static void on_dbus_remove_watch(DBusWatch* watch, void*)
+    {
+        if (auto w = static_cast<Holder<Executor::Watch::Ptr>*>(watch::get_data(watch)))
+            w->value->stop();
+    }
+
+    static void on_dbus_watch_toggled(DBusWatch* watch, void*)
+    {
+        if (auto holder = static_cast<Holder<Executor::Watch::Ptr>*>(watch::get_data(watch)))
+        {
+            Executor::Watch::Flags f{Executor::Watch::Flags::none};
+
+            if (watch::is_monitoring_fd_for_readable(watch))
+                f = f | Executor::Watch::Flags::readable;
+            if (watch::is_monitoring_fd_for_writable(watch))
+                f = f | Executor::Watch::Flags::writable;
+
+            if (watch::is_watch_enabled(watch))
+                holder->value->start_with_flags(f);
+            else
+                holder->value->stop();
+        }
+    }
+
+    static dbus_bool_t on_dbus_add_timeout(DBusTimeout* timeout, void* data)
+    {
+        auto thiz = static_cast<Private*>(data);
+
+        if (not thiz)
+            return FALSE;
+
+        const auto interval = timeout::get_interval(timeout);
+
+        auto t = thiz->executor->add_timeout(interval);
+
+        t->on_triggered().connect([timeout]()
+        {
+            timeout::invoke_handler_or_throw(timeout);
+        });
+
+        timeout::set_data(timeout, make_holder(t), Holder<Executor::Timeout::Ptr>::ptr_delete);
+
+        if (timeout::is_enabled(timeout))
+            t->start();
+
+        return TRUE;
+    }
+
+    static void on_dbus_remove_timeout(DBusTimeout* timeout, void*)
+    {
+        if (auto holder = static_cast<Holder<Executor::Timeout::Ptr>*>(dbus_timeout_get_data(timeout)))
+            holder->value->stop();
+    }
+
+    static void on_dbus_timeout_toggled(DBusTimeout* timeout, void*)
+    {
+        if (auto holder = static_cast<Holder<Executor::Timeout::Ptr>*>(dbus_timeout_get_data(timeout)))
+        {
+            if (timeout::is_enabled(timeout))
+                holder->value->start();
+            else
+                holder->value->stop();
+        }
+
+    }
+
+    static void on_dbus_wakeup_event_loop(void* data)
+    {
+        auto thiz = static_cast<Private*>(data);
+        auto connection = thiz->connection;
+
+        thiz->executor->dispatch([connection]()
+        {
+            while (dbus_connection_get_dispatch_status(connection.get()) == DBUS_DISPATCH_DATA_REMAINS)
+            {
+                dbus_connection_dispatch(connection.get());
+            }
+        });
+    }
+
     std::shared_ptr<DBusConnection> connection;
     std::shared_ptr<MessageFactory> message_factory_impl;
     Executor::Ptr executor;
@@ -339,6 +564,30 @@
 void Bus::install_executor(const Executor::Ptr& e)
 {
     d->executor = e;
+
+    if (!dbus_connection_set_watch_functions(
+                d->connection.get(),
+                Private::on_dbus_add_watch,
+                Private::on_dbus_remove_watch,
+                Private::on_dbus_watch_toggled,
+                d.get(),
+                nullptr))
+        throw std::runtime_error("Problem installing watch functions.");
+
+    if (!dbus_connection_set_timeout_functions(
+                d->connection.get(),
+                Private::on_dbus_add_timeout,
+                Private::on_dbus_remove_timeout,
+                Private::on_dbus_timeout_toggled,
+                d.get(),
+                nullptr))
+        throw std::runtime_error("Problem installing timeout functions.");
+
+    dbus_connection_set_wakeup_main_function(
+                d->connection.get(),
+                Private::on_dbus_wakeup_event_loop,
+                d.get(),
+                nullptr);
 }
 
 void Bus::stop()

=== added file 'src/core/dbus/executor.cpp'
--- src/core/dbus/executor.cpp	1970-01-01 00:00:00 +0000
+++ src/core/dbus/executor.cpp	2016-01-18 16:49:39 +0000
@@ -0,0 +1,42 @@
+/*
+ * 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/executor.h>
+
+#include <bitset>
+#include <iostream>
+
+namespace
+{
+using NT = typename std::underlying_type<core::dbus::Executor::Watch::Flags>::type;
+}
+
+std::ostream& core::dbus::operator<<(std::ostream& out, core::dbus::Executor::Watch::Flags flags)
+{
+    return out << "Watch::Flags[" << std::bitset<4*sizeof(NT)>(static_cast<NT>(flags)).to_string() << "]";
+}
+
+core::dbus::Executor::Watch::Flags core::dbus::operator|(core::dbus::Executor::Watch::Flags lhs, core::dbus::Executor::Watch::Flags rhs)
+{
+    return static_cast<core::dbus::Executor::Watch::Flags>(static_cast<NT>(lhs) | static_cast<NT>(rhs));
+}
+
+core::dbus::Executor::Watch::Flags core::dbus::operator&(core::dbus::Executor::Watch::Flags lhs, core::dbus::Executor::Watch::Flags rhs)
+{
+    return static_cast<core::dbus::Executor::Watch::Flags>(static_cast<NT>(lhs) & static_cast<NT>(rhs));
+}

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-09-28 21:27:09 +0000
+++ tests/CMakeLists.txt	2016-01-18 16:49:39 +0000
@@ -31,6 +31,7 @@
   ${CMAKE_CURRENT_BINARY_DIR}/test_data.h @ONLY)
 
 include_directories(
+  ${CMAKE_SOURCE_DIR}/src
   ${CMAKE_CURRENT_BINARY_DIR}
 )
 

=== modified file 'tests/executor_test.cpp'
--- tests/executor_test.cpp	2014-09-28 21:27:09 +0000
+++ tests/executor_test.cpp	2016-01-18 16:49:39 +0000
@@ -16,7 +16,8 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
-#include <core/dbus/asio/executor.h>
+#include <core/dbus/asio/make_executor.h>
+#include <core/dbus/asio/asio.h>
 
 #include <core/dbus/dbus.h>
 #include <core/dbus/fixture.h>
@@ -53,10 +54,15 @@
     std::binomial_distribution<> coin{1, 1.-probability_for_failure};
 };
 
+struct ExecutorWatchFlags : public ::testing::TestWithParam<core::dbus::Executor::Watch::Flags>
+{
+
+};
+
 struct Executor : public core::dbus::testing::Fixture
 {
  protected:
-    boost::asio::io_service io_service;
+    std::shared_ptr<boost::asio::io_service> io_service = std::make_shared<boost::asio::io_service>();
 };
 
 auto session_bus_config_file =
@@ -68,16 +74,119 @@
         core::testing::system_bus_configuration_file();
 }
 
-TEST_F(Executor, ThrowsOnConstructionFromNullBus)
-{
-    EXPECT_ANY_THROW(core::dbus::asio::make_executor(core::dbus::Bus::Ptr{}, io_service));
-}
-
-TEST_F(Executor, DoesNotThrowForExistingBus)
-{
-    auto bus = session_bus();
-    EXPECT_NO_THROW(bus->install_executor(core::dbus::asio::make_executor(bus, io_service)));
-}
+TEST_P(ExecutorWatchFlags, BinaryOrAndWorksAsExpected)
+{
+    core::dbus::Executor::Watch::Flags f{core::dbus::Executor::Watch::Flags::none};
+    EXPECT_EQ(GetParam(), (f | GetParam()) & GetParam());
+}
+
+INSTANTIATE_TEST_CASE_P(ExecutorWatchFlags,
+                        ExecutorWatchFlags,
+                        ::testing::Values(core::dbus::Executor::Watch::Flags::readable,
+                                          core::dbus::Executor::Watch::Flags::writable,
+                                          core::dbus::Executor::Watch::Flags::error,
+                                          core::dbus::Executor::Watch::Flags::hangup));
+
+TEST(ExecutorWatch, TriggersForFdReadable)
+{
+    static constexpr const std::size_t read = 0;
+    static constexpr const std::size_t write = 1;
+
+    int fds[2];
+    ::pipe(fds);
+
+    auto ios = std::make_shared<boost::asio::io_service>();
+    boost::asio::io_service::work work{*ios};
+
+    auto watch = core::dbus::asio::Executor::Watch::create(ios, fds[read]);
+    watch->on_triggered().connect([ios](core::dbus::asio::Executor::Watch::Flags flags)
+    {
+        EXPECT_EQ(core::dbus::asio::Executor::Watch::Flags::readable, flags & core::dbus::asio::Executor::Watch::Flags::readable);
+        ios->stop();
+    });
+    watch->start_with_flags(core::dbus::asio::Executor::Watch::Flags::readable);
+
+    ::write(fds[write], &read, sizeof(read));
+
+    ios->run();
+
+    ::close(fds[read]); ::close(fds[write]);
+}
+
+TEST(ExecutorWatch, TriggersForFdWritable)
+{
+    static constexpr const std::size_t read = 0;
+    static constexpr const std::size_t write = 1;
+
+    int fds[2];
+    ::pipe(fds);
+
+    auto ios = std::make_shared<boost::asio::io_service>();
+    boost::asio::io_service::work work{*ios};
+
+    auto ww = core::dbus::asio::Executor::Watch::create(ios, fds[write]);
+    ww->on_triggered().connect([ios](core::dbus::asio::Executor::Watch::Flags flags)
+    {
+        EXPECT_EQ(core::dbus::asio::Executor::Watch::Flags::writable, flags & core::dbus::asio::Executor::Watch::Flags::writable);
+        ios->stop();
+    });
+    ww->start_with_flags(core::dbus::asio::Executor::Watch::Flags::writable);
+
+    std::size_t v;
+    ::write(fds[write], &v, sizeof(v));
+
+    ios->run();
+
+    ::close(fds[read]); ::close(fds[write]);
+}
+
+TEST(ExecutorTimeout, TimeoutTriggersCorrectly)
+{
+    auto ios = std::make_shared<boost::asio::io_service>();
+    boost::asio::io_service::work work{*ios};
+
+    auto to = core::dbus::asio::Executor::Timeout::create(ios, std::chrono::milliseconds{500});
+    to->on_triggered().connect([ios]()
+    {
+        ios->stop();
+    });
+
+    to->start();
+    ios->run();
+}
+
+TEST(ExecutorTimeout, TimeoutTriggersCorrectlyForZeroDuration)
+{
+    auto ios = std::make_shared<boost::asio::io_service>();
+    boost::asio::io_service::work work{*ios};
+
+    auto to = core::dbus::asio::Executor::Timeout::create(ios, std::chrono::milliseconds{0});
+    to->on_triggered().connect([ios]()
+    {
+        ios->stop();
+    });
+
+    to->start();
+    ios->run();
+}
+
+TEST(ExecutorTimeout, TimeoutGoingOutOfScopeDoesNotSegfault)
+{
+    auto ios = std::make_shared<boost::asio::io_service>();
+    boost::asio::io_service::work work{*ios};
+
+    {
+        auto to = core::dbus::asio::Executor::Timeout::create(ios, std::chrono::milliseconds{500});
+        to->start();
+    }
+
+    auto to = core::dbus::asio::Executor::Timeout::create(ios, std::chrono::milliseconds{500});
+    to->on_triggered().connect([ios]() { ios->stop(); });
+    to->start();
+
+    ios->run();
+}
+
 
 TEST_F(Executor, ABusRunByAnExecutorReceivesSignals)
 {
@@ -206,45 +315,30 @@
         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;
-                }
-            }
-        });
+        auto updater = [](const core::dbus::Object::Ptr& stub)
+        {
+            for (unsigned int counter = 0; counter < 1000; counter++)
+            {
+                try
+                {
+                    auto result = stub->transact_method<test::Service::Method, int64_t>();
+
+                    if (not result.is_error())
+                    {
+                        EXPECT_EQ(42, result.value());
+                    }
+
+                } catch(...)
+                {
+                    // Dropping the exception on purpose. We have a chaos monkey running,
+                    //
+                }
+            }
+        };
+
+
+        std::thread updater1(updater, stub);
+        std::thread updater2(updater, stub);
 
         if (updater1.joinable())
             updater1.join();

=== modified file 'tests/service_test.cpp'
--- tests/service_test.cpp	2014-07-30 16:12:16 +0000
+++ tests/service_test.cpp	2016-01-18 16:49:39 +0000
@@ -66,11 +66,13 @@
 
 TEST_F(Service, AddingServiceAndObjectAndCallingIntoItSucceeds)
 {
-        core::testing::CrossProcessSync cps1;
-
-        const int64_t expected_value = 42;
-
-        auto service = [this, expected_value, &cps1]()
+    core::testing::CrossProcessSync cps1;
+
+    const int64_t expected_value = 42;
+
+    auto service = [this, expected_value, &cps1]()
+    {
+        try
         {
             core::testing::SigTermCatcher sc;
 
@@ -87,6 +89,7 @@
 
             skeleton->install_method_handler<test::Service::Method>([bus, skeleton, &readonly_property, expected_value](const dbus::Message::Ptr& msg)
             {
+                std::cout << "here" << std::endl;
                 auto reply = dbus::Message::make_method_return(msg);
                 reply->writer() << expected_value;
                 bus->send(reply);
@@ -95,9 +98,9 @@
                 auto changed_signal = skeleton->get_signal<core::dbus::interfaces::Properties::Signals::PropertiesChanged>();
                 core::dbus::interfaces::Properties::Signals::PropertiesChanged::ArgumentType
                         args("this.is.unlikely.to.exist.Service",
-                             {{test::Service::Properties::ReadOnly::name(),
-                               core::dbus::types::TypedVariant<test::Service::Properties::ReadOnly::ValueType>(expected_value)}},
-                             {});
+                {{test::Service::Properties::ReadOnly::name(),
+                  core::dbus::types::TypedVariant<test::Service::Properties::ReadOnly::ValueType>(expected_value)}},
+                {});
                 skeleton->emit_signal<core::dbus::interfaces::Properties::Signals::PropertiesChanged, core::dbus::interfaces::Properties::Signals::PropertiesChanged::ArgumentType>(args);
                 changed_signal->emit(args);
 
@@ -115,15 +118,22 @@
                 t.join();
 
             return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        auto client = [this, expected_value, &cps1]()
+        } catch(const std::exception& e)
+        {
+            std::cout << e.what() << std::endl;
+        }
+
+        return core::posix::exit::Status::failure;
+    };
+
+    auto client = [this, expected_value, &cps1]()
+    {
+        try
         {
             auto bus = session_bus();
             bus->install_executor(core::dbus::asio::make_executor(bus));
             std::thread t{[bus](){ bus->run(); }};
             EXPECT_EQ(std::uint32_t(1), cps1.wait_for_signal_ready_for(std::chrono::milliseconds{500}));
-
             auto stub_service = dbus::Service::use_service<test::Service>(bus);
             auto stub = stub_service->object_for_path(dbus::types::ObjectPath("/this/is/unlikely/to/exist/Service"));
             EXPECT_EQ(stub->path().as_string(), "/this/is/unlikely/to/exist/Service");
@@ -151,6 +161,7 @@
             try
             {
                 auto result = stub->invoke_method_synchronously<test::Service::Method, int64_t>();
+                std::cout << "here" << std::endl;
                 EXPECT_FALSE(result.is_error());
                 EXPECT_EQ(expected_value, result.value());
             } catch(const std::exception& e)
@@ -170,9 +181,15 @@
             EXPECT_EQ(changed_value, expected_value);
 
             return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
+        }
+        catch (const std::exception& e)
+        {
+            std::cout << e.what() << std::endl;
+        }
+        return core::posix::exit::Status::failure;
+    };
 
-        EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
+    EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
 }
 
 TEST_F(Service, AddingANonExistingServiceDoesNotThrow)