RTPSParticipantAttributes.hpp

// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef FASTDDS_RTPS_ATTRIBUTES__RTPSPARTICIPANTATTRIBUTES_HPP
#define FASTDDS_RTPS_ATTRIBUTES__RTPSPARTICIPANTATTRIBUTES_HPP
 
#include <memory>
#include <sstream>
 
#include <fastcdr/cdr/fixed_size_string.hpp>
 
#include <fastdds/rtps/attributes/BuiltinTransports.hpp>
#include <fastdds/rtps/attributes/ExternalLocators.hpp>
#include <fastdds/rtps/attributes/PropertyPolicy.hpp>
#include <fastdds/rtps/attributes/ResourceManagement.hpp>
#include <fastdds/rtps/attributes/RTPSParticipantAllocationAttributes.hpp>
#include <fastdds/rtps/attributes/ThreadSettings.hpp>
#include <fastdds/rtps/common/Locator.hpp>
#include <fastdds/rtps/common/PortParameters.hpp>
#include <fastdds/rtps/common/Time_t.hpp>
#include <fastdds/rtps/common/Types.hpp>
#include <fastdds/rtps/flowcontrol/FlowControllerDescriptor.hpp>
#include <fastdds/rtps/transport/network/NetmaskFilterKind.hpp>
#include <fastdds/rtps/transport/TransportInterface.hpp>
#include <fastdds/fastdds_dll.hpp>
 
namespace eprosima {
namespace fastdds {
namespace rtps {
 
struct ParticipantType
{
    static constexpr const char* SIMPLE = "SIMPLE";
    static constexpr const char* SERVER = "SERVER";
    static constexpr const char* CLIENT = "CLIENT";
    static constexpr const char* SUPER_CLIENT = "SUPER_CLIENT";
    static constexpr const char* BACKUP = "BACKUP";
    static constexpr const char* NONE = "NONE";
    static constexpr const char* EXTERNAL = "EXTERNAL";
    static constexpr const char* UNKNOWN = "UNKNOWN";
};
 
}  // namespace rtps
}  // namespace fastdds
 
namespace fastdds {
namespace rtps {
 
enum class DiscoveryProtocol
{
    NONE,
    SIMPLE,
    EXTERNAL,
    CLIENT, 
    SERVER, 
    BACKUP,  
    SUPER_CLIENT  
};
 
inline std::ostream& operator <<(
        std::ostream& output,
        const DiscoveryProtocol& discovery_protocol)
{
    switch (discovery_protocol)
    {
        case DiscoveryProtocol::NONE:
            output << fastdds::rtps::ParticipantType::NONE;
            break;
        case DiscoveryProtocol::SIMPLE:
            output << fastdds::rtps::ParticipantType::SIMPLE;
            break;
        case DiscoveryProtocol::EXTERNAL:
            output << fastdds::rtps::ParticipantType::EXTERNAL;
            break;
        case DiscoveryProtocol::CLIENT:
            output << fastdds::rtps::ParticipantType::CLIENT;
            break;
        case DiscoveryProtocol::SUPER_CLIENT:
            output << fastdds::rtps::ParticipantType::SUPER_CLIENT;
            break;
        case DiscoveryProtocol::SERVER:
            output << fastdds::rtps::ParticipantType::SERVER;
            break;
        case DiscoveryProtocol::BACKUP:
            output << fastdds::rtps::ParticipantType::BACKUP;
            break;
        default:
            output << fastdds::rtps::ParticipantType::UNKNOWN;
    }
    return output;
}
 
FASTDDS_EXPORTED_API bool get_server_client_default_guidPrefix(
        int id,
        fastdds::rtps::GuidPrefix_t& guid);
 
// Port used if the ros environment variable doesn't specify one
constexpr uint16_t DEFAULT_ROS2_SERVER_PORT = 11811;
// Port used by default for tcp transport
constexpr uint16_t DEFAULT_TCP_SERVER_PORT = 42100;
 
FASTDDS_TODO_BEFORE(4, 0, "Change it to uint8_t (implies also changing [de]serializations)");
enum ParticipantFilteringFlags : uint32_t
{
    NO_FILTER = 0,
    FILTER_DIFFERENT_HOST = 0x1,
    FILTER_DIFFERENT_PROCESS = 0x2,
    FILTER_SAME_PROCESS = 0x4
};
 
#define BUILTIN_DATA_MAX_SIZE 512
 
class PDP;
class BuiltinProtocols;
 
typedef struct PDPFactory
{
    // Pointer to the PDP creator
    PDP* (*CreatePDPInstance)(
            BuiltinProtocols*);
    // Pointer to the PDP destructor
    void (* ReleasePDPInstance)(
            PDP*);
 
    bool operator ==(
            const struct PDPFactory& e) const
    {
        return (CreatePDPInstance == e.CreatePDPInstance)
               && (ReleasePDPInstance == e.ReleasePDPInstance);
    }
 
} PDPFactory;
 
class SimpleEDPAttributes
{
public:
 
