mirror of
https://github.com/XRPLF/rippled.git
synced 2026-04-29 15:37:57 +00:00
123 lines
2.7 KiB
C++
123 lines
2.7 KiB
C++
#include <xrpl/core/HashRouter.h>
|
|
|
|
#include <xrpl/basics/base_uint.h>
|
|
#include <xrpl/basics/chrono.h>
|
|
#include <xrpl/beast/container/detail/aged_unordered_container.h>
|
|
#include <xrpl/beast/utility/instrumentation.h>
|
|
|
|
#include <chrono>
|
|
#include <functional>
|
|
#include <mutex>
|
|
#include <optional>
|
|
#include <set>
|
|
#include <utility>
|
|
|
|
namespace xrpl {
|
|
|
|
auto
|
|
HashRouter::emplace(uint256 const& key) -> std::pair<Entry&, bool>
|
|
{
|
|
auto iter = suppressionMap_.find(key);
|
|
|
|
if (iter != suppressionMap_.end())
|
|
{
|
|
suppressionMap_.touch(iter);
|
|
return std::make_pair(std::ref(iter->second), false);
|
|
}
|
|
|
|
// See if any suppressions need to be expired
|
|
expire(suppressionMap_, setup_.holdTime);
|
|
|
|
return std::make_pair(std::ref(suppressionMap_.emplace(key, Entry()).first->second), true);
|
|
}
|
|
|
|
void
|
|
HashRouter::addSuppression(uint256 const& key)
|
|
{
|
|
std::lock_guard const lock(mutex_);
|
|
|
|
emplace(key);
|
|
}
|
|
|
|
bool
|
|
HashRouter::addSuppressionPeer(uint256 const& key, PeerShortID peer)
|
|
{
|
|
return addSuppressionPeerWithStatus(key, peer).first;
|
|
}
|
|
|
|
std::pair<bool, std::optional<Stopwatch::time_point>>
|
|
HashRouter::addSuppressionPeerWithStatus(uint256 const& key, PeerShortID peer)
|
|
{
|
|
std::lock_guard const lock(mutex_);
|
|
|
|
auto result = emplace(key);
|
|
result.first.addPeer(peer);
|
|
return {result.second, result.first.relayed()};
|
|
}
|
|
|
|
bool
|
|
HashRouter::addSuppressionPeer(uint256 const& key, PeerShortID peer, HashRouterFlags& flags)
|
|
{
|
|
std::lock_guard const lock(mutex_);
|
|
|
|
auto [s, created] = emplace(key);
|
|
s.addPeer(peer);
|
|
flags = s.getFlags();
|
|
return created;
|
|
}
|
|
|
|
bool
|
|
HashRouter::shouldProcess(
|
|
uint256 const& key,
|
|
PeerShortID peer,
|
|
HashRouterFlags& flags,
|
|
std::chrono::seconds tx_interval)
|
|
{
|
|
std::lock_guard const lock(mutex_);
|
|
|
|
auto result = emplace(key);
|
|
auto& s = result.first;
|
|
s.addPeer(peer);
|
|
flags = s.getFlags();
|
|
return s.shouldProcess(suppressionMap_.clock().now(), tx_interval);
|
|
}
|
|
|
|
HashRouterFlags
|
|
HashRouter::getFlags(uint256 const& key)
|
|
{
|
|
std::lock_guard const lock(mutex_);
|
|
|
|
return emplace(key).first.getFlags();
|
|
}
|
|
|
|
bool
|
|
HashRouter::setFlags(uint256 const& key, HashRouterFlags flags)
|
|
{
|
|
XRPL_ASSERT(static_cast<bool>(flags), "xrpl::HashRouter::setFlags : valid input");
|
|
|
|
std::lock_guard const lock(mutex_);
|
|
|
|
auto& s = emplace(key).first;
|
|
|
|
if ((s.getFlags() & flags) == flags)
|
|
return false;
|
|
|
|
s.setFlags(flags);
|
|
return true;
|
|
}
|
|
|
|
auto
|
|
HashRouter::shouldRelay(uint256 const& key) -> std::optional<std::set<PeerShortID>>
|
|
{
|
|
std::lock_guard const lock(mutex_);
|
|
|
|
auto& s = emplace(key).first;
|
|
|
|
if (!s.shouldRelay(suppressionMap_.clock().now(), setup_.relayTime))
|
|
return {};
|
|
|
|
return s.releasePeerSet();
|
|
}
|
|
|
|
} // namespace xrpl
|