Merge lp:~dobey/dbus-cpp/merge-vivid into lp:dbus-cpp

[dobey]

Merge newer code from vivid branch to trunk.

=== modified file 'debian/changelog'
--- debian/changelog	2015-10-22 07:17:01 +0000
+++ debian/changelog	2016-08-01 20:07:50 +0000
@@ -23,6 +23,53 @@
 
  -- Thomas Voß <[e-mail]>  Tue, 21 Jul 2015 12:36:46 +0200
 
+dbus-cpp (4.3.0+15.04.20160114.2-0ubuntu1) vivid; urgency=medium
+
+  [ CI Train Bot ]
+  * debian/libdbus-cpp4.symbols.32bit: update to released version.
+  * debian/libdbus-cpp4.symbols.64bit: update to released version.
+
+  [ Thomas Voß ]
+  * Add a proper operator<< for dbus::Message::Type. (LP: #1524131)
+
+ -- Thomas Voß <[e-mail]>  Thu, 14 Jan 2016 21:51:19 +0000
+
+dbus-cpp (4.3.0+15.04.20160112-0ubuntu1) vivid; urgency=medium
+
+  * Only run dbus_shutdown if explicitly requested by env var. (LP:
+    #1422304, #1526877)
+
+ -- Thomas Voß <[e-mail]>  Tue, 12 Jan 2016 16:28:02 +0000
+
+dbus-cpp (4.3.0+15.04.20151126-0ubuntu1) vivid; urgency=medium
+
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+  [ Thomas Voß ]
+  * Ensure that Signal with non-void argument types correctly narrow
+    their match rules. (LP: #1480877)
+
+ -- Thomas Voß <[e-mail]>  Thu, 26 Nov 2015 07:31:37 +0000
+
+dbus-cpp (4.3.0+15.04.20151023-0ubuntu1) vivid; urgency=medium
+
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+  [ Thomas Voß ]
+  * Do not cache emitted values for stub signals. (LP: #1509285)
+
+ -- Jim Hodapp <[e-mail]>  Fri, 23 Oct 2015 10:01:27 +0000
+
+dbus-cpp (4.3.0+15.04.20151020-0ubuntu1) vivid; urgency=medium
+
+  [ Manuel de la Pena ]
+  * Ensure that the signals are correctly emitted for when the services
+    appear and go.
+
+ -- Thomas Voß <[e-mail]>  Tue, 20 Oct 2015 10:55:11 +0000
+
 dbus-cpp (4.3.0+15.04.20150505-0ubuntu1) vivid; urgency=medium
 
   [ CI Train Bot ]

=== modified file 'debian/libdbus-cpp5.symbols.32bit'
--- debian/libdbus-cpp5.symbols.32bit	2015-10-21 08:00:49 +0000
+++ debian/libdbus-cpp5.symbols.32bit	2016-08-01 20:07:50 +0000
@@ -1,5 +1,6 @@
- (c++)"core::dbus::Fixture::system_bus_address[abi:cxx11]()@Base" 4.3.0+15.04.20150505
- (c++)"core::dbus::Fixture::session_bus_address[abi:cxx11]()@Base" 4.3.0+15.04.20150505
+ (c++)"core::dbus::operator<<(std::basic_ostream<char, std::char_traits<char> >&, core::dbus::Message::Type)@Base" 4.3.0+15.04.20160114.2
+ (c++)"core::dbus::Fixture::system_bus_address()@Base" 4.3.0+15.04.20150505
+ (c++)"core::dbus::Fixture::session_bus_address()@Base" 4.3.0+15.04.20150505
  (c++)"core::dbus::Fixture::default_daemon_timeout()@Base" 4.0.0+14.10.20140730
  (c++)"core::dbus::asio::make_executor(std::shared_ptr<core::dbus::Bus> const&)@Base" 2.0.0+14.04.20140310
  (c++)"core::dbus::asio::make_executor(std::shared_ptr<core::dbus::Bus> const&, boost::asio::io_service&)@Base" 3.1.0+14.10.20140711

=== modified file 'debian/libdbus-cpp5.symbols.64bit'
--- debian/libdbus-cpp5.symbols.64bit	2015-10-21 08:00:49 +0000
+++ debian/libdbus-cpp5.symbols.64bit	2016-08-01 20:07:50 +0000
@@ -1,5 +1,6 @@
- (c++)"core::dbus::Fixture::system_bus_address[abi:cxx11]()@Base" 4.3.0+15.04.20150505
- (c++)"core::dbus::Fixture::session_bus_address[abi:cxx11]()@Base" 4.3.0+15.04.20150505
+ (c++)"core::dbus::operator<<(std::basic_ostream<char, std::char_traits<char> >&, core::dbus::Message::Type)@Base" 4.3.0+15.04.20160114.2
+ (c++)"core::dbus::Fixture::system_bus_address()@Base" 4.3.0+15.04.20150505
+ (c++)"core::dbus::Fixture::session_bus_address()@Base" 4.3.0+15.04.20150505
  (c++)"core::dbus::Fixture::default_daemon_timeout()@Base" 4.0.0+14.10.20140730
  (c++)"core::dbus::asio::make_executor(std::shared_ptr<core::dbus::Bus> const&)@Base" 2.0.0+14.04.20140310
  (c++)"core::dbus::asio::make_executor(std::shared_ptr<core::dbus::Bus> const&, boost::asio::io_service&)@Base" 3.1.0+14.10.20140711

=== modified file 'include/core/dbus/impl/object.h'
--- include/core/dbus/impl/object.h	2014-10-30 13:22:52 +0000
+++ include/core/dbus/impl/object.h	2016-08-01 20:07:50 +0000
@@ -19,7 +19,6 @@
 #define CORE_DBUS_IMPL_OBJECT_H_
 
 #include <core/dbus/bus.h>
-#include <core/dbus/lifetime_constrained_cache.h>
 #include <core/dbus/match_rule.h>
 #include <core/dbus/message_router.h>
 #include <core/dbus/message_streaming_operators.h>
@@ -37,6 +36,7 @@
 
 #include <functional>
 #include <future>
+#include <iostream>
 #include <map>
 #include <memory>
 #include <string>
@@ -70,17 +70,17 @@
         object_path.as_string(),
         traits::Service<typename Method::Interface>::interface_name().c_str(),
         Method::name());
-    
+
     if (!msg)
         throw std::runtime_error("No memory available to allocate DBus message");
-    
+ 
     auto writer = msg->writer();
     encode_message(writer, args...);
-    
+
     auto reply = parent->get_connection()->send_with_reply_and_block_for_at_most(
                 msg,
                 Method::default_timeout());
-    
+
     return Result<ResultType>::from_message(reply);
 }
 
@@ -153,40 +153,57 @@
 inline std::shared_ptr<Property<PropertyDescription>>
 Object::get_property()
 {
-    // If this is a proxy object we set up listening for property changes the
-    // first time someone accesses properties.
-    if (parent->is_stub())
-    {
-        if (!signal_properties_changed)
-        {
-            signal_properties_changed
-                = get_signal<interfaces::Properties::Signals::PropertiesChanged>();
-
-            signal_properties_changed->connect(
-                std::bind(
-                    &Object::on_properties_changed,
-                    shared_from_this(),
-                    std::placeholders::_1));
-        }
-    }
-
     typedef Property<PropertyDescription> PropertyType;
-    auto property =
-            PropertyType::make_property(
-                shared_from_this());
 
+    // Creating a stub property for a remote object/property instance
+    // requires the following steps:
+    //   [1.] Look up if we already have a property instance available in the cache, 
+    //        leveraging the tuple (path, interface, name) as key.
+    //     [1.1] If yes: return the property.
+    //     [1.2] If no: Create a new proeprty instance and:
+    //       [1.2.1] Make it known to the cache.
+    //       [1.2.2] Wire it up for property_changed signal receiving.
+    //       [1.2.3] Communicate a new match rule to the dbus daemon to enable reception.
     if (parent->is_stub())
     {
-        auto tuple = std::make_tuple(
-                traits::Service<typename PropertyDescription::Interface>::interface_name(),
-                PropertyDescription::name());
-
-        property_changed_vtable[tuple] = std::bind(
-                &Property<PropertyDescription>::handle_changed,
-                property,
-                std::placeholders::_1);
+        auto itf = traits::Service<typename PropertyDescription::Interface>::interface_name();
+        auto name = PropertyDescription::name(); 
+        auto ekey = std::make_tuple(path(), itf, name);
+
+        auto property = Object::property_cache<PropertyDescription>().retrieve_value_for_key(ekey);
+        if (property)
+        {
+            return property;
+        }
+
+        auto mr = MatchRule()
+            .type(Message::Type::signal)
+            .interface(traits::Service<interfaces::Properties>::interface_name())
+            .member(interfaces::Properties::Signals::PropertiesChanged::name());
+
+        property = PropertyType::make_property(shared_from_this());
+
+        Object::property_cache<PropertyDescription>().insert_value_for_key(ekey, property);
+
+        // We only ever do this once per object.
+        std::call_once(add_match_once, [&]()
+        {
+            // [1.2.4] Inform the dbus daemon that we would like to receive the respective signals.
+            add_match(mr);
+        });
+
+        // [1.2.2] Enable dispatching of changes.
+        std::weak_ptr<PropertyType> wp{property};
+        property_changed_vtable[std::make_tuple(itf, name)] = [wp](const types::Variant& arg)
+        {
+            if (auto sp = wp.lock())
+                sp->handle_changed(arg);
+        };
+
+        return property;
     }
-    return property;
+
+    return PropertyType::make_property(shared_from_this());
 }
 
 template<typename Interface>
@@ -312,6 +329,23 @@
                 &MessageRouter<PropertyKey>::operator(), 
                 std::ref(set_property_router), 
                 std::placeholders::_1));
