Overlay.h

#pragma once
 
#include <xrpld/overlay/Peer.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/net/IPAddress.h>
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/beast/utility/PropertyStream.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/server/Handoff.h>
 
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/context.hpp>
#include <boost/beast/core/tcp_stream.hpp>
#include <boost/beast/ssl/ssl_stream.hpp>
 
#include <xrpl.pb.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <set>
#include <vector>
 
namespace boost::asio::ssl {
class context;
}  // namespace boost::asio::ssl
 
namespace xrpl {

class Overlay : public beast::PropertyStream::Source
{
protected:
    using socket_type = boost::beast::tcp_stream;
    using stream_type = boost::beast::ssl_stream<socket_type>;
 
    // VFALCO NOTE The requirement of this constructor is an
    //             unfortunate problem with the API for
    //             PropertyStream
    Overlay() : beast::PropertyStream::Source("peers")
    {
    }
 
public:
    enum class Promote { Automatic, Never, Always };
 
    struct Setup
    {
        explicit Setup() = default;
 
        std::shared_ptr<boost::asio::ssl::context> context;
        beast::ip::Address publicIp;
        int ipLimit = 0;
        std::uint32_t crawlOptions = 0;
        std::optional<std::uint32_t> networkID;
        bool vlEnabled = true;
        bool verifyEndpoints = true;
    };
 
    using PeerSequence = std::vector<std::shared_ptr<Peer>>;
 
    ~Overlay() override = default;
 
    virtual void
    start()
    {
    }
 
    virtual void
    stop()
    {
    }

    virtual Handoff
    onHandoff(
        std::unique_ptr<stream_type>&& bundle,
        http_request_type&& request,
        boost::asio::ip::tcp::endpoint remoteAddress) = 0;

    virtual void
    connect(beast::ip::Endpoint const& address) = 0;

    virtual int
    limit() = 0;

    [[nodiscard]] virtual std::size_t
    size() const = 0;

    virtual json::Value
    json() = 0;

    [[nodiscard]] virtual PeerSequence
    getActivePeers() const = 0;

    virtual void
    checkTracking(std::uint32_t index) = 0;

    [[nodiscard]] virtual std::shared_ptr<Peer>
    findPeerByShortID(Peer::id_t const& id) const = 0;

    virtual std::shared_ptr<Peer>
    findPeerByPublicKey(PublicKey const& pubKey) = 0;

    virtual void
    broadcast(protocol::TMProposeSet const& m) = 0;

    virtual void
    broadcast(protocol::TMValidation const& m) = 0;

    virtual std::set<Peer::id_t>
    relay(protocol::TMProposeSet const& m, uint256 const& uid, PublicKey const& validator) = 0;

    virtual std::set<Peer::id_t>
    relay(protocol::TMValidation const& m, uint256 const& uid, PublicKey const& validator) = 0;

    virtual void
    relay(
        uint256 const& hash,
        std::optional<std::reference_wrapper<protocol::TMTransaction>> m,
        std::set<Peer::id_t> const& toSkip) = 0;

    template <class Function>
    void
    foreach(Function f) const
    {
        for (auto const& p : getActivePeers())
            f(p);
    }

    virtual void
    incJqTransOverflow() = 0;
    [[nodiscard]] virtual std::uint64_t
    getJqTransOverflow() const = 0;

    virtual void
    incPeerDisconnect() = 0;
    [[nodiscard]] virtual std::uint64_t
    getPeerDisconnect() const = 0;
    virtual void
    incPeerDisconnectCharges() = 0;
    [[nodiscard]] virtual std::uint64_t
    getPeerDisconnectCharges() const = 0;

    [[nodiscard]] virtual std::optional<std::uint32_t>
    networkID() const = 0;

    [[nodiscard]] virtual json::Value
    txMetrics() const = 0;
};
 
}  // namespace xrpl