peer_exchange.h

Go to the documentation of this file.

#pragma once

 
#include "librats/util/rats_export.h"
#include "librats/node/peer_network.h"
#include "librats/peer/peer.h"
#include "librats/peer/peer_id.h"
#include "librats/core/address.h"
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <mutex>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace librats {
 
class ServiceRegistry;
struct HolePunchService;
 
class RATS_API PeerExchange final : public Subsystem {
public:
    struct Config {
        size_t max_addresses_per_response = 32;  
        size_t request_max                = 32;  
        bool   request_on_connect         = true;
        bool   public_only                = false;  
        std::chrono::milliseconds dial_cooldown{std::chrono::minutes(5)};  
        size_t max_recent_dials           = 4096;  

        size_t peer_target                = 0;

        bool punch_on_dial_failure        = true;
        std::chrono::milliseconds punch_window{std::chrono::seconds(30)};
        size_t max_pending_dials          = 512;

        bool   introduce_requesters       = false;
    };
 
    PeerExchange();
    explicit PeerExchange(Config config);
    ~PeerExchange() override;
 
    void attach(NodeContext& ctx) override;
    void start() override;
    void stop() override;
 
private:
    void on_connected(const Peer& peer);
    void handle(const Peer& peer, ByteView payload);
    void handle_request(const Peer& requester, uint16_t max);
    void introduce(const PeerId& peer, const std::vector<PeerInfo>& peers,
                   const std::vector<PeerId>& listed);
    void handle_response(ByteView body);
    void on_dial_failed(const Address& address);
 
    const Address* pick_shareable(const std::vector<Address>& addrs) const;
    bool           should_dial(const Address& addr);  
    void           remember_dial(const Address& addr, const PeerId& id);
 
    Config       config_;
    PeerNetwork* network_ = nullptr;
    ServiceRegistry*  services_ = nullptr;
    std::atomic<HolePunchService*> punch_{nullptr};
    std::atomic<bool> running_{false};
 
    struct PendingDial {
        PeerId                                id;
        std::chrono::steady_clock::time_point started;
    };
 
    std::mutex mutex_;
    std::unordered_map<Address, std::chrono::steady_clock::time_point> recent_dials_;
    std::unordered_map<Address, PendingDial>                           pending_dials_;
    std::unordered_set<PeerId, PeerId::Hash>                           introduced_;
};
 
} // namespace librats