Extend DISCOVERY_TOPIC to include physical information [14006]

include/fastdds/dds/core/policy/ParameterTypes.hpp

@@ -1032,6 +1032,27 @@ const std::string parameter_property_ds_version = "DS_VERSION";
  */
 const std::string parameter_property_current_ds_version = "2.0";
 
+/**
+ * Parameter property value for Host physical data
+ *
+ * @ingroup PARAMETER_MODULE
+ */
+const char* const parameter_policy_physical_data_host = "fastdds.physical_data.host";
+
+/**
+ * Parameter property value for User physical data
+ *
+ * @ingroup PARAMETER_MODULE
+ */
+const char* const parameter_policy_physical_data_user = "fastdds.physical_data.user";
+
+/**
+ * Parameter property value for Process physical data
+ *
+ * @ingroup PARAMETER_MODULE
+ */
+const char* const parameter_policy_physical_data_process = "fastdds.physical_data.process";
+
 /**
  * @ingroup PARAMETER_MODULE
  */

include/fastdds/dds/domain/qos/DomainParticipantQos.hpp

@@ -20,6 +20,8 @@
 #ifndef _FASTDDS_PARTICIPANTQOS_HPP_
 #define _FASTDDS_PARTICIPANTQOS_HPP_
 
+#include <string>
+
 #include <fastrtps/fastrtps_dll.h>
 #include <fastdds/dds/core/policy/QosPolicies.hpp>
 #include <fastdds/rtps/flowcontrol/FlowControllerDescriptor.hpp>
