ConnectAttempt.h

#pragma once
 
#include <xrpld/overlay/detail/OverlayImpl.h>
 
#include <chrono>
 
namespace xrpl {
 
class ConnectAttempt : public OverlayImpl::Child,
                       public std::enable_shared_from_this<ConnectAttempt>
{
private:
    using error_code = boost::system::error_code;
    using endpoint_type = boost::asio::ip::tcp::endpoint;
    using request_type = boost::beast::http::request<boost::beast::http::empty_body>;
    using response_type = boost::beast::http::response<boost::beast::http::dynamic_body>;
    using socket_type = boost::asio::ip::tcp::socket;
    using middle_type = boost::beast::tcp_stream;
    using stream_type = boost::beast::ssl_stream<middle_type>;
    using shared_context = std::shared_ptr<boost::asio::ssl::context>;
 
    enum class ConnectionStep {
        Init,            // Initial state, nothing started
        TcpConnect,      // Establishing TCP connection to remote peer
        TlsHandshake,    // Performing SSL/TLS handshake
        HttpWrite,       // Sending HTTP upgrade request
        HttpRead,        // Reading HTTP upgrade response
        Complete,        // Connection successfully established
        ShutdownStarted  // Connection shutdown has started
    };
 
    // A timeout for connection process, greater than all step timeouts
    static constexpr std::chrono::seconds connectTimeout{25};
 
    struct StepTimeouts
    {
        // TCP connection timeout
        static constexpr std::chrono::seconds tcpConnect{8};
        // SSL handshake timeout
        static constexpr std::chrono::seconds tlsHandshake{8};
        // HTTP write timeout
        static constexpr std::chrono::seconds httpWrite{3};
        // HTTP read timeout
        static constexpr std::chrono::seconds httpRead{3};
        // SSL shutdown timeout
        static constexpr std::chrono::seconds tlsShutdown{2};
    };
 
    // Core application and networking components
    Application& app_;
    Peer::id_t const id_;
    beast::WrappedSink sink_;
    beast::Journal const journal_;
    endpoint_type remote_endpoint_;
    Resource::Consumer usage_;
 
    boost::asio::strand<boost::asio::io_context::executor_type> strand_;
    boost::asio::basic_waitable_timer<std::chrono::steady_clock> timer_;
    boost::asio::basic_waitable_timer<std::chrono::steady_clock> stepTimer_;
 
    std::unique_ptr<stream_type> stream_ptr_;  // SSL stream (owned)
    socket_type& socket_;
    stream_type& stream_;
    boost::beast::multi_buffer read_buf_;
 
    response_type response_;
    std::shared_ptr<PeerFinder::Slot> slot_;
    request_type req_;
 
    bool shutdown_ = false;   // Shutdown has been initiated
    bool ioPending_ = false;  // Async I/O operation in progress
    ConnectionStep currentStep_ = ConnectionStep::Init;
 
public:
    ConnectAttempt(
        Application& app,
        boost::asio::io_context& io_context,
        endpoint_type const& remote_endpoint,
        Resource::Consumer usage,
        shared_context const& context,
        Peer::id_t id,
        std::shared_ptr<PeerFinder::Slot> const& slot,
        beast::Journal journal,
        OverlayImpl& overlay);
 
    virtual ~ConnectAttempt();
 
    void
    stop() override;
 
    void
    run();
 
private:
    void
    setTimer(ConnectionStep step);
 
    void
    cancelTimer();
 
    void
    onTimer(error_code ec);
 
    // Connection phase handlers
    void
    onConnect(error_code ec);  // TCP connection completion handler
    void
    onHandshake(error_code ec);  // TLS handshake completion handler
    void
    onWrite(error_code ec);  // HTTP write completion handler
    void
    onRead(error_code ec);  // HTTP read completion handler
 
    // Error and cleanup handlers
    void
    fail(std::string const& reason);  // Fail with custom reason
    void
    fail(std::string const& name, error_code ec);  // Fail with system error
    void
    shutdown();  // Initiate graceful shutdown
    void
    tryAsyncShutdown();  // Attempt async SSL shutdown
    void
    onShutdown(error_code ec);  // SSL shutdown completion handler
    void
    close();  // Force close socket
 
    void
    processResponse();
 
    static std::string
    stepToString(ConnectionStep step)
    {
        switch (step)
        {
            case ConnectionStep::Init:
                return "Init";
            case ConnectionStep::TcpConnect:
                return "TcpConnect";
            case ConnectionStep::TlsHandshake:
                return "TlsHandshake";
            case ConnectionStep::HttpWrite:
                return "HttpWrite";
            case ConnectionStep::HttpRead:
                return "HttpRead";
            case ConnectionStep::Complete:
                return "Complete";
            case ConnectionStep::ShutdownStarted:
                return "ShutdownStarted";
        }
        return "Unknown";
    };
 
    template <class = void>
    static boost::asio::ip::tcp::endpoint
    parse_endpoint(std::string const& s, boost::system::error_code& ec)
    {
        beast::IP::Endpoint bep;
        std::istringstream is(s);
        is >> bep;
        if (is.fail())
        {
            ec = boost::system::errc::make_error_code(boost::system::errc::invalid_argument);
            return boost::asio::ip::tcp::endpoint{};
        }
 
        return beast::IPAddressConversion::to_asio_endpoint(bep);
    }
};
 
}  // namespace xrpl