ValidatorSite.h

#pragma once
 
#include <xrpld/app/main/Application.h>
#include <xrpld/app/misc/ValidatorList.h>
#include <xrpld/app/misc/detail/Work.h>
 
#include <xrpl/basics/StringUtilities.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/json/json_value.h>
 
#include <boost/asio.hpp>
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <vector>
 
namespace xrpl {

class ValidatorSite
{
    friend class Work;
 
private:
    using error_code = boost::system::error_code;
    using clock_type = std::chrono::system_clock;
    using endpoint_type = boost::asio::ip::tcp::endpoint;
 
    struct Site
    {
        struct Status
        {
            clock_type::time_point refreshed;
            ListDisposition disposition;
            std::string message;
        };
 
        struct Resource
        {
            explicit Resource(std::string uri);
            std::string const uri;
            ParsedUrl pUrl;
        };
 
        explicit Site(std::string uri);

        std::shared_ptr<Resource> loadedResource;

        std::shared_ptr<Resource> startingResource;

        std::shared_ptr<Resource> activeResource;
 
        unsigned short redirCount{0};
        std::chrono::minutes refreshInterval;
        clock_type::time_point nextRefresh;
        std::optional<Status> lastRefreshStatus;
        endpoint_type lastRequestEndpoint;
        bool lastRequestSuccessful{false};
    };
 
    Application& app_;
    beast::Journal const j_;
 
    // If both mutex are to be locked at the same time, `sitesMutex_` must be
    // locked before `stateMutex_` or we may deadlock.
    std::mutex mutable sitesMutex_;
    std::mutex mutable stateMutex_;
 
    std::condition_variable cv_;
    std::weak_ptr<detail::Work> work_;
    boost::asio::basic_waitable_timer<clock_type> timer_;
 
    // A list is currently being fetched from a site
    std::atomic<bool> fetching_;
 
    // One or more lists are due to be fetched
    std::atomic<bool> pending_;
    std::atomic<bool> stopping_;
 
    // The configured list of URIs for fetching lists
    std::vector<Site> sites_;
 
    // time to allow for requests to complete
    std::chrono::seconds const requestTimeout_;
 
public:
    ValidatorSite(
        Application& app,
        std::optional<beast::Journal> j = std::nullopt,
        std::chrono::seconds timeout = std::chrono::seconds{20});
    ~ValidatorSite();

    bool
    load(std::vector<std::string> const& siteURIs);

    void
    start();

    void
    join();

    void
    stop();

    json::Value
    getJson() const;
 
private:
    bool
    load(std::vector<std::string> const& siteURIs, std::scoped_lock<std::mutex> const&);

    void
    setTimer(std::scoped_lock<std::mutex> const&, std::scoped_lock<std::mutex> const&);

    void
    onRequestTimeout(std::size_t siteIdx, error_code const& ec);

    void
    onTimer(std::size_t siteIdx, error_code const& ec);

    void
    onSiteFetch(
        boost::system::error_code const& ec,
        endpoint_type const& endpoint,
        detail::response_type const& res,
        std::size_t siteIdx);

    void
    onTextFetch(boost::system::error_code const& ec, std::string const& res, std::size_t siteIdx);

    void
    makeRequest(
        std::shared_ptr<Site::Resource> resource,
        std::size_t siteIdx,
        std::scoped_lock<std::mutex> const&);

    void
    parseJsonResponse(
        std::string const& res,
        std::size_t siteIdx,
        std::scoped_lock<std::mutex> const&);

    std::shared_ptr<Site::Resource>
    processRedirect(
        detail::response_type const& res,
        std::size_t siteIdx,
        std::scoped_lock<std::mutex> const&);

    bool
    missingSite(std::scoped_lock<std::mutex> const&);
};
 
}  // namespace xrpl