CapturePeer.h

#pragma once
 
#include <test/jtx/Env.h>
 
#include <xrpld/app/main/Application.h>
#include <xrpld/overlay/Message.h>
#include <xrpld/overlay/Peer.h>
#include <xrpld/overlay/detail/OverlayImpl.h>
#include <xrpld/overlay/detail/PeerImp.h>
#include <xrpld/overlay/detail/ProtocolVersion.h>
 
#include <xrpl/basics/contract.h>
#include <xrpl/basics/make_SSLContext.h>
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/peerfinder/Slot.h>
#include <xrpl/protocol/KeyType.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/resource/Charge.h>
#include <xrpl/resource/Consumer.h>
#include <xrpl/server/Handoff.h>
 
#include <boost/asio/ip/address.hpp>
#include <boost/asio/ip/address_v4.hpp>
#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 <cstdint>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace xrpl::test {

class CapturePeer : public PeerImp
{
public:
    using MiddleType = boost::beast::tcp_stream;
    using StreamType = boost::beast::ssl_stream<MiddleType>;
    using SocketType = boost::asio::ip::tcp::socket;

    CapturePeer(
        Application& app,
        Peer::ID id,
        std::shared_ptr<peer_finder::Slot> const& slot,
        HttpRequestType request,
        PublicKey const& publicKey,
        ProtocolVersion protocol,
        resource::Consumer consumer,
        std::unique_ptr<StreamType> streamPtr,
        OverlayImpl& overlay)
        : PeerImp(
              app,
              id,
              slot,
              std::move(request),
              publicKey,
              protocol,
              consumer,  // copy-only, so `std::move` would be a copy anyway
              std::move(streamPtr),
              overlay)
    {
    }
 
    ~CapturePeer() override = default;

    void
    run() override
    {
    }

    void
    send(std::shared_ptr<Message> const& m) override
    {
        sent_.push_back(m);
    }

    std::vector<std::shared_ptr<Message>> const&
    sent() const
    {
        return sent_;
    }

    std::shared_ptr<Message>
    lastSent() const
    {
        return sent_.empty() ? nullptr : sent_.back();
    }

    resource::Charge
    feeCharge() const
    {
        return currentFeeCharge();
    }
 
private:
    std::vector<std::shared_ptr<Message>> sent_;
};
 
namespace detail {
 
// `inline` so the functions below name one entity across translation units.
inline constexpr std::uint16_t kCapturePeerPort = 51235;

inline Peer::ID
nextCapturePeerId()
{
    static Peer::ID id{0};
    return ++id;
}

inline beast::ip::Endpoint
nextCapturePeerRemote()
{
    // From 172.2.0.1 upward, so ~900k fit before reaching 172.16/12, where the
    // peer finder would treat them as private rather than as real inbound.
    static std::uint32_t next{0xAC020001};
    return beast::ip::Endpoint(boost::asio::ip::address_v4(next++), kCapturePeerPort);
}

inline boost::asio::ssl::context&
capturePeerSslContext()
{
    static std::shared_ptr<boost::asio::ssl::context> const kContext{makeSslContext("")};
    return *kContext;
}
 
}  // namespace detail

template <class PeerType = CapturePeer>
std::shared_ptr<PeerType>
makeCapturePeer(
    jtx::Env& env,
    std::optional<PublicKey> key = std::nullopt,
    HttpRequestType request = {})
{
    auto& overlay = dynamic_cast<OverlayImpl&>(env.app().getOverlay());
    auto streamPtr = std::make_unique<CapturePeer::StreamType>(
        CapturePeer::SocketType(env.app().getIOContext()), detail::capturePeerSslContext());
 
    beast::ip::Endpoint const local(
        boost::asio::ip::make_address("172.1.1.1"), detail::kCapturePeerPort);
    auto const remote = detail::nextCapturePeerRemote();
 
    auto consumer = overlay.resourceManager().newInboundEndpoint(remote);
    auto [slot, _] = overlay.peerFinder().newInboundSlot(local, remote);
 
    // Unseated when the endpoint is already connected or at the per-address
    // limit. `PeerImp` dereferences the slot, so fail here, not there.
    if (!slot)
    {
        Throw<std::runtime_error>("makeCapturePeer: no slot for " + to_string(remote));
    }
 
    if (!key)
        key = PublicKey(std::get<0>(randomKeyPair(KeyType::Ed25519)));
 
    auto peer = std::make_shared<PeerType>(
        env.app(),
        detail::nextCapturePeerId(),
        slot,
        std::move(request),
        *key,
        // An unsupported version fails every `supportsFeature` test, so a
        // version-gated reply would only ever take its legacy branch.
        newestSupportedProtocolVersion(),
        consumer,
        std::move(streamPtr),
        overlay);
 
    overlay.addActive(peer);
    return peer;
}
 
}  // namespace xrpl::test