    bool use_PublicationWriterANDSubscriptionReader;
 
    bool use_PublicationReaderANDSubscriptionWriter;
 
#if HAVE_SECURITY
    bool enable_builtin_secure_publications_writer_and_subscriptions_reader;
 
    bool enable_builtin_secure_subscriptions_writer_and_publications_reader;
#endif // if HAVE_SECURITY
 
    SimpleEDPAttributes()
        : use_PublicationWriterANDSubscriptionReader(true)
        , use_PublicationReaderANDSubscriptionWriter(true)
#if HAVE_SECURITY
        , enable_builtin_secure_publications_writer_and_subscriptions_reader(true)
        , enable_builtin_secure_subscriptions_writer_and_publications_reader(true)
#endif // if HAVE_SECURITY
    {
    }
 
    bool operator ==(
            const SimpleEDPAttributes& b) const
    {
        return (this->use_PublicationWriterANDSubscriptionReader == b.use_PublicationWriterANDSubscriptionReader) &&
#if HAVE_SECURITY
               (this->enable_builtin_secure_publications_writer_and_subscriptions_reader ==
               b.enable_builtin_secure_publications_writer_and_subscriptions_reader) &&
               (this->enable_builtin_secure_subscriptions_writer_and_publications_reader ==
               b.enable_builtin_secure_subscriptions_writer_and_publications_reader) &&
#endif // if HAVE_SECURITY
               (this->use_PublicationReaderANDSubscriptionWriter == b.use_PublicationReaderANDSubscriptionWriter);
    }
 
};
 
struct InitialAnnouncementConfig
{
    uint32_t count = 5u;
 
    dds::Duration_t period = { 0, 100000000u };
 
    bool operator ==(
            const InitialAnnouncementConfig& b) const
    {
        return (count == b.count) && (period == b.period);
    }
 
};
 
class DiscoverySettings
{
public:
 
    DiscoveryProtocol discoveryProtocol = DiscoveryProtocol::SIMPLE;
 
    bool use_SIMPLE_EndpointDiscoveryProtocol = true;
 
    bool use_STATIC_EndpointDiscoveryProtocol = false;
 
    dds::Duration_t leaseDuration = { 20, 0 };
 
    dds::Duration_t leaseDuration_announcementperiod = { 3, 0 };
 
    InitialAnnouncementConfig initial_announcements;
 
    SimpleEDPAttributes m_simpleEDP;
 
    PDPFactory m_PDPfactory{};
    dds::Duration_t discoveryServer_client_syncperiod = { 0, 450 * 1000000}; // 450 milliseconds
 
    eprosima::fastdds::rtps::LocatorList m_DiscoveryServers;
 
    ParticipantFilteringFlags ignoreParticipantFlags = ParticipantFilteringFlags::NO_FILTER;
 
    DiscoverySettings() = default;
 