+    } else
+    {
+        // We centrally route org.freedesktop.DBus.Properties.PropertiesChanged
+        // through the object, which in turn routes via a custom Property cache.
+        signal_router.install_route(
+            SignalKey{
+                traits::Service<interfaces::Properties>::interface_name(), 
+                interfaces::Properties::Signals::PropertiesChanged::name()
+            },
+            // Passing 'this' is fine as the lifetime of the signal_router is upper limited
+            // by the lifetime of 'this'.
+            [this](const Message::Ptr& msg)
+            {
+                interfaces::Properties::Signals::PropertiesChanged::ArgumentType arg;
+                msg->reader() >> arg;
+                on_properties_changed(arg);
+            });
     }
 }
 
@@ -319,6 +353,20 @@
 {
     parent->get_connection()->access_signal_router().uninstall_route(object_path);
     parent->get_connection()->unregister_object_path(object_path);
+
+    auto mr = MatchRule()
+        .type(Message::Type::signal)
+        .interface(traits::Service<interfaces::Properties>::interface_name())
+        .member(interfaces::Properties::Signals::PropertiesChanged::name());
+
+    try
+    {
+        remove_match(mr);
+    } catch(...)
+   {
+        // We consciously drop all possible exceptions here. There is hardly 
+        // anything we can do about the error anyway.
+   }
 }
 
 inline void Object::add_match(const MatchRule& rule)
