HashRouter.h

#pragma once
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/hardened_hash.h>
#include <xrpl/beast/container/aged_unordered_map.h>
 
#include <chrono>
#include <cstdint>
#include <mutex>
#include <optional>
#include <set>
#include <type_traits>
#include <utility>
 
namespace xrpl {
 
enum class HashRouterFlags : std::uint16_t {
    // Public flags
    UNDEFINED = 0x00,
    BAD = 0x02,  // Temporarily bad
    SAVED = 0x04,
    HELD = 0x08,     // Held by LedgerMaster after potential processing failure
    TRUSTED = 0x10,  // Comes from a trusted source
 
    // Private flags. Each group is owned by one file; do not read, set, or
    // reuse a flag outside the file noted.
    // Used in apply.cpp
    PRIVATE1 = 0x0100,
    PRIVATE2 = 0x0200,
    PRIVATE3 = 0x0400,
    PRIVATE4 = 0x0800,
    // Used in EscrowFinish.cpp
    PRIVATE5 = 0x1000,
    PRIVATE6 = 0x2000,
    // Used in apply.cpp
    PRIVATE7 = 0x4000,
    PRIVATE8 = 0x8000
};
 
constexpr HashRouterFlags
operator|(HashRouterFlags lhs, HashRouterFlags rhs)
{
    return static_cast<HashRouterFlags>(
        static_cast<std::underlying_type_t<HashRouterFlags>>(lhs) |
        static_cast<std::underlying_type_t<HashRouterFlags>>(rhs));
}
 
constexpr HashRouterFlags&
operator|=(HashRouterFlags& lhs, HashRouterFlags rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
 
constexpr HashRouterFlags
operator&(HashRouterFlags lhs, HashRouterFlags rhs)
{
    return static_cast<HashRouterFlags>(
        static_cast<std::underlying_type_t<HashRouterFlags>>(lhs) &
        static_cast<std::underlying_type_t<HashRouterFlags>>(rhs));
}
 
constexpr HashRouterFlags&
operator&=(HashRouterFlags& lhs, HashRouterFlags rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
constexpr bool
any(HashRouterFlags flags)
{
    return static_cast<std::underlying_type_t<HashRouterFlags>>(flags) != 0;
}
 
class Config;

class HashRouter
{
public:
    // The type here *MUST* match the type of Peer::ID
    using PeerShortID = std::uint32_t;

    struct Setup
    {
        explicit Setup() = default;
 
        using Seconds = std::chrono::seconds;

        Seconds holdTime{300};

        Seconds relayTime{30};
    };
 
private:
    class Entry : public CountedObject<Entry>
    {
    public:
        Entry() = default;
 
        void
        addPeer(PeerShortID peer)
        {
            if (peer != 0)
                peers_.insert(peer);
        }
 
        [[nodiscard]] HashRouterFlags
        getFlags() const
        {
            return flags_;
        }
 
        void
        setFlags(HashRouterFlags flagsToSet)
        {
            flags_ |= flagsToSet;
        }

        std::set<PeerShortID>
        releasePeerSet()
        {
            return std::move(peers_);
        }

        [[nodiscard]] std::optional<Stopwatch::time_point>
        relayed() const
        {
            return relayed_;
        }

        bool
        shouldRelay(Stopwatch::time_point const& now, std::chrono::seconds relayTime)
        {
            if (relayed_ && *relayed_ + relayTime > now)
                return false;
            relayed_.emplace(now);
            return true;
        }
 
        bool
        shouldProcess(Stopwatch::time_point now, std::chrono::seconds interval)
        {
            if (processed_ && ((*processed_ + interval) > now))
                return false;
            processed_.emplace(now);
            return true;
        }
 
    private:
        HashRouterFlags flags_ = HashRouterFlags::UNDEFINED;
        std::set<PeerShortID> peers_;
        // This could be generalized to a map, if more
        // than one flag needs to expire independently.
        std::optional<Stopwatch::time_point> relayed_;
        std::optional<Stopwatch::time_point> processed_;
    };
 
public:
    HashRouter(Setup const& setup, Stopwatch& clock) : setup_(setup), suppressionMap_(clock)
    {
    }
 
    HashRouter&
    operator=(HashRouter const&) = delete;
 
    virtual ~HashRouter() = default;
 
    // VFALCO TODO Replace "Suppression" terminology with something more
    // semantically meaningful.
    void
    addSuppression(UInt256 const& key);
 
    bool
    addSuppressionPeer(UInt256 const& key, PeerShortID peer);

    std::pair<bool, std::optional<Stopwatch::time_point>>
    addSuppressionPeerWithStatus(UInt256 const& key, PeerShortID peer);
 
    bool
    addSuppressionPeer(UInt256 const& key, PeerShortID peer, HashRouterFlags& flags);
 
    // Add a peer suppression and return whether the entry should be processed
    bool
    shouldProcess(
        UInt256 const& key,
        PeerShortID peer,
        HashRouterFlags& flags,
        std::chrono::seconds txInterval);

    bool
    setFlags(UInt256 const& key, HashRouterFlags flags);
 
    HashRouterFlags
    getFlags(UInt256 const& key);

    std::optional<std::set<PeerShortID>>
    shouldRelay(UInt256 const& key);
 
private:
    // pair.second indicates whether the entry was created
    std::pair<Entry&, bool>
    emplace(UInt256 const&);
 
    std::mutex mutable mutex_;
 
    // Configurable parameters
    Setup const setup_;
 
    // Stores all suppressed hashes and their expiration time
    beast::AgedUnorderedMap<UInt256, Entry, Stopwatch::ClockType, HardenedHash<StrongHash>>
        suppressionMap_;
};
 
}  // namespace xrpl