    bool operator ==(
            const DiscoverySettings& b) const
    {
        return (this->discoveryProtocol == b.discoveryProtocol) &&
               (this->use_SIMPLE_EndpointDiscoveryProtocol == b.use_SIMPLE_EndpointDiscoveryProtocol) &&
               (this->use_STATIC_EndpointDiscoveryProtocol == b.use_STATIC_EndpointDiscoveryProtocol) &&
               (this->discoveryServer_client_syncperiod == b.discoveryServer_client_syncperiod) &&
               (this->m_PDPfactory == b.m_PDPfactory) &&
               (this->leaseDuration == b.leaseDuration) &&
               (this->leaseDuration_announcementperiod == b.leaseDuration_announcementperiod) &&
               (this->initial_announcements == b.initial_announcements) &&
               (this->m_simpleEDP == b.m_simpleEDP) &&
               (this->static_edp_xml_config_ == b.static_edp_xml_config_) &&
               (this->m_DiscoveryServers == b.m_DiscoveryServers) &&
               (this->ignoreParticipantFlags == b.ignoreParticipantFlags);
    }
 
    void static_edp_xml_config(
            const char* str)
    {
        static_edp_xml_config_ = str;
    }
 
    const char* static_edp_xml_config() const
    {
        return static_edp_xml_config_.c_str();
    }
 
private:
 
    std::string static_edp_xml_config_ = "";
};
 
class BuiltinAttributes
{
public:
 
    DiscoverySettings discovery_config;
 
    bool use_WriterLivelinessProtocol = true;
 
    NetworkConfigSet_t network_configuration = 0;
 
    LocatorList_t metatrafficUnicastLocatorList;
 
    LocatorList_t metatrafficMulticastLocatorList;
 
    fastdds::rtps::ExternalLocators metatraffic_external_unicast_locators;
 
    LocatorList_t initialPeersList;
 
    MemoryManagementPolicy_t readerHistoryMemoryPolicy =
            MemoryManagementPolicy_t::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
 
    uint32_t readerPayloadSize = BUILTIN_DATA_MAX_SIZE;
 
    MemoryManagementPolicy_t writerHistoryMemoryPolicy =
            MemoryManagementPolicy_t::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
 
    uint32_t writerPayloadSize = BUILTIN_DATA_MAX_SIZE;
 
    uint32_t mutation_tries = 100u;
 
    bool avoid_builtin_multicast = true;
 
    std::string flow_controller_name = "";
 
    BuiltinAttributes() = default;
 
    virtual ~BuiltinAttributes() = default;
 
    bool operator ==(
            const BuiltinAttributes& b) const
    {
        return (this->discovery_config == b.discovery_config) &&
               (this->use_WriterLivelinessProtocol == b.use_WriterLivelinessProtocol) &&
               (this->network_configuration == b.network_configuration) &&
               (this->metatrafficUnicastLocatorList == b.metatrafficUnicastLocatorList) &&
               (this->metatrafficMulticastLocatorList == b.metatrafficMulticastLocatorList) &&
               (this->metatraffic_external_unicast_locators == b.metatraffic_external_unicast_locators) &&
               (this->initialPeersList == b.initialPeersList) &&
               (this->readerHistoryMemoryPolicy == b.readerHistoryMemoryPolicy) &&
               (this->readerPayloadSize == b.readerPayloadSize) &&
               (this->writerHistoryMemoryPolicy == b.writerHistoryMemoryPolicy) &&
               (this->writerPayloadSize == b.writerPayloadSize) &&
               (this->mutation_tries == b.mutation_tries) &&
               (this->flow_controller_name == b.flow_controller_name) &&
               (this->avoid_builtin_multicast == b.avoid_builtin_multicast);
    }
 
};
 
class RTPSParticipantAttributes
{
    using FlowControllerDescriptorList = std::vector<std::shared_ptr<fastdds::rtps::FlowControllerDescriptor>>;
 
public:
 
    RTPSParticipantAttributes() = default;
 
    virtual ~RTPSParticipantAttributes() = default;
 