@@ -346,6 +394,19 @@
         }
     }
 }
+
+template<typename PropertyDescription>
+inline core::dbus::ThreadSafeLifetimeConstrainedCache<
+    core::dbus::Object::CacheKey,
+    core::dbus::Property<PropertyDescription>>&
+core::dbus::Object::property_cache()
+{
+    static core::dbus::ThreadSafeLifetimeConstrainedCache<
+        core::dbus::Object::CacheKey,
+        core::dbus::Property<PropertyDescription>
+    > cache;
+    return cache;
+}
 }
 }
 

=== modified file 'include/core/dbus/impl/property.h'
--- include/core/dbus/impl/property.h	2014-06-10 08:44:17 +0000
+++ include/core/dbus/impl/property.h	2016-08-01 20:07:50 +0000
@@ -64,6 +64,13 @@
 }
 
 template<typename PropertyType>
+const core::Signal<void>&
+Property<PropertyType>::about_to_be_destroyed() const
+{
+    return signal_about_to_be_destroyed;
+}
+
+template<typename PropertyType>
 std::shared_ptr<Property<PropertyType>>
 Property<PropertyType>::make_property(const std::shared_ptr<Object>& parent)
 {
@@ -109,6 +116,20 @@
 }
 
 template<typename PropertyType>
