[17283] Fix issues in Dynamic Network Interfaces (backport #5282) (backport #5304)

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

@@ -22,9 +22,12 @@
 #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
 
 #include <atomic>
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <string>
+#include <vector>
 
 #include <fastdds/rtps/attributes/RTPSParticipantAttributes.h>
 #include <fastdds/rtps/builtin/data/ReaderProxyData.h>
@@ -61,6 +64,7 @@ class RTPSWriter;
 class RTPSReader;
 class WriterHistory;
 class ReaderHistory;
+struct RTPSParticipantAllocationAttributes;
 class RTPSParticipantImpl;
 class RTPSParticipantListener;
 class BuiltinProtocols;
@@ -70,6 +74,7 @@ class ReaderProxyData;
 class WriterProxyData;
 class ParticipantProxyData;
 class ReaderListener;
+class PDPEndpoints;
 class PDPListener;
 class PDPServerListener;
 class ITopicPayloadPool;

src/cpp/rtps/participant/RTPSParticipantImpl.h

@@ -762,11 +762,17 @@ class RTPSParticipantImpl
      */
     void get_default_metatraffic_locators();
 
+    void get_default_metatraffic_locators(
+            RTPSParticipantAttributes& att);
+
     /**
      * Get default unicast locators when not provided by the user.
      */
     void get_default_unicast_locators();
 
+    void get_default_unicast_locators(
+            RTPSParticipantAttributes& att);
+
     bool match_local_endpoints_ = true;
 
     bool should_match_local_endpoints(

test/dds/communication/CMakeLists.txt

@@ -206,3 +206,7 @@ if(Python3_Interpreter_FOUND)
         endif()
     endforeach()
 endif()
+
+if(UNIX AND NOT(APPLE) AND NOT(QNXNTO) AND NOT(ANDROID))
+    add_subdirectory(dyn_network)
+endif()

test/dds/communication/PubSubMain.cpp

@@ -52,7 +52,7 @@ void publisher_run(
         publisher->wait_discovery(wait);
     }
 
-    publisher->run(samples, loops, interval);
+    publisher->run(samples, 0, loops, interval);
 }
 
 int main(
@@ -197,7 +197,7 @@ int main(
         DomainParticipantFactory::get_instance()->load_XML_profiles_file(xml_file);
     }
 
-    SubscriberModule subscriber(publishers, samples, fixed_type, zero_copy);
+    SubscriberModule subscriber(publishers, samples, fixed_type, zero_copy, false);
     PublisherModule publisher(exit_on_lost_liveliness, fixed_type, zero_copy);
 
     uint32_t result = 1;
@@ -208,7 +208,7 @@ int main(
 
         if (subscriber.init(seed, magic))
         {
-            result = subscriber.run(notexit, timeout) ? 0 : -1;
+            result = subscriber.run(notexit, 0, timeout) ? 0 : -1;
         }
 
         publisher_thread.join();

test/dds/communication/PublisherMain.cpp

@@ -29,9 +29,11 @@ using namespace eprosima::fastdds::dds;
  * --seed <int>
  * --wait <int>
  * --samples <int>
+ * --loops <int>
+ * --interval <int>
  * --magic <str>
  * --xmlfile <path>
- * --interval <int>
+ * --rescan <int>
  */
 
 int main(
@@ -46,7 +48,9 @@ int main(
     uint32_t wait = 0;
     char* xml_file = nullptr;
     uint32_t samples = 4;
+    uint32_t loops = 0;
     uint32_t interval = 250;
+    uint32_t rescan_interval_seconds = 0;
     std::string magic;
 
     while (arg_count < argc)
@@ -93,6 +97,16 @@ int main(
 
             samples = strtol(argv[arg_count], nullptr, 10);
         }
+        else if (strcmp(argv[arg_count], "--loops") == 0)
+        {
+            if (++arg_count >= argc)
+            {
+                std::cout << "--loops expects a parameter" << std::endl;
+                return -1;
+            }
+
+            loops = strtol(argv[arg_count], nullptr, 10);
+        }
         else if (strcmp(argv[arg_count], "--interval") == 0)
         {
             if (++arg_count >= argc)
@@ -123,6 +137,16 @@ int main(
 
             xml_file = argv[arg_count];
         }
+        else if (strcmp(argv[arg_count], "--rescan") == 0)
+        {
+            if (++arg_count >= argc)
+            {
+                std::cout << "--rescan expects a parameter" << std::endl;
+                return -1;
+            }
+
+            rescan_interval_seconds = strtol(argv[arg_count], nullptr, 10);
+        }
         else
         {
             std::cout << "Wrong argument " << argv[arg_count] << std::endl;
@@ -146,7 +170,7 @@ int main(
             publisher.wait_discovery(wait);
         }
 
-        publisher.run(samples, 0, interval);
+        publisher.run(samples, rescan_interval_seconds, loops, interval);
         return 0;
     }
 

test/dds/communication/PublisherModule.cpp

@@ -131,13 +131,30 @@ void PublisherModule::wait_discovery(
 
 void PublisherModule::run(
         uint32_t samples,
+        const uint32_t rescan_interval,
         const uint32_t loops,
         uint32_t interval)
 {
     uint32_t current_loop = 0;
     uint16_t index = 1;
     void* sample = nullptr;
 
+    std::thread net_rescan_thread([this, rescan_interval]()
+            {
+                if (rescan_interval > 0)
+                {
+                    auto interval = std::chrono::seconds(rescan_interval);
+                    while (run_)
+                    {
+                        std::this_thread::sleep_for(interval);
+                        if (run_)
+                        {
+                            participant_->set_qos(participant_->get_qos());
+                        }
+                    }
+                }
+            });
+
     while (run_ && (loops == 0 || loops > current_loop))
     {
         if (zero_copy_)
@@ -184,6 +201,9 @@ void PublisherModule::run(
 
         std::this_thread::sleep_for(std::chrono::milliseconds(interval));
     }
+
+    run_ = false;
+    net_rescan_thread.join();
 }
 
 void PublisherModule::on_publication_matched(

test/dds/communication/PublisherModule.hpp

@@ -19,6 +19,11 @@
 #ifndef TEST_DDS_COMMUNICATION_PUBLISHERMODULE_HPP
 #define TEST_DDS_COMMUNICATION_PUBLISHERMODULE_HPP
 
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+
 #include <fastdds/dds/domain/DomainParticipant.hpp>
 #include <fastdds/dds/domain/DomainParticipantListener.hpp>
 #include <fastdds/dds/publisher/PublisherListener.hpp>
@@ -27,9 +32,6 @@
 #include "types/FixedSizedPubSubTypes.h"
 #include "types/HelloWorldPubSubTypes.h"
 
-#include <mutex>
-#include <condition_variable>
-
 namespace eprosima {
 namespace fastdds {
 namespace dds {
@@ -41,8 +43,8 @@ class PublisherModule
 
     PublisherModule(
             bool exit_on_lost_liveliness,
-            bool fixed_type = false,
-            bool zero_copy = false)
+            bool fixed_type,
+            bool zero_copy)
         : exit_on_lost_liveliness_(exit_on_lost_liveliness)
         , fixed_type_(zero_copy || fixed_type) // If zero copy active, fixed type is required
         , zero_copy_(zero_copy)
@@ -80,8 +82,9 @@ class PublisherModule
 
     void run(
             uint32_t samples,
-            uint32_t loops = 0,
-            uint32_t interval = 250);
+            const uint32_t rescan_interval,
+            uint32_t loops,
+            uint32_t interval);
 
 private:
 
@@ -93,7 +96,7 @@ class PublisherModule
     bool exit_on_lost_liveliness_ = false;
     bool fixed_type_ = false;
     bool zero_copy_ = false;
-    bool run_ = true;
+    std::atomic_bool run_{true};
     DomainParticipant* participant_ = nullptr;
     TypeSupport type_;
     Publisher* publisher_ = nullptr;

test/dds/communication/SubscriberMain.cpp

@@ -26,13 +26,14 @@ using namespace eprosima::fastdds::dds;
  * --notexit
  * --fixed_type
  * --zero_copy
+ * --succeed_on_timeout
  * --seed <int>
  * --samples <int>
  * --magic <str>
+ * --timeout <int>
  * --xmlfile <path>
  * --publishers <int>
- * --succeed_on_timeout
- * --timeout <int>
+ * --rescan <int>
  */
 
 int main(
@@ -48,6 +49,7 @@ int main(
     uint32_t samples = 4;
     uint32_t publishers = 1;
     uint32_t timeout = 86400000; // 24 h in ms
+    uint32_t rescan_interval_seconds = 0;
     char* xml_file = nullptr;
     std::string magic;
 
@@ -129,6 +131,16 @@ int main(
 
             publishers = strtol(argv[arg_count], nullptr, 10);
         }
+        else if (strcmp(argv[arg_count], "--rescan") == 0)
+        {
+            if (++arg_count >= argc)
+            {
+                std::cout << "--rescan expects a parameter" << std::endl;
+                return -1;
+            }
+
+            rescan_interval_seconds = strtol(argv[arg_count], nullptr, 10);
+        }
         else
         {
             std::cout << "Wrong argument " << argv[arg_count] << std::endl;
@@ -147,7 +159,7 @@ int main(
 
     if (subscriber.init(seed, magic))
     {
-        return subscriber.run(notexit, timeout) ? 0 : -1;
+        return subscriber.run(notexit, rescan_interval_seconds, timeout) ? 0 : -1;
     }
 
     return -1;

test/dds/communication/SubscriberModule.cpp

@@ -130,17 +130,35 @@ bool SubscriberModule::init(
 
 bool SubscriberModule::run(
         bool notexit,
+        const uint32_t rescan_interval,
         uint32_t timeout)
 {
-    return run_for(notexit, std::chrono::milliseconds(timeout));
+    return run_for(notexit, rescan_interval, std::chrono::milliseconds(timeout));
 }
 
 bool SubscriberModule::run_for(
         bool notexit,
+        const uint32_t rescan_interval,
         const std::chrono::milliseconds& timeout)
 {
     bool returned_value = false;
 
+    std::thread net_rescan_thread([this, rescan_interval]()
+            {
+                if (rescan_interval > 0)
+                {
+                    auto interval = std::chrono::seconds(rescan_interval);
+                    while (run_)
+                    {
+                        std::this_thread::sleep_for(interval);
+                        if (run_)
+                        {
+                            participant_->set_qos(participant_->get_qos());
+                        }
+                    }
+                }
+            });
+
     while (notexit && run_)
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(250));
@@ -152,7 +170,7 @@ bool SubscriberModule::run_for(
         std::unique_lock<std::mutex> lock(mutex_);
         returned_value = cv_.wait_for(lock, timeout, [&]
                         {
-                            if (succeeed_on_timeout_ && (std::chrono::steady_clock::now() - t0) > timeout)
+                            if (succeed_on_timeout_ && (std::chrono::steady_clock::now() - t0) > timeout)
                             {
                                 return true;
                             }
@@ -190,6 +208,9 @@ bool SubscriberModule::run_for(
         returned_value = false;
     }
 
+    run_ = false;
+    net_rescan_thread.join();
+
     return returned_value;
 }