include/xrpl/peerfinder/PeerfinderManager.h

#pragma once
 
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/beast/utility/PropertyStream.h>
#include <xrpl/peerfinder/Config.h>
#include <xrpl/peerfinder/Slot.h>
#include <xrpl/peerfinder/Types.h>
#include <xrpl/protocol/PublicKey.h>
 
#include <boost/asio/ip/tcp.hpp>
 
#include <memory>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace xrpl::peer_finder {

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::peer_finder