+Property<PropertyType>::~Property()
+{
+    try
+    {
+        signal_about_to_be_destroyed();
+    } catch(...)
+    {
+        // Consciously dropping all exceptions here.
+        // There is hardly anything we can do about it while
+        // tearing down the object anyway.
+    }
+}
+
+template<typename PropertyType>
 void
 Property<PropertyType>::handle_get(const Message::Ptr& msg)
 {

=== modified file 'include/core/dbus/impl/signal.h'
--- include/core/dbus/impl/signal.h	2014-11-10 08:14:45 +0000
+++ include/core/dbus/impl/signal.h	2016-08-01 20:07:50 +0000
@@ -121,8 +121,8 @@
             &Signal<SignalDescription>::operator(),
             this,
             std::placeholders::_1));
-    parent->add_match(
-        rule.type(Message::Type::signal).interface(interface).member(name));
+    rule = rule.type(Message::Type::signal).interface(interface).member(name);
+    parent->add_match(rule);
 }
 
 template<typename SignalDescription, typename Argument>
@@ -309,6 +309,8 @@
             &Signal<SignalDescription, typename SignalDescription::ArgumentType>::operator(),
             this,
             std::placeholders::_1));
+
+    d->rule = d->rule.type(Message::Type::signal).interface(interface).member(name);
 }
 
 template<typename SignalDescription>
@@ -322,7 +324,8 @@
 {
     try
     {
-        msg->reader() >> d->value;
+        typename SignalDescription::ArgumentType value;
+        msg->reader() >> value;
         std::lock_guard<std::mutex> lg(d->handlers_guard);
         for (auto it : d->handlers)
         {
@@ -356,7 +359,7 @@
                     continue;
             }
 
-            handler(d->value);
+            handler(value);
         }
     }
     catch (const std::runtime_error& e)

=== modified file 'include/core/dbus/message.h'
--- include/core/dbus/message.h	2014-01-05 18:58:19 +0000
+++ include/core/dbus/message.h	2016-08-01 20:07:50 +0000
@@ -439,6 +439,8 @@
 };
 typedef std::shared_ptr<Message> MessagePtr;
 typedef std::unique_ptr<Message> MessageUPtr;
+
+ORG_FREEDESKTOP_DBUS_DLL_PUBLIC std::ostream& operator<<(std::ostream&, Message::Type);
 }
 }
 

=== modified file 'include/core/dbus/object.h'
--- include/core/dbus/object.h	2014-10-23 21:09:56 +0000
+++ include/core/dbus/object.h	2016-08-01 20:07:50 +0000
@@ -19,12 +19,14 @@
 #define CORE_DBUS_OBJECT_H_
 
 #include <core/dbus/bus.h>
+#include <core/dbus/lifetime_constrained_cache.h>
 #include <core/dbus/service.h>
 
 #include <functional>
 #include <future>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <ostream>
 #include <string>
 
