PeerfinderManager.h

#pragma once
 
#include <xrpld/core/Config.h>
#include <xrpld/peerfinder/Slot.h>
#include <xrpld/peerfinder/detail/Tuning.h>
 
#include <xrpl/beast/clock/abstract_clock.h>
#include <xrpl/beast/utility/PropertyStream.h>
 
#include <boost/asio/ip/tcp.hpp>
 
#include <string_view>
 
namespace xrpl::PeerFinder {
 
using clock_type = beast::AbstractClock<std::chrono::steady_clock>;

using IPAddresses = std::vector<beast::IP::Endpoint>;
 
//------------------------------------------------------------------------------

struct Config
{
    std::size_t maxPeers{Tuning::kDefaultMaxPeers};

    std::size_t outPeers;

    std::size_t inPeers{0};

    bool peerPrivate = true;

    bool wantIncoming{true};

    bool autoConnect{true};

    std::uint16_t listeningPort{0};

    std::string features;

    int ipLimit{0};

    bool verifyEndpoints = true;
 
    //--------------------------------------------------------------------------

    Config();

    [[nodiscard]] std::size_t
    calcOutPeers() const;

    void
    applyTuning();

    void
    onWrite(beast::PropertyStream::Map& map) const;

    static Config
    makeConfig(
        xrpl::Config const& config,
        std::uint16_t port,
        bool validationPublicKey,
        int ipLimit,
        bool verifyEndpoints);
 
    friend bool
    operator==(Config const& lhs, Config const& rhs) = default;
};
 
//------------------------------------------------------------------------------

struct Endpoint
{
    Endpoint() = default;
 
    Endpoint(beast::IP::Endpoint ep, std::uint32_t hops);
 
    std::uint32_t hops = 0;
    beast::IP::Endpoint address;
};
 
inline bool
operator<(Endpoint const& lhs, Endpoint const& rhs)
{
    return lhs.address < rhs.address;
}

using Endpoints = std::vector<Endpoint>;
 
//------------------------------------------------------------------------------

enum class Result { InboundDisabled, DuplicatePeer, IpLimitExceeded, Full, Success };

inline std::string_view
to_string(Result result) noexcept
{
    switch (result)
    {
        case Result::InboundDisabled:
            return "inbound disabled";
        case Result::DuplicatePeer:
            return "peer already connected";
        case Result::IpLimitExceeded:
            return "ip limit exceeded";
        case Result::Full:
            return "slots full";
        case Result::Success:
            return "success";
    }
 
    return "unknown";
}

class Manager : public beast::PropertyStream::Source
{
protected:
    Manager() noexcept;
 
public:
    ~Manager() override = default;

    virtual void
    setConfig(Config const& config) = 0;

    virtual void
    start() = 0;

    virtual void
    stop() = 0;

    virtual Config
    config() = 0;

    virtual void
    addFixedPeer(std::string_view name, std::vector<beast::IP::Endpoint> const& addresses) = 0;

    virtual void
    addFallbackStrings(std::string const& name, std::vector<std::string> const& strings) = 0;

    /* VFALCO NOTE Unimplemented
    virtual void addFallbackURL (std::string const& name,
        std::string const& url) = 0;
    */
 
    //--------------------------------------------------------------------------

    virtual std::pair<std::shared_ptr<Slot>, Result>
    newInboundSlot(
        beast::IP::Endpoint const& localEndpoint,
        beast::IP::Endpoint const& remoteEndpoint) = 0;

    virtual std::pair<std::shared_ptr<Slot>, Result>
    newOutboundSlot(beast::IP::Endpoint const& remoteEndpoint) = 0;

    virtual void
    onEndpoints(std::shared_ptr<Slot> const& slot, Endpoints const& endpoints) = 0;

    virtual void
    onClosed(std::shared_ptr<Slot> const& slot) = 0;

    virtual void
    onFailure(std::shared_ptr<Slot> const& slot) = 0;

    virtual void
    onRedirects(
        boost::asio::ip::tcp::endpoint const& remoteAddress,
        std::vector<boost::asio::ip::tcp::endpoint> const& eps) = 0;
 
    //--------------------------------------------------------------------------

    virtual bool
    onConnected(std::shared_ptr<Slot> const& slot, beast::IP::Endpoint const& localEndpoint) = 0;

    virtual Result
    activate(std::shared_ptr<Slot> const& slot, PublicKey const& key, bool reserved) = 0;

    virtual std::vector<Endpoint>
    redirect(std::shared_ptr<Slot> const& slot) = 0;

    virtual std::vector<beast::IP::Endpoint>
    autoconnect() = 0;
 
    virtual std::vector<std::pair<std::shared_ptr<Slot>, std::vector<Endpoint>>>
    buildEndpointsForPeers() = 0;

    virtual void
    oncePerSecond() = 0;
};
 
}  // namespace xrpl::PeerFinder