Squelch.h

#pragma once
 
#include <xrpld/overlay/ReduceRelayCommon.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/protocol/PublicKey.h>
 
#include <chrono>
 
namespace xrpl::reduce_relay {

template <typename ClockType>
class Squelch
{
    using time_point = ClockType::time_point;
 
public:
    explicit Squelch(beast::Journal journal) : journal_(journal)
    {
    }
    virtual ~Squelch() = default;

    bool
    addSquelch(PublicKey const& validator, std::chrono::seconds const& squelchDuration);

    void
    removeSquelch(PublicKey const& validator);

    bool
    expireSquelch(PublicKey const& validator);
 
private:
    hash_map<PublicKey, time_point> squelched_;
    beast::Journal const journal_;
};
 
template <typename ClockType>
bool
Squelch<ClockType>::addSquelch(
    PublicKey const& validator,
    std::chrono::seconds const& squelchDuration)
{
    if (squelchDuration >= kMinUnsquelchExpire && squelchDuration <= kMaxUnsquelchExpirePeers)
    {
        squelched_[validator] = ClockType::now() + squelchDuration;
        return true;
    }
 
    JLOG(journal_.error()) << "squelch: invalid squelch duration " << squelchDuration.count();
 
    // unsquelch if invalid duration
    removeSquelch(validator);
 
    return false;
}
 
template <typename ClockType>
void
Squelch<ClockType>::removeSquelch(PublicKey const& validator)
{
    squelched_.erase(validator);
}
 
template <typename ClockType>
bool
Squelch<ClockType>::expireSquelch(PublicKey const& validator)
{
    auto now = ClockType::now();
 
    auto const& it = squelched_.find(validator);
    if (it == squelched_.end())
        return true;
    if (it->second > now)
        return false;
 
    // squelch expired
    squelched_.erase(it);
 
    return true;
}
 
}  // namespace xrpl::reduce_relay