@@ -82,10 +84,14 @@
 class Object : public std::enable_shared_from_this<Object>
 {
   private:
+    typedef std::tuple<types::ObjectPath, std::string, std::string> CacheKey;
     typedef std::tuple<std::string, std::string> MethodKey;
     typedef std::tuple<std::string, std::string> PropertyKey;
     typedef std::tuple<std::string, std::string> SignalKey;
 
+    template<typename PropertyDescription>
+    static ThreadSafeLifetimeConstrainedCache<CacheKey, Property<PropertyDescription>>& property_cache();
+
   public:
     typedef std::shared_ptr<Object> Ptr;
     typedef std::function<void(const Message::Ptr&)> MethodHandler;
@@ -173,7 +179,7 @@
      * @param [in] path The path to associate the object with.
      * @return An object instance or nullptr in case of errors.
      */
-    std::shared_ptr<Object> 
+    std::shared_ptr<Object>
     inline add_object_for_path(const types::ObjectPath& path);
 
     /**
@@ -227,16 +233,11 @@
     MessageRouter<MethodKey> method_router;
     MessageRouter<PropertyKey> get_property_router;
     MessageRouter<PropertyKey> set_property_router;
+    std::once_flag add_match_once;
     std::map<
         std::tuple<std::string, std::string>,
         std::function<void(const types::Variant&)>
     > property_changed_vtable;
-    std::shared_ptr<
-        Signal<
-            interfaces::Properties::Signals::PropertiesChanged,
-            interfaces::Properties::Signals::PropertiesChanged::ArgumentType
-        >
-    > signal_properties_changed;
 };
 }
 }

=== modified file 'include/core/dbus/property.h'
--- include/core/dbus/property.h	2014-01-20 21:22:02 +0000
+++ include/core/dbus/property.h	2016-08-01 20:07:50 +0000
@@ -43,6 +43,8 @@
     typedef typename PropertyType::ValueType ValueType;
     typedef core::Property<ValueType> Super;
 
+    inline ~Property();
+
     /**
      * @brief Non-mutable access to the contained value.
      * @return Non-mutable reference to the contained value.
@@ -61,6 +63,11 @@
      */
     inline bool is_writable() const;
 
+    /**
+     * @brief Emitted during destruction of an object instance.
+     */
+    inline const core::Signal<void>& about_to_be_destroyed() const;
+
 protected:
     friend class Object;
 
@@ -82,6 +89,7 @@
     std::string interface;
     std::string name;
     bool writable;
+    core::Signal<void> signal_about_to_be_destroyed;
 };
 }
 }

=== modified file 'include/core/dbus/signal.h'
--- include/core/dbus/signal.h	2014-01-24 11:17:26 +0000
+++ include/core/dbus/signal.h	2016-08-01 20:07:50 +0000
@@ -189,8 +189,11 @@
             const std::shared_ptr<Object>& parent, 
             const std::string& interface, 
             const std::string& name);
-
-        typename SignalDescription::ArgumentType value;
+        
+        // We do not need this member anymore, but keep it in place for
+        // the sake of binary compatibility. Leaving a TODO(tvoss) to clean
+        // up on next ABI bump.
+        typename SignalDescription::ArgumentType pad;
         std::shared_ptr<Object> parent;
         std::string interface;
         std::string name;

=== modified file 'src/core/dbus/bus.cpp'
--- src/core/dbus/bus.cpp	2014-11-27 16:38:44 +0000
+++ src/core/dbus/bus.cpp	2016-08-01 20:07:50 +0000
@@ -24,6 +24,8 @@
 #include <core/dbus/traits/timeout.h>
 #include <core/dbus/traits/watch.h>
 
+#include <core/posix/this_process.h>
+
 #include "message_p.h"
 #include "message_factory_impl.h"
 #include "pending_call_impl.h"