@@ -50,6 +52,16 @@ class DomainParticipantQos
      */
     RTPS_DllAPI DomainParticipantQos()
     {
+#ifdef FASTDDS_STATISTICS
+        /*
+         * In the case of Statistics, the following properties are set with an empty value. This is because if these
+         * properties are set and empty during the enabling of the DomainParticipant, they are fill with the default
+         * mechanism
+         */
+        properties_.properties().emplace_back(parameter_policy_physical_data_host, "");
+        properties_.properties().emplace_back(parameter_policy_physical_data_user, "");
+        properties_.properties().emplace_back(parameter_policy_physical_data_process, "");
+#endif // ifdef FASTDDS_STATISTICS
     }
 
     /**

include/fastdds/rtps/builtin/discovery/participant/PDP.h

@@ -410,12 +410,14 @@ class PDP
      *
      * @param participant_guid GUID of the participant for which to create the proxy object.
      * @param with_lease_duration indicates whether lease duration event should be created.
+     * @param participant_proxy_data The participant proxy data from which the copy is made (if provided)
      *
      * @return pointer to the currently inserted entry, nullptr if allocation limits were reached.
      */
     ParticipantProxyData* add_participant_proxy_data(
             const GUID_t& participant_guid,
-            bool with_lease_duration);
+            bool with_lease_duration,
+            const ParticipantProxyData* participant_proxy_data = nullptr);
 
     /**
      * Gets the key of a participant proxy data.

include/fastdds/statistics/types.idl

@@ -65,6 +65,9 @@ struct DiscoveryTime
     @Key detail::GUID_s local_participant_guid;
     @Key detail::GUID_s remote_entity_guid;
     unsigned long long time;
+    string host;
+    string user;
+    string process;
 };
 
 struct EntityCount

src/cpp/fastdds/domain/DomainParticipantFactory.cpp

@@ -48,13 +48,26 @@ namespace eprosima {
 namespace fastdds {
 namespace dds {
 
+/**
+ * @brief Fill DomainParticipantQos from a given attributes RTPSParticipantAttributes object
+ *
+ * For the case of the non-binary properties, instead of the RTPSParticipantAttributes overriding the
+ * property list in the DomainParticipantQos, a merge is performed in the following manner:
+ *
+ * - If any property from the RTPSParticipantAttributes is not in the DomainParticipantQos, then it is appended
+ *   to the DomainParticipantQos.
+ * - If any property from the RTPSParticipantAttributes property is also in the DomainParticipantQos, then the
+ *   value in the DomainParticipantQos is overridden with that of the RTPSParticipantAttributes.
+ *
+ * @param[in, out] qos The DomainParticipantQos to set
+ * @param[in] attr The RTPSParticipantAttributes from which the @c qos is set.
+ */
 static void set_qos_from_attributes(
         DomainParticipantQos& qos,
         const eprosima::fastrtps::rtps::RTPSParticipantAttributes& attr)
 {
     qos.user_data().setValue(attr.userData);
     qos.allocation() = attr.allocation;
-    qos.properties() = attr.properties;
     qos.wire_protocol().prefix = attr.prefix;
     qos.wire_protocol().participant_id = attr.participantID;
     qos.wire_protocol().builtin = attr.builtin;
@@ -68,6 +81,22 @@ static void set_qos_from_attributes(
     qos.transport().listen_socket_buffer_size = attr.listenSocketBufferSize;
     qos.name() = attr.getName();
     qos.flow_controllers() = attr.flow_controllers;
+
+    // Merge attributes and qos properties
+    for (auto property : attr.properties.properties())
+    {
+        std::string* property_value = fastrtps::rtps::PropertyPolicyHelper::find_property(
+            qos.properties(), property.name());
+        if (nullptr == property_value)
+        {
+            qos.properties().properties().emplace_back(property);
+        }
+        else
+        {
+            *property_value = property.value();
+        }
+    }
+    qos.properties().binary_properties() = attr.properties.binary_properties();
 }
 
 DomainParticipantFactory::DomainParticipantFactory()

src/cpp/fastdds/domain/DomainParticipantImpl.cpp

@@ -17,47 +17,48 @@
  *
  */
 
+#include <chrono>
+#include <string>
+
+#include <asio.hpp>
+
 #include <fastdds/domain/DomainParticipantImpl.hpp>
 
+#include <fastdds/core/policy/QosPolicyUtils.hpp>
 #include <fastdds/dds/builtin/typelookup/TypeLookupManager.hpp>
 #include <fastdds/dds/domain/DomainParticipant.hpp>
-#include <fastdds/dds/domain/DomainParticipantListener.hpp>
 #include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/domain/DomainParticipantListener.hpp>
 #include <fastdds/dds/log/Log.hpp>
 #include <fastdds/dds/publisher/DataWriter.hpp>
 #include <fastdds/dds/publisher/Publisher.hpp>
 #include <fastdds/dds/subscriber/DataReader.hpp>
 #include <fastdds/dds/subscriber/Subscriber.hpp>
 #include <fastdds/dds/topic/IContentFilterFactory.hpp>
 #include <fastdds/dds/topic/TypeSupport.hpp>
-
-#include <fastdds/rtps/RTPSDomain.h>
+#include <fastdds/publisher/PublisherImpl.hpp>
+#include <fastdds/rtps/attributes/PropertyPolicy.h>
 #include <fastdds/rtps/attributes/RTPSParticipantAttributes.h>
 #include <fastdds/rtps/builtin/liveliness/WLP.h>
 #include <fastdds/rtps/participant/ParticipantDiscoveryInfo.h>
 #include <fastdds/rtps/participant/RTPSParticipant.h>
 #include <fastdds/rtps/reader/ReaderDiscoveryInfo.h>
+#include <fastdds/rtps/RTPSDomain.h>
 #include <fastdds/rtps/writer/WriterDiscoveryInfo.h>
-
 #include <fastrtps/attributes/PublisherAttributes.h>
 #include <fastrtps/attributes/SubscriberAttributes.h>
-
-#include <fastrtps/types/DynamicTypeBuilderFactory.h>
 #include <fastrtps/types/DynamicPubSubType.h>
 #include <fastrtps/types/DynamicType.h>
+#include <fastrtps/types/DynamicTypeBuilderFactory.h>
 #include <fastrtps/types/DynamicTypeMember.h>
 #include <fastrtps/types/TypeObjectFactory.h>
-
 #include <fastrtps/xmlparser/XMLProfileManager.h>
 
-#include <fastdds/publisher/PublisherImpl.hpp>
 #include <fastdds/subscriber/SubscriberImpl.hpp>
-#include <fastdds/topic/TopicImpl.hpp>
 #include <fastdds/topic/ContentFilteredTopicImpl.hpp>
-
+#include <fastdds/topic/TopicImpl.hpp>
 #include <rtps/RTPSDomainImpl.hpp>
-
-#include <chrono>
+#include <utils/SystemInfo.hpp>
 
 namespace eprosima {
 namespace fastdds {
@@ -166,6 +167,32 @@ DomainParticipantImpl::DomainParticipantImpl(
     // Pre calculate participant id and generated guid
     participant_id_ = qos_.wire_protocol().participant_id;
     eprosima::fastrtps::rtps::RTPSDomainImpl::create_participant_guid(participant_id_, guid_);
+
+    /* Fill physical data properties if they are found and empty */
+    std::string* property_value = fastrtps::rtps::PropertyPolicyHelper::find_property(
+        qos_.properties(), parameter_policy_physical_data_host);
+    if (nullptr != property_value && property_value->empty())
+    {
+        property_value->assign(asio::ip::host_name() + ":" + std::to_string(utils::default_domain_id()));
+    }
+
+    property_value = fastrtps::rtps::PropertyPolicyHelper::find_property(
+        qos_.properties(), parameter_policy_physical_data_user);
+    if (nullptr != property_value && property_value->empty())
+    {
+        std::string username = "unknown";
+        if (ReturnCode_t::RETCODE_OK == SystemInfo::get_username(username))
+        {
+            property_value->assign(username);
+        }
+    }
+
+    property_value = fastrtps::rtps::PropertyPolicyHelper::find_property(
+        qos_.properties(), parameter_policy_physical_data_process);
+    if (nullptr != property_value && property_value->empty())
+    {
+        property_value->assign(std::to_string(SystemInfo::instance().process_id()));
+    }
 }
 
 void DomainParticipantImpl::disable()

src/cpp/rtps/builtin/discovery/participant/PDP.cpp

@@ -178,7 +178,8 @@ PDP::~PDP()
 
 ParticipantProxyData* PDP::add_participant_proxy_data(
         const GUID_t& participant_guid,
-        bool with_lease_duration)
+        bool with_lease_duration,
+        const ParticipantProxyData* participant_proxy_data)
 {
     ParticipantProxyData* ret_val = nullptr;
 
@@ -218,11 +219,15 @@ ParticipantProxyData* PDP::add_participant_proxy_data(
     // Add returned entry to the collection
     ret_val->should_check_lease_duration = with_lease_duration;
     ret_val->m_guid = participant_guid;
+    if (nullptr != participant_proxy_data)
+    {
+        ret_val->copy(*participant_proxy_data);
+        ret_val->isAlive = true;
+        // Notify discovery of remote participant
+        getRTPSParticipant()->on_entity_discovery(participant_guid, ret_val->m_properties);
+    }
     participant_proxies_.push_back(ret_val);
 
-    // notify statistics module
-    getRTPSParticipant()->on_entity_discovery(participant_guid);
-
     return ret_val;
 }
 
@@ -355,6 +360,22 @@ void PDP::initializeParticipantProxyData(
     participant_type << mp_RTPSParticipant->getAttributes().builtin.discovery_config.discoveryProtocol;
     auto ptype = participant_type.str();
     participant_data->m_properties.push_back(fastdds::dds::parameter_property_participant_type, ptype);
+
+    /* Add physical properties if present */
+    std::vector<std::string> physical_property_names = {
+        fastdds::dds::parameter_policy_physical_data_host,
+        fastdds::dds::parameter_policy_physical_data_user,
+        fastdds::dds::parameter_policy_physical_data_process
+    };
+    for (auto physical_property_name : physical_property_names)
+    {
+        std::string* physical_property = PropertyPolicyHelper::find_property(
+            mp_RTPSParticipant->getAttributes().properties, physical_property_name);
+        if (nullptr != physical_property)
+        {
+            participant_data->m_properties.push_back(physical_property_name, *physical_property);
+        }
+    }
 }
 
 bool PDP::initPDP(
@@ -373,7 +394,7 @@ bool PDP::initPDP(
     mp_builtin->updateMetatrafficLocators(this->mp_PDPReader->getAttributes().unicastLocatorList);
 
     mp_mutex->lock();
-    ParticipantProxyData* pdata = add_participant_proxy_data(mp_RTPSParticipant->getGuid(), false);
+    ParticipantProxyData* pdata = add_participant_proxy_data(mp_RTPSParticipant->getGuid(), false, nullptr);
     mp_mutex->unlock();
 
     if (pdata == nullptr)
@@ -410,6 +431,9 @@ bool PDP::enable()
     set_initial_announcement_interval();
 
     enable_  = true;
+    // Notify "self-discovery"
+    getRTPSParticipant()->on_entity_discovery(mp_RTPSParticipant->getGuid(),
+            get_participant_proxy_data(mp_RTPSParticipant->getGuid().guidPrefix)->m_properties);
 
     return mp_RTPSParticipant->enableReader(mp_PDPReader);
 }
@@ -713,7 +737,7 @@ ReaderProxyData* PDP::addReaderProxyData(
     ReaderProxyData* ret_val = nullptr;
 
     // notify statistics module
-    getRTPSParticipant()->on_entity_discovery(reader_guid);
+    getRTPSParticipant()->on_entity_discovery(reader_guid, ParameterPropertyList_t());
 
     std::lock_guard<std::recursive_mutex> guardPDP(*this->mp_mutex);
 
@@ -808,7 +832,7 @@ WriterProxyData* PDP::addWriterProxyData(
     WriterProxyData* ret_val = nullptr;
 
     // notify statistics module
-    getRTPSParticipant()->on_entity_discovery(writer_guid);
+    getRTPSParticipant()->on_entity_discovery(writer_guid, ParameterPropertyList_t());
 
     std::lock_guard<std::recursive_mutex> guardPDP(*this->mp_mutex);
 

src/cpp/rtps/builtin/discovery/participant/PDPClient.cpp

@@ -162,12 +162,9 @@ ParticipantProxyData* PDPClient::createParticipantProxyData(
         }
     }
 
-    ParticipantProxyData* pdata = add_participant_proxy_data(participant_data.m_guid, is_server);
+    ParticipantProxyData* pdata = add_participant_proxy_data(participant_data.m_guid, is_server, &participant_data);
     if (pdata != nullptr)
     {
-        pdata->copy(participant_data);
-        pdata->isAlive = true;
-
         // Clients only assert its server lifeliness, other clients liveliness is provided
         // through server's PDP discovery data
         if (is_server)

src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp

@@ -206,11 +206,9 @@ ParticipantProxyData* PDPServer::createParticipantProxyData(
         }
     }
 
-    ParticipantProxyData* pdata = add_participant_proxy_data(participant_data.m_guid, do_lease);
+    ParticipantProxyData* pdata = add_participant_proxy_data(participant_data.m_guid, do_lease, &participant_data);
     if (pdata != nullptr)
     {
-        pdata->copy(participant_data);
-        pdata->isAlive = true;
         if (do_lease)
         {
             pdata->lease_duration_event->update_interval(pdata->m_leaseDuration);

src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp

@@ -189,11 +189,9 @@ ParticipantProxyData* PDPSimple::createParticipantProxyData(
         }
     }
 
-    ParticipantProxyData* pdata = add_participant_proxy_data(participant_data.m_guid, true);
+    ParticipantProxyData* pdata = add_participant_proxy_data(participant_data.m_guid, true, &participant_data);
     if (pdata != nullptr)
     {
-        pdata->copy(participant_data);
-        pdata->isAlive = true;
         pdata->lease_duration_event->update_interval(pdata->m_leaseDuration);
         pdata->lease_duration_event->restart_timer();
     }