WebHandlers.hpp

#pragma once
 
#include "data/LedgerCacheInterface.hpp"
#include "rpc/Errors.hpp"
#include "rpc/WorkQueue.hpp"
#include "util/log/Logger.hpp"
#include "web/AdminVerificationStrategy.hpp"
#include "web/SubscriptionContextInterface.hpp"
#include "web/dosguard/DOSGuardInterface.hpp"
#include "web/ng/Connection.hpp"
#include "web/ng/Request.hpp"
#include "web/ng/Response.hpp"
 
#include <boost/asio/spawn.hpp>
#include <boost/beast/http/status.hpp>
#include <boost/json/array.hpp>
#include <boost/json/parse.hpp>
 
#include <exception>
#include <functional>
#include <memory>
#include <string>
#include <utility>
 
namespace app {

class OnConnectCheck {
    std::reference_wrapper<web::dosguard::DOSGuardInterface> dosguard_;
 
public:
    OnConnectCheck(web::dosguard::DOSGuardInterface& dosguard);

    std::expected<void, web::ng::Response>
    operator()(web::ng::Connection const& connection);
};

class IpChangeHook {
    std::reference_wrapper<web::dosguard::DOSGuardInterface> dosguard_;
 
public:
    IpChangeHook(web::dosguard::DOSGuardInterface& dosguard);

    void
    operator()(std::string const& oldIp, std::string const& newIp);
};

class DisconnectHook {
    std::reference_wrapper<web::dosguard::DOSGuardInterface> dosguard_;
 
public:
    DisconnectHook(web::dosguard::DOSGuardInterface& dosguard);

    void
    operator()(web::ng::Connection const& connection);
};

class MetricsHandler {
    std::shared_ptr<web::AdminVerificationStrategy> adminVerifier_;
    std::reference_wrapper<rpc::WorkQueue> workQueue_;
 
public:
    MetricsHandler(
        std::shared_ptr<web::AdminVerificationStrategy> adminVerifier,
        rpc::WorkQueue& workQueue
    );

    web::ng::Response
    operator()(
        web::ng::Request const& request,
        web::ng::ConnectionMetadata& connectionMetadata,
        web::SubscriptionContextPtr,
        boost::asio::yield_context yield
    );
};

class HealthCheckHandler {
public:
    web::ng::Response
    operator()(
        web::ng::Request const& request,
        web::ng::ConnectionMetadata&,
        web::SubscriptionContextPtr,
        boost::asio::yield_context
    );
};

class CacheStateHandler {
    std::reference_wrapper<data::LedgerCacheInterface const> cache_;
 
public:
    CacheStateHandler(data::LedgerCacheInterface const& cache) : cache_{cache}
    {
    }

    web::ng::Response
    operator()(
        web::ng::Request const& request,
        web::ng::ConnectionMetadata&,
        web::SubscriptionContextPtr,
        boost::asio::yield_context
    );
};

template <typename RpcHandlerType>
class RequestHandler {
    util::Logger webServerLog_{"WebServer"};
    std::shared_ptr<web::AdminVerificationStrategy> adminVerifier_;
    std::reference_wrapper<RpcHandlerType> rpcHandler_;
 
public:
    RequestHandler(
        std::shared_ptr<web::AdminVerificationStrategy> adminVerifier,
        RpcHandlerType& rpcHandler
    )
        : adminVerifier_(std::move(adminVerifier)), rpcHandler_(rpcHandler)
    {
    }

    web::ng::Response
    operator()(
        web::ng::Request const& request,
        web::ng::ConnectionMetadata& connectionMetadata,
        web::SubscriptionContextPtr subscriptionContext,
        boost::asio::yield_context yield
    )
    {
        LOG(webServerLog_.info()) << connectionMetadata.tag()
                                  << "Received request from ip = " << connectionMetadata.ip()
                                  << " - posting to WorkQueue";
 
        connectionMetadata.setIsAdmin([this, &request, &connectionMetadata]() {
            return adminVerifier_->isAdmin(request.httpHeaders(), connectionMetadata.ip());
        });
 
        try {
            return rpcHandler_(request, connectionMetadata, std::move(subscriptionContext), yield);
        } catch (std::exception const&) {
            return web::ng::Response{
                boost::beast::http::status::internal_server_error,
                rpc::makeError(rpc::RippledError::rpcINTERNAL),
                request
            };
        }
    }
};
 
}  // namespace app