PeerfinderManager.h

#ifndef XRPL_PEERFINDER_MANAGER_H_INCLUDED
#define XRPL_PEERFINDER_MANAGER_H_INCLUDED
 
#include <xrpld/core/Config.h>
#include <xrpld/peerfinder/Slot.h>
 
#include <xrpl/beast/clock/abstract_clock.h>
#include <xrpl/beast/utility/PropertyStream.h>
 
#include <boost/asio/ip/tcp.hpp>
 
#include <string_view>
 
namespace ripple {
namespace PeerFinder {
 
using clock_type = beast::abstract_clock<std::chrono::steady_clock>;
 
using IPAddresses = std::vector<beast::IP::Endpoint>;
 
//------------------------------------------------------------------------------
 
struct Config
{
    std::size_t maxPeers;
 
    std::size_t outPeers;
 
    std::size_t inPeers;
 
    bool peerPrivate = true;
 
    bool wantIncoming;
 
    bool autoConnect;
 
    std::uint16_t listeningPort;
 
    std::string features;
 
    int ipLimit;
 
    //--------------------------------------------------------------------------
 
    Config();
 
    std::size_t
    calcOutPeers() const;
 
    void
    applyTuning();
 
    void
    onWrite(beast::PropertyStream::Map& map);
 
    static Config
    makeConfig(
        ripple::Config const& config,
        std::uint16_t port,
        bool validationPublicKey,
        int ipLimit);
 
    friend bool
    operator==(Config const& lhs, Config const& rhs);
};
 
//------------------------------------------------------------------------------
 
struct Endpoint
{
    Endpoint() = default;
 
    Endpoint(beast::IP::Endpoint const& 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:
    virtual ~Manager() = 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 const& 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>
    new_inbound_slot(
        beast::IP::Endpoint const& local_endpoint,
        beast::IP::Endpoint const& remote_endpoint) = 0;
 
    virtual std::pair<std::shared_ptr<Slot>, Result>
    new_outbound_slot(beast::IP::Endpoint const& remote_endpoint) = 0;
 
    virtual void
    on_endpoints(
        std::shared_ptr<Slot> const& slot,
        Endpoints const& endpoints) = 0;
 
    virtual void
    on_closed(std::shared_ptr<Slot> const& slot) = 0;
 
    virtual void
    on_failure(std::shared_ptr<Slot> const& slot) = 0;
 
    virtual void
    onRedirects(
        boost::asio::ip::tcp::endpoint const& remote_address,
        std::vector<boost::asio::ip::tcp::endpoint> const& eps) = 0;
 
    //--------------------------------------------------------------------------
 
    virtual bool
    onConnected(
        std::shared_ptr<Slot> const& slot,
        beast::IP::Endpoint const& local_endpoint) = 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
    once_per_second() = 0;
};
 
}  // namespace PeerFinder
}  // namespace ripple
 
#endif