Program Listing for File PDP.h

↰ Return to documentation for file (/tmp/ws/src/fastrtps/include/fastdds/rtps/builtin/discovery/participant/PDP.h)

// Copyright 2019 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_PDP_H_
#define _FASTDDS_RTPS_PDP_H_
#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC

#include <atomic>
#include <mutex>
#include <functional>

#include <fastdds/rtps/attributes/RTPSParticipantAttributes.h>
#include <fastdds/rtps/builtin/data/ReaderProxyData.h>
#include <fastdds/rtps/builtin/data/WriterProxyData.h>
#include <fastdds/rtps/common/Guid.h>
#include <fastdds/rtps/participant/ParticipantDiscoveryInfo.h>
#include <fastrtps/qos/QosPolicies.h>
#include <fastrtps/utils/ProxyPool.hpp>
#include <fastrtps/utils/collections/ResourceLimitedVector.hpp>

namespace eprosima {

namespace fastdds {
namespace rtps {

class PDPServerListener;

} // namespace rtps
} // namespace fastdds

namespace fastrtps {
namespace rtps {

class RTPSWriter;
class RTPSReader;
class WriterHistory;
class ReaderHistory;
class RTPSParticipantImpl;
class RTPSParticipantListener;
class BuiltinProtocols;
class EDP;
class TimedEvent;
class ReaderProxyData;
class WriterProxyData;
class ParticipantProxyData;
class ReaderListener;
class PDPListener;
class PDPServerListener;
class ITopicPayloadPool;

class PDP
{
    friend class PDPListener;
    friend class PDPServerListener;
    friend class fastdds::rtps::PDPServerListener;

public:

    PDP(
            BuiltinProtocols* builtin,
            const RTPSParticipantAllocationAttributes& allocation);

    virtual ~PDP();

    virtual void initializeParticipantProxyData(
            ParticipantProxyData* participant_data);

    bool initPDP(
            RTPSParticipantImpl* part);

    bool enable();

    virtual bool init(
            RTPSParticipantImpl* part) = 0;

    virtual ParticipantProxyData* createParticipantProxyData(
            const ParticipantProxyData& p,
            const GUID_t& writer_guid) = 0;

    virtual void announceParticipantState(
            bool new_change,
            bool dispose = false,
            WriteParams& wparams = WriteParams::WRITE_PARAM_DEFAULT);

    virtual void stopParticipantAnnouncement();

    virtual void resetParticipantAnnouncement();

    ReaderProxyData* addReaderProxyData(
            const GUID_t& reader_guid,
            GUID_t& participant_guid,
            std::function<bool(ReaderProxyData*, bool, const ParticipantProxyData&)> initializer_func);

    WriterProxyData* addWriterProxyData(
            const GUID_t& writer_guid,
            GUID_t& participant_guid,
            std::function<bool(WriterProxyData*, bool, const ParticipantProxyData&)> initializer_func);

    bool has_reader_proxy_data(
            const GUID_t& reader);

    bool lookupReaderProxyData(
            const GUID_t& reader,
            ReaderProxyData& rdata);

    bool has_writer_proxy_data(
            const GUID_t& writer);

    bool lookupWriterProxyData(
            const GUID_t& writer,
            WriterProxyData& wdata);

    bool lookup_participant_name(
            const GUID_t& guid,
            string_255& name);

    bool removeReaderProxyData(
            const GUID_t& reader_guid);

    bool removeWriterProxyData(
            const GUID_t& writer_guid);

    virtual bool createPDPEndpoints() = 0;

    virtual void assignRemoteEndpoints(
            ParticipantProxyData* pdata) = 0;

    virtual void notifyAboveRemoteEndpoints(
            const ParticipantProxyData& pdata) = 0;

    virtual bool updateInfoMatchesEDP()
    {
        return false;
    }

    virtual void removeRemoteEndpoints(
            ParticipantProxyData* pdata) = 0;

    virtual bool remove_remote_participant(
            const GUID_t& participant_guid,
            ParticipantDiscoveryInfo::DISCOVERY_STATUS reason);

    const BuiltinAttributes& builtin_attributes() const;

    ParticipantProxyData* getLocalParticipantProxyData()
    {
        return participant_proxies_.front();
    }

    inline EDP* getEDP()
    {
        return mp_EDP;
    }