@@ -76,8 +78,18 @@
 
 void init_libdbus_thread_support_and_install_shutdown_handler()
 {
+    static const bool install_dbus_shutdown_handler
+    {
+        not core::posix::this_process::env::get("DBUS_CPP_INSTALL_DBUS_SHUTDOWN_HANDLER").empty()
+    };
+
     static std::once_flag once;
-    std::call_once(once, []() { dbus_threads_init_default(); std::atexit(dbus_shutdown); });
+    std::call_once(once, []()
+    {
+        dbus_threads_init_default();
+        if (install_dbus_shutdown_handler)
+            std::atexit(dbus_shutdown);
+    });
 }
 }
 

=== modified file 'src/core/dbus/match_rule.cpp'
--- src/core/dbus/match_rule.cpp	2014-01-21 13:48:54 +0000
+++ src/core/dbus/match_rule.cpp	2016-08-01 20:07:50 +0000
@@ -151,17 +151,10 @@
 
 std::string dbus::MatchRule::as_string() const
 {
-    static const std::map<Message::Type, std::string> lut =
-    {
-        {Message::Type::signal, "signal"},
-        {Message::Type::method_call, "method_call"},
-        {Message::Type::method_return, "method_return"},
-        {Message::Type::error, "error"}
-    };
     Comma comma;
     std::stringstream ss;
     if (d->type != Message::Type::invalid)
-        ss << "type='" << lut.at(d->type) << "'" << comma;
+        ss << "type='" << d->type << "'" << comma;
     if (!d->sender.empty())
         ss << comma << "sender='" << d->sender << "'" << comma;
     if (!d->interface.empty())

=== modified file 'src/core/dbus/message.cpp'
--- src/core/dbus/message.cpp	2015-07-21 18:30:23 +0000
+++ src/core/dbus/message.cpp	2016-08-01 20:07:50 +0000
@@ -652,5 +652,24 @@
 {
     return std::shared_ptr<Message>(new Message(d->clone()));
 }
+
+std::ostream& operator<<(std::ostream& out, Message::Type type)
+{
+    switch (type)
+    {
+    case Message::Type::error:
+        return out << "error";
+    case Message::Type::invalid:
+        return out << "invalid";
+    case Message::Type::method_call:
+        return out << "method_call";
+    case Message::Type::method_return:
+        return out << "method_return";
+    case Message::Type::signal:
+        return out << "signal";
+    }
+
+    return out;
+}
 }
 }

=== modified file 'src/core/dbus/service.cpp'
--- src/core/dbus/service.cpp	2014-06-30 04:57:08 +0000
+++ src/core/dbus/service.cpp	2016-08-01 20:07:50 +0000
@@ -79,7 +79,7 @@
 
 void Service::remove_match(const MatchRule& rule)
 {
-    connection->remove_match(rule);
+    connection->remove_match(rule.sender(name));
 }
 
 Service::Service(const Bus::Ptr& connection, const std::string& name)

=== modified file 'tests/message_test.cpp'
--- tests/message_test.cpp	2014-01-10 07:34:59 +0000
+++ tests/message_test.cpp	2016-08-01 20:07:50 +0000
@@ -175,3 +175,23 @@
         }
     }
 }
+
+namespace
+{
+class MessageType : public testing::TestWithParam<std::pair<core::dbus::Message::Type, std::string>>
+{
+};
+}
+
+TEST_P(MessageType, IsPrintedCorrectly)
+{
+    std::stringstream ss; ss << GetParam().first;
+    EXPECT_EQ(GetParam().second, ss.str());
+}
+
+INSTANTIATE_TEST_CASE_P(MessageType, MessageType, ::testing::Values(
+                            std::make_pair(core::dbus::Message::Type::error, "error"),
+                            std::make_pair(core::dbus::Message::Type::invalid, "invalid"),
+                            std::make_pair(core::dbus::Message::Type::method_call, "method_call"),
+                            std::make_pair(core::dbus::Message::Type::method_return, "method_return"),
+                            std::make_pair(core::dbus::Message::Type::signal, "signal")));