Overlay.h

#ifndef XRPL_OVERLAY_OVERLAY_H_INCLUDED
#define XRPL_OVERLAY_OVERLAY_H_INCLUDED
 
#include <xrpld/overlay/Peer.h>
 
#include <xrpl/beast/utility/PropertyStream.h>
#include <xrpl/json/json_value.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 <functional>
#include <optional>
 
namespace boost {
namespace asio {
namespace ssl {
class context;
}
}  // namespace asio
}  // namespace boost
 
namespace ripple {
 
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 public_ip;
        int ipLimit = 0;
        std::uint32_t crawlOptions = 0;
        std::optional<std::uint32_t> networkID;
        bool vlEnabled = true;
    };
 
    using PeerSequence = std::vector<std::shared_ptr<Peer>>;
 
    virtual ~Overlay() = 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 remote_address) = 0;
 
    virtual void
    connect(beast::IP::Endpoint const& address) = 0;
 
    virtual int
    limit() = 0;
 
    virtual std::size_t
    size() const = 0;
 
    virtual Json::Value
    json() = 0;
 
    virtual PeerSequence
    getActivePeers() const = 0;
 
    virtual void
    checkTracking(std::uint32_t index) = 0;
 
    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& m) = 0;
 
    virtual void
    broadcast(protocol::TMValidation& m) = 0;
 
    virtual std::set<Peer::id_t>
    relay(
        protocol::TMProposeSet& m,
        uint256 const& uid,
        PublicKey const& validator) = 0;
 
    virtual std::set<Peer::id_t>
    relay(
        protocol::TMValidation& 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;
    virtual std::uint64_t
    getJqTransOverflow() const = 0;
 
    virtual void
    incPeerDisconnect() = 0;
    virtual std::uint64_t
    getPeerDisconnect() const = 0;
    virtual void
    incPeerDisconnectCharges() = 0;
    virtual std::uint64_t
    getPeerDisconnectCharges() const = 0;
 
    virtual std::optional<std::uint32_t>
    networkID() const = 0;
 
    virtual Json::Value
    txMetrics() const = 0;
};
 
}  // namespace ripple
 
#endif