    ResourceLimitedVector<ParticipantProxyData*>::const_iterator ParticipantProxiesBegin()
    {
        return participant_proxies_.begin();
    }

    ResourceLimitedVector<ParticipantProxyData*>::const_iterator ParticipantProxiesEnd()
    {
        return participant_proxies_.end();
    }

    void assert_remote_participant_liveliness(
            const GuidPrefix_t& remote_guid);

    inline RTPSParticipantImpl* getRTPSParticipant() const
    {
        return mp_RTPSParticipant;
    }

    inline std::recursive_mutex* getMutex() const
    {
        return mp_mutex;
    }

    CDRMessage_t get_participant_proxy_data_serialized(
            Endianness_t endian);

    ParticipantProxyData* get_participant_proxy_data(
            const GuidPrefix_t& guid_prefix);

    std::list<eprosima::fastdds::rtps::RemoteServerAttributes>& remote_server_attributes();

    ProxyPool<ReaderProxyData>& get_temporary_reader_proxies_pool()
    {
        return temp_reader_proxies_;
    }

    ProxyPool<WriterProxyData>& get_temporary_writer_proxies_pool()
    {
        return temp_writer_proxies_;
    }

protected:

    BuiltinProtocols* mp_builtin;
    RTPSParticipantImpl* mp_RTPSParticipant;
    BuiltinAttributes m_discovery;
    RTPSWriter* mp_PDPWriter;
    RTPSReader* mp_PDPReader;
    EDP* mp_EDP;
    size_t participant_proxies_number_;
    ResourceLimitedVector<ParticipantProxyData*> participant_proxies_;
    ResourceLimitedVector<ParticipantProxyData*> participant_proxies_pool_;
    size_t reader_proxies_number_;
    ResourceLimitedVector<ReaderProxyData*> reader_proxies_pool_;
    size_t writer_proxies_number_;
    ResourceLimitedVector<WriterProxyData*> writer_proxies_pool_;
    std::atomic_bool m_hasChangedLocalPDP;
    ReaderListener* mp_listener;
    WriterHistory* mp_PDPWriterHistory;
    std::shared_ptr<ITopicPayloadPool> writer_payload_pool_;
    ReaderHistory* mp_PDPReaderHistory;
    std::shared_ptr<ITopicPayloadPool> reader_payload_pool_;
    ProxyPool<ReaderProxyData> temp_reader_proxies_;
    ProxyPool<WriterProxyData> temp_writer_proxies_;
    std::recursive_mutex* mp_mutex;
    std::mutex callback_mtx_;
    std::atomic<bool> enabled_ {false};

    ParticipantProxyData* add_participant_proxy_data(
            const GUID_t& participant_guid,
            bool with_lease_duration,
            const ParticipantProxyData* participant_proxy_data = nullptr);

    bool lookup_participant_key(
            const GUID_t& participant_guid,
            InstanceHandle_t& key);

private:

    TimedEvent* resend_participant_info_event_;

    InitialAnnouncementConfig initial_announcements_;

    void check_remote_participant_liveliness(
            ParticipantProxyData* remote_participant);

    void check_and_notify_type_discovery(
            RTPSParticipantListener* listener,
            const WriterProxyData& wdata) const;

    void check_and_notify_type_discovery(
            RTPSParticipantListener* listener,
            const ReaderProxyData& rdata) const;

    void check_and_notify_type_discovery(
            RTPSParticipantListener* listener,
            const string_255& topic_name,
            const string_255& type_name,
            const types::TypeIdentifier* type_id,
            const types::TypeObject* type_obj,
            const xtypes::TypeInformation* type_info) const;

    void set_next_announcement_interval();

    void set_initial_announcement_interval();

    void set_external_participant_properties_(
            ParticipantProxyData* participant_data);
};


// configuration values for PDP reliable entities.
extern const Duration_t pdp_heartbeat_period;
extern const Duration_t pdp_nack_response_delay;
extern const Duration_t pdp_nack_supression_duration;
extern const Duration_t pdp_heartbeat_response_delay;

extern const int32_t pdp_initial_reserved_caches;

} /* namespace rtps */
} /* namespace fastrtps */
} /* namespace eprosima */

#endif // ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
#endif /* _FASTDDS_RTPS_PDP_H_ */