[21793] Easy Mode Implementation

.github/workflows/reusable-ubuntu-ci.yml

@@ -463,7 +463,7 @@ jobs:
       - name: Install Python dependencies
         uses: eProsima/eProsima-CI/ubuntu/install_python_packages@v0
         with:
-          packages: vcstool xmlschema
+          packages: vcstool xmlschema psutil
 
       - name: Setup CCache
         uses: eProsima/eProsima-CI/external/setup-ccache-action@v0
@@ -650,7 +650,7 @@ jobs:
       - name: Install Python dependencies
         uses: eProsima/eProsima-CI/ubuntu/install_python_packages@v0
         with:
-          packages: vcstool xmlschema xmltodict==0.13.0 jsondiff==2.0.0 pandas==1.5.2
+          packages: vcstool xmlschema xmltodict==0.13.0 jsondiff==2.0.0 pandas==1.5.2 psutil
 
       - name: Setup CCache
         uses: eProsima/eProsima-CI/external/setup-ccache-action@v0

CMakeLists.txt

@@ -603,7 +603,7 @@ option(INSTALL_TOOLS "Install tools" OFF)
 
 if(INSTALL_TOOLS)
   # Install tools
-  install(DIRECTORY ${PROJECT_SOURCE_DIR}/tools
+  install(DIRECTORY ${PROJECT_SOURCE_DIR}/tools/
       DESTINATION tools
       COMPONENT tools
       PATTERN "tools/CMakeLists.txt" EXCLUDE

include/fastdds/rtps/attributes/BuiltinTransports.hpp

@@ -104,14 +104,15 @@ inline bool operator ==(
  */
 enum class BuiltinTransports : uint16_t
 {
-    NONE = 0,      //< No transport will be instantiated
-    DEFAULT = 1,   //< Default value that will instantiate UDPv4 and SHM transports
+    NONE = 0,          //< No transport will be instantiated
+    DEFAULT = 1,       //< Default value that will instantiate UDPv4 and SHM transports
     DEFAULTv6 = 2,     //< Instantiate UDPv6 and SHM transports
     SHM = 3,           //< Instantiate SHM transport only
     UDPv4 = 4,         //< Instantiate UDPv4 transport only
     UDPv6 = 5,         //< Instantiate UDPv6 transport only
     LARGE_DATA = 6,    //< Instantiate SHM, UDPv4 and TCPv4 transports, but UDPv4 is only used for bootstrapping discovery
-    LARGE_DATAv6 = 7   //< Instantiate SHM, UDPv6 and TCPv6 transports, but UDPv6 is only used for bootstrapping discovery
+    LARGE_DATAv6 = 7,  //< Instantiate SHM, UDPv6 and TCPv6 transports, but UDPv6 is only used for bootstrapping discovery
+    P2P = 8            //< Instantiate SHM, UDPv4 (unicast) and TCPv4 transports, shall only be used along with ROS2_EASY_MODE=<ip>
 };
 
 inline std::ostream& operator <<(
@@ -144,6 +145,9 @@ inline std::ostream& operator <<(
         case BuiltinTransports::LARGE_DATAv6:
             output << "LARGE_DATAv6";
             break;
+        case BuiltinTransports::P2P:
+            output << "P2P";
+            break;
         default:
             output << "UNKNOWN";
             break;

include/fastdds/rtps/common/PortParameters.hpp

@@ -42,6 +42,7 @@ class PortParameters
         , offsetd1(10)
         , offsetd2(1)
         , offsetd3(11)
+        , offsetd4(2)
     {
     }
 
@@ -58,7 +59,8 @@ class PortParameters
                (this->offsetd0 == b.offsetd0) &&
                (this->offsetd1 == b.offsetd1) &&
                (this->offsetd2 == b.offsetd2) &&
-               (this->offsetd3 == b.offsetd3);
+               (this->offsetd3 == b.offsetd3) &&
+               (this->offsetd4 == b.offsetd4);
     }
 
     /**
@@ -111,6 +113,30 @@ class PortParameters
         return port;
     }
 
+    /**
+     * Get a discovery server port based on the domain ID.
+     *
+     * @param domainId Domain ID.
+     * @return Discovery server port
+     */
+    inline uint16_t get_discovery_server_port(
+            uint32_t domainId) const
+    {
+        uint32_t port = portBase + domainIDGain * domainId + offsetd4;
+
+        if (port > 65535)
+        {
+            EPROSIMA_LOG_ERROR(RTPS, "Calculated port number is too high. Probably the domainId is over 232 "
+                    << "or portBase is too high.");
+            std::cout << "Calculated port number is too high. Probably the domainId is over 232 "
+                      << "or portBase is too high." << std::endl;
+            std::cout.flush();
+            exit(EXIT_FAILURE);
+        }
+
+        return static_cast<uint16_t>(port);
+    }
+
 public:
 
     //!PortBase, default value 7400.
@@ -127,6 +153,8 @@ class PortParameters
     uint16_t offsetd2;
     //!Offset d3, default value 11.
     uint16_t offsetd3;
+    //!Offset d4, default value 2.
+    uint16_t offsetd4;
 };
 
 } // namespace rtps

resources/xsd/fastdds_profiles.xsd

@@ -816,7 +816,8 @@
         ├ offsetd0          [uint16],
         ├ offsetd1          [uint16],
         ├ offsetd2          [uint16],
-        └ offsetd3          [uint16] -->
+        ├ offsetd3          [uint16],
+        └ offsetd4          [uint16] -->
     <xs:complexType name="portType">
         <xs:all>
             <xs:element name="portBase" type="uint16" minOccurs="0" maxOccurs="1"/>
@@ -826,6 +827,7 @@
             <xs:element name="offsetd1" type="uint16" minOccurs="0" maxOccurs="1"/>
             <xs:element name="offsetd2" type="uint16" minOccurs="0" maxOccurs="1"/>
             <xs:element name="offsetd3" type="uint16" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="offsetd4" type="uint16" minOccurs="0" maxOccurs="1"/>
         </xs:all>
     </xs:complexType>
 
@@ -1961,6 +1963,7 @@
             <xs:enumeration value="UDPv6" />
             <xs:enumeration value="LARGE_DATA" />
             <xs:enumeration value="LARGE_DATAv6" />
+            <xs:enumeration value="P2P" />
         </xs:restriction>
     </xs:simpleType>
 

src/cpp/rtps/RTPSDomain.cpp

@@ -50,6 +50,7 @@
 #include <rtps/transport/UDPv6Transport.h>
 #include <rtps/writer/BaseWriter.hpp>
 #include <utils/Host.hpp>
+#include <utils/SystemCommandBuilder.hpp>
 #include <utils/SystemInfo.hpp>
 #include <xmlparser/XMLProfileManager.h>
 
@@ -518,59 +519,128 @@ RTPSParticipant* RTPSDomainImpl::clientServerEnvironmentCreationOverride(
     // Is up to the caller guarantee the att argument is not modified during the call
     RTPSParticipantAttributes client_att(att);
 
-    // Retrieve the info from the environment variable
-    LocatorList_t& server_list = client_att.builtin.discovery_config.m_DiscoveryServers;
-    if (load_environment_server_info(server_list) && server_list.empty())
-    {
-        // It's not an error, the environment variable may not be set. Any issue with environment
-        // variable syntax is EPROSIMA_LOG_ERROR already
-        return nullptr;
-    }
+    // Check whether we need to initialize in easy mode
+    const std::string& easy_mode_env_value = easy_mode_env();
 
-    // Check if some address requires the UDPv6, TCPv4 or TCPv6 transport
-    if (server_list.has_kind<LOCATOR_KIND_UDPv6>() &&
-            !has_user_transport<fastdds::rtps::UDPv6TransportDescriptor>(client_att))
+    if (easy_mode_env_value.empty())
     {
-        // Extend builtin transports with the UDPv6 transport
-        auto descriptor = std::make_shared<fastdds::rtps::UDPv6TransportDescriptor>();
-        descriptor->sendBufferSize = client_att.sendSocketBufferSize;
-        descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
-        client_att.userTransports.push_back(std::move(descriptor));
-    }
-    if (server_list.has_kind<LOCATOR_KIND_TCPv4>() &&
-            !has_user_transport<fastdds::rtps::TCPv4TransportDescriptor>(client_att))
-    {
-        // Extend builtin transports with the TCPv4 transport
-        auto descriptor = std::make_shared<fastdds::rtps::TCPv4TransportDescriptor>();
-        // Add automatic port
-        descriptor->add_listener_port(0);
-        descriptor->sendBufferSize = client_att.sendSocketBufferSize;
-        descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
-        client_att.userTransports.push_back(std::move(descriptor));
-    }
-    if (server_list.has_kind<LOCATOR_KIND_TCPv6>() &&
-            !has_user_transport<fastdds::rtps::TCPv6TransportDescriptor>(client_att))
-    {
-        // Extend builtin transports with the TCPv6 transport
-        auto descriptor = std::make_shared<fastdds::rtps::TCPv6TransportDescriptor>();
-        // Add automatic port
-        descriptor->add_listener_port(0);
-        descriptor->sendBufferSize = client_att.sendSocketBufferSize;
-        descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
-        client_att.userTransports.push_back(std::move(descriptor));
-    }
+        // Retrieve the info from the environment variable
+        LocatorList_t& server_list = client_att.builtin.discovery_config.m_DiscoveryServers;
+        if (load_environment_server_info(server_list) && server_list.empty())
+        {
+            // It's not an error, the environment variable may not be set. Any issue with environment
+            // variable syntax is EPROSIMA_LOG_ERROR already
+            return nullptr;
+        }
 
-    EPROSIMA_LOG_INFO(DOMAIN, "Detected auto client-server environment variable."
-            << "Trying to create client with the default server setup: "
-            << client_att.builtin.discovery_config.m_DiscoveryServers);
+        // Check if some address requires the UDPv6, TCPv4 or TCPv6 transport
+        if (server_list.has_kind<LOCATOR_KIND_UDPv6>() &&
+                !has_user_transport<fastdds::rtps::UDPv6TransportDescriptor>(client_att))
+        {
+            // Extend builtin transports with the UDPv6 transport
+            auto descriptor = std::make_shared<fastdds::rtps::UDPv6TransportDescriptor>();
+            descriptor->sendBufferSize = client_att.sendSocketBufferSize;
+            descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
+            client_att.userTransports.push_back(std::move(descriptor));
+        }
+        if (server_list.has_kind<LOCATOR_KIND_TCPv4>() &&
+                !has_user_transport<fastdds::rtps::TCPv4TransportDescriptor>(client_att))
+        {
+            // Extend builtin transports with the TCPv4 transport
+            auto descriptor = std::make_shared<fastdds::rtps::TCPv4TransportDescriptor>();
+            // Add automatic port
+            descriptor->add_listener_port(0);
+            descriptor->sendBufferSize = client_att.sendSocketBufferSize;
+            descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
+            client_att.userTransports.push_back(std::move(descriptor));
+        }
+        if (server_list.has_kind<LOCATOR_KIND_TCPv6>() &&
+                !has_user_transport<fastdds::rtps::TCPv6TransportDescriptor>(client_att))
+        {
+            // Extend builtin transports with the TCPv6 transport
+            auto descriptor = std::make_shared<fastdds::rtps::TCPv6TransportDescriptor>();
+            // Add automatic port
+            descriptor->add_listener_port(0);
+            descriptor->sendBufferSize = client_att.sendSocketBufferSize;
+            descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
+            client_att.userTransports.push_back(std::move(descriptor));
+        }
+
+        EPROSIMA_LOG_INFO(DOMAIN, "Detected auto client-server environment variable."
+                << "Trying to create client with the default server setup: "
+                << client_att.builtin.discovery_config.m_DiscoveryServers);
 
-    client_att.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::CLIENT;
-    // RemoteServerAttributes already fill in above
+        client_att.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::CLIENT;
+        // RemoteServerAttributes already fill in above
 
-    // Check if the client must become a super client
-    if (ros_super_client_env())
+        // Check if the client must become a super client
+        if (ros_super_client_env())
+        {
+            client_att.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::SUPER_CLIENT;
+        }
+    }
+    else
     {
+        // SUPER_CLIENT
         client_att.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::SUPER_CLIENT;
+
+        // P2P transport. Similar to LARGE_DATA, but with UDPv4 unicast
+        client_att.useBuiltinTransports = false;
+        client_att.setup_transports(BuiltinTransports::P2P);
+
+        // Ignore initialpeers
+        client_att.builtin.initialPeersList = LocatorList();
+
+        eprosima::fastdds::rtps::PortParameters port_params;
+
+        auto domain_port = port_params.get_discovery_server_port(domain_id);
+
+        // Add user traffic TCP
+        eprosima::fastdds::rtps::Locator_t locator_tcp;
+        locator_tcp.kind = LOCATOR_KIND_TCPv4;
+
+        IPLocator::setPhysicalPort(locator_tcp, 0);
+        IPLocator::setLogicalPort(locator_tcp, 0);
+        // Initialize to the wan interface
+        IPLocator::setIPv4(locator_tcp, "0.0.0.0");
+
+        client_att.defaultUnicastLocatorList.push_back(locator_tcp);
+
+        // Add remote DS based on port
+        eprosima::fastdds::rtps::Locator_t locator_udp;
+        locator_udp.kind = LOCATOR_KIND_UDPv4;
+
+        locator_udp.port = domain_port;
+        IPLocator::setIPv4(locator_udp, 127, 0, 0, 1);
+
+        // Point to the well known DS port in the corresponding domain
+        client_att.builtin.discovery_config.m_DiscoveryServers.push_back(locator_udp);
+
+        SystemCommandBuilder sys_command;
+        int res = sys_command.executable(FAST_DDS_DEFAULT_CLI_SCRIPT_NAME)
+                        .verb(FAST_DDS_DEFAULT_CLI_DISCOVERY_VERB)
+                        .verb(FAST_DDS_DEFAULT_CLI_AUTO_VERB)
+                        .arg("-d")
+                        .value(std::to_string(domain_id))
+                        .value(easy_mode_env_value + ":" + std::to_string(domain_id))
+                        .build_and_call();
+#ifndef _WIN32
+        // Adecuate Python subprocess return
+        res = WEXITSTATUS(res);
+#endif // _WIN32
+
+        if (res != SystemCommandBuilder::SystemCommandResult::SUCCESS)
+        {
+            if (res == SystemCommandBuilder::SystemCommandResult::BAD_PARAM)
+            {
+                EPROSIMA_LOG_ERROR("DOMAIN", "ROS2_EASY_MODE IP connection conflicts with a previous one.");
+            }
+            else
+            {
+                EPROSIMA_LOG_ERROR(DOMAIN, "Auto discovery server client setup. Unable to spawn daemon.");
+            }
+            return nullptr;
+        }
     }
 
     RTPSParticipant* part = createParticipant(domain_id, enabled, client_att, listen);

src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp

@@ -301,6 +301,38 @@ static void setup_transports_large_datav6(
     }
 }
 
+static void setup_transports_p2p(
+        RTPSParticipantAttributes& att,
+        bool intraprocess_only,
+        const fastdds::rtps::BuiltinTransportsOptions& options)
+{
+    if (!intraprocess_only)
+    {
+        setup_large_data_shm_transport(att, options);
+
+        auto tcp_transport = create_tcpv4_transport(att, options);
+        att.userTransports.push_back(tcp_transport);
+
+        Locator_t tcp_loc;
+        tcp_loc.kind = LOCATOR_KIND_TCPv4;
+        IPLocator::setIPv4(tcp_loc, "0.0.0.0");
+        IPLocator::setPhysicalPort(tcp_loc, 0);
+        IPLocator::setLogicalPort(tcp_loc, 0);
+        att.defaultUnicastLocatorList.push_back(tcp_loc);
+    }
+
+    auto udp_descriptor = create_udpv4_transport(att, intraprocess_only, options);
+    att.userTransports.push_back(udp_descriptor);
+
+    if (!intraprocess_only)
+    {
+        Locator_t udp_locator;
+        udp_locator.kind = LOCATOR_KIND_UDPv4;
+        IPLocator::setIPv4(udp_locator, "127.0.0.1");
+        att.builtin.metatrafficUnicastLocatorList.push_back(udp_locator);
+    }
+}
+
 void RTPSParticipantAttributes::setup_transports(
         fastdds::rtps::BuiltinTransports transports,
         const fastdds::rtps::BuiltinTransportsOptions& options)
@@ -309,7 +341,8 @@ void RTPSParticipantAttributes::setup_transports(
             (transports != fastdds::rtps::BuiltinTransports::NONE &&
             transports != fastdds::rtps::BuiltinTransports::SHM &&
             transports != fastdds::rtps::BuiltinTransports::LARGE_DATA &&
-            transports != fastdds::rtps::BuiltinTransports::LARGE_DATAv6))
+            transports != fastdds::rtps::BuiltinTransports::LARGE_DATAv6 &&
+            transports != fastdds::rtps::BuiltinTransports::P2P))
     {
         EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT,
                 "Max message size of UDP cannot be greater than " << std::to_string(
@@ -347,17 +380,23 @@ void RTPSParticipantAttributes::setup_transports(
             break;
 
         case fastdds::rtps::BuiltinTransports::LARGE_DATA:
-            // This parameter will allow allow the initialization of UDP transports with maxMessageSize > 65500 KB (s_maximumMessageSize)
+            // This parameter will allow the initialization of UDP transports with maxMessageSize > 65500 KB (s_maximumMessageSize)
             max_msg_size_no_frag = options.maxMessageSize;
             setup_transports_large_data(*this, intraprocess_only, options);
             break;
 
         case fastdds::rtps::BuiltinTransports::LARGE_DATAv6:
-            // This parameter will allow allow the initialization of UDP transports with maxMessageSize > 65500 KB (s_maximumMessageSize)
+            // This parameter will allow the initialization of UDP transports with maxMessageSize > 65500 KB (s_maximumMessageSize)
             max_msg_size_no_frag = options.maxMessageSize;
             setup_transports_large_datav6(*this, intraprocess_only, options);
             break;
 
+        case fastdds::rtps::BuiltinTransports::P2P:
+            // This parameter will allow the initialization of UDP transports with maxMessageSize > 65500 KB (s_maximumMessageSize)
+            max_msg_size_no_frag = options.maxMessageSize;
+            setup_transports_p2p(*this, intraprocess_only, options);
+            break;
+
         default:
             EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT,
                     "Setup for '" << transports << "' transport configuration not yet supported.");