    bool operator ==(
            const RTPSParticipantAttributes& b) const
    {
        return (this->name == b.name) &&
               (this->defaultUnicastLocatorList == b.defaultUnicastLocatorList) &&
               (this->defaultMulticastLocatorList == b.defaultMulticastLocatorList) &&
               (this->default_external_unicast_locators == b.default_external_unicast_locators) &&
               (this->ignore_non_matching_locators == b.ignore_non_matching_locators) &&
               (this->sendSocketBufferSize == b.sendSocketBufferSize) &&
               (this->listenSocketBufferSize == b.listenSocketBufferSize) &&
               (this->netmaskFilter == b.netmaskFilter) &&
               (this->builtin == b.builtin) &&
               (this->port == b.port) &&
               (this->userData == b.userData) &&
               (this->participantID == b.participantID) &&
               (this->easy_mode_ip == b.easy_mode_ip) &&
               (this->useBuiltinTransports == b.useBuiltinTransports) &&
               (this->properties == b.properties) &&
               (this->prefix == b.prefix) &&
               (this->flow_controllers == b.flow_controllers) &&
               (this->builtin_controllers_sender_thread == b.builtin_controllers_sender_thread) &&
               (this->timed_events_thread == b.timed_events_thread) &&
#if HAVE_SECURITY
               (this->security_log_thread == b.security_log_thread) &&
#endif // if HAVE_SECURITY
               (this->discovery_server_thread == b.discovery_server_thread) &&
               (this->typelookup_service_thread == b.typelookup_service_thread) &&
               (this->builtin_transports_reception_threads == b.builtin_transports_reception_threads);
 
    }
 
    FASTDDS_EXPORTED_API void setup_transports(
            fastdds::rtps::BuiltinTransports transports,
            const fastdds::rtps::BuiltinTransportsOptions& options = fastdds::rtps::BuiltinTransportsOptions());
 
    LocatorList_t defaultUnicastLocatorList;
 
    LocatorList_t defaultMulticastLocatorList;
 
    fastdds::rtps::ExternalLocators default_external_unicast_locators;
 
    bool ignore_non_matching_locators = false;
 
    uint32_t sendSocketBufferSize = 0;
 
    uint32_t listenSocketBufferSize = 0;
 
    fastdds::rtps::NetmaskFilterKind netmaskFilter = fastdds::rtps::NetmaskFilterKind::AUTO;
 
    GuidPrefix_t prefix;
 
    FASTDDS_EXPORTED_API inline bool ReadguidPrefix(
            const char* pfx)
    {
        return bool(std::istringstream(pfx) >> prefix);
    }
 
    BuiltinAttributes builtin;
 
    PortParameters port;
 
    std::vector<octet> userData;
 
    int32_t participantID = -1;
 
    std::string easy_mode_ip = "";
 
    std::vector<std::shared_ptr<fastdds::rtps::TransportDescriptorInterface>> userTransports;
 
    bool useBuiltinTransports = true;
 
    RTPSParticipantAllocationAttributes allocation;
 
    PropertyPolicy properties;
 
    inline void setName(
            const char* nam)
    {
        name = nam;
    }
 
    inline const char* getName() const
    {
        return name.c_str();
    }
 
    FlowControllerDescriptorList flow_controllers;
 
    fastdds::rtps::ThreadSettings builtin_controllers_sender_thread;
 
    fastdds::rtps::ThreadSettings timed_events_thread;
 
    fastdds::rtps::ThreadSettings discovery_server_thread;
 
    fastdds::rtps::ThreadSettings typelookup_service_thread;
 
    fastdds::rtps::ThreadSettings builtin_transports_reception_threads;
 
#if HAVE_SECURITY
    fastdds::rtps::ThreadSettings security_log_thread;
#endif // if HAVE_SECURITY
 
    uint32_t max_msg_size_no_frag = 0;
 
private:
 
    fastcdr::string_255 name{"RTPSParticipant"};
};
 
}  // namespace rtps
}  // namespace fastdds
}  // namespace eprosima
 
#endif  // FASTDDS_RTPS_ATTRIBUTES__RTPSPARTICIPANTATTRIBUTES_HPP