ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-12-06 17:27:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement sanitizer support via CMake (#822)

Browse Source 
Fixes #302
This commit is contained in:
Alex Kremer
2023-08-15 15:20:50 +01:00
committed by GitHub
parent ec70127050
commit bf3b24867c
28 changed files with 340 additions and 318 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/data/BackendFactory.h
View File

@@ -31,12 +31,11 @@ namespace data {
/**
* @brief A factory function that creates the backend based on a config.
*
* @param ioc The boost::asio::io_context to use
* @param config The clio config to use
* @return A shared_ptr<BackendInterface> with the selected implementation
*/
std::shared_ptr<BackendInterface>
make_Backend(boost::asio::io_context& ioc, util::Config const& config)
make_Backend(util::Config const& config)
{
static util::Logger log{"Backend"};
LOG(log.info()) << "Constructing BackendInterface";

4
src/data/CassandraBackend.h
View File

@@ -568,7 +568,7 @@ public:
std::vector<Statement> statements;
statements.reserve(numHashes);
auto const timeDiff = util::timed([this, &yield, &results, &hashes, &statements]() {
auto const timeDiff = util::timed([this, yield, &results, &hashes, &statements]() {
// TODO: seems like a job for "hash IN (list of hashes)" instead?
std::transform(
std::cbegin(hashes), std::cend(hashes), std::back_inserter(statements), [this](auto const& hash) {
@@ -634,7 +634,7 @@ public:
std::vector<LedgerObject>
fetchLedgerDiff(std::uint32_t const ledgerSequence, boost::asio::yield_context yield) const override
{
auto const [keys, timeDiff] = util::timed([this, &ledgerSequence, &yield]() -> std::vector<ripple::uint256> {
auto const [keys, timeDiff] = util::timed([this, &ledgerSequence, yield]() -> std::vector<ripple::uint256> {
auto const res = executor_.read(yield, schema_->selectDiff, ledgerSequence);
if (not res)
{

2
src/etl/ETLService.cpp
View File

@@ -236,7 +236,7 @@ void
ETLService::doWork()
{
worker_ = std::thread([this]() {
beast::setCurrentThreadName("rippled: ETLService worker");
beast::setCurrentThreadName("ETLService worker");
if (state_.isReadOnly)
monitorReadOnly();

6
src/etl/Source.cpp
View File

@@ -59,8 +59,7 @@ PlainSource::close(bool startAgain)
derived().ws().async_close(boost::beast::websocket::close_code::normal, [this, startAgain](auto ec) {
if (ec)
{
LOG(log_.error()) << " async_close : "
<< "error code = " << ec << " - " << toString();
LOG(log_.error()) << "async_close: error code = " << ec << " - " << toString();
}
closing_ = false;
if (startAgain)
@@ -94,8 +93,7 @@ SslSource::close(bool startAgain)
derived().ws().async_close(boost::beast::websocket::close_code::normal, [this, startAgain](auto ec) {
if (ec)
{
LOG(log_.error()) << " async_close : "
<< "error code = " << ec << " - " << toString();
LOG(log_.error()) << "async_close: error code = " << ec << " - " << toString();
}
closing_ = false;
if (startAgain)

19
src/etl/impl/CacheLoader.h
View File

@@ -68,7 +68,6 @@ class CacheLoader
std::vector<ClioPeer> clioPeers_;
std::thread thread_;
std::atomic_bool stopping_ = false;
public:
@@ -116,8 +115,6 @@ public:
~CacheLoader()
{
stop();
if (thread_.joinable())
thread_.join();
}
/**
@@ -357,28 +354,28 @@ private:
diff.erase(std::unique(diff.begin(), diff.end(), [](auto a, auto b) { return a.key == b.key; }), diff.end());
cursors.push_back({});
for (auto& obj : diff)
for (auto const& obj : diff)
if (obj.blob.size())
cursors.push_back({obj.key});
cursors.push_back({});
std::stringstream cursorStr;
for (auto& c : cursors)
for (auto const& c : cursors)
if (c)
cursorStr << ripple::strHex(*c) << ", ";
LOG(log_.info()) << "Loading cache. num cursors = " << cursors.size() - 1;
LOG(log_.trace()) << "cursors = " << cursorStr.str();
thread_ = std::thread{[this, seq, cursors]() {
boost::asio::post(ioContext_.get(), [this, seq, cursors = std::move(cursors)]() {
auto startTime = std::chrono::system_clock::now();
auto markers = std::make_shared<std::atomic_int>(0);
auto numRemaining = std::make_shared<std::atomic_int>(cursors.size() - 1);
for (size_t i = 0; i < cursors.size() - 1; ++i)
{
auto const start = cursors[i];
auto const end = cursors[i + 1];
auto const start = cursors.at(i);
auto const end = cursors.at(i + 1);
markers->wait(numCacheMarkers_);
++(*markers);
@@ -386,14 +383,14 @@ private:
boost::asio::spawn(
ioContext_.get(),
[this, seq, start, end, numRemaining, startTime, markers](boost::asio::yield_context yield) {
std::optional<ripple::uint256> cursor = start;
auto cursor = start;
std::string cursorStr =
cursor.has_value() ? ripple::strHex(cursor.value()) : ripple::strHex(data::firstKey);
LOG(log_.debug()) << "Starting a cursor: " << cursorStr << " markers = " << *markers;
while (not stopping_)
{
auto res = data::retryOnTimeout([this, seq, &cursor, &yield]() {
auto res = data::retryOnTimeout([this, seq, &cursor, yield]() {
return backend_->fetchLedgerPage(cursor, seq, cachePageFetchSize_, false, yield);
});
@@ -428,7 +425,7 @@ private:
}
});
}
}};
});
}
};

4
src/main/Main.cpp
View File

@@ -184,7 +184,7 @@ try
auto dosGuard = web::DOSGuard{config, whitelistHandler, sweepHandler};
// Interface to the database
auto backend = data::make_Backend(ioc, config);
auto backend = data::make_Backend(config);
// Manages clients subscribed to streams
auto subscriptions = feed::SubscriptionManager::make_SubscriptionManager(config, backend);
@@ -208,7 +208,7 @@ try
auto const rpcEngine = rpc::RPCEngine::make_RPCEngine(
config, backend, subscriptions, balancer, etl, dosGuard, workQueue, counters, handlerProvider);
// init the web server
// Init the web server
auto handler = std::make_shared<web::RPCServerHandler<rpc::RPCEngine, etl::ETLService>>(
config, backend, rpcEngine, etl, subscriptions);
auto ctx = parseCerts(config);

2
src/rpc/handlers/NFTOffersCommon.cpp
View File

@@ -84,7 +84,7 @@ NFTOffersHandlerBase::iterateOfferDirectory(
cursor = uint256(input.marker->c_str());
// We have a start point. Use limit - 1 from the result and use the very last one for the resume.
auto const sle = [this, &cursor, &lgrInfo, &yield]() -> std::shared_ptr<SLE const> {
auto const sle = [this, &cursor, &lgrInfo, yield]() -> std::shared_ptr<SLE const> {
auto const key = keylet::nftoffer(cursor).key;
if (auto const blob = sharedPtrBackend_->fetchLedgerObject(key, lgrInfo.seq, yield); blob)

64
src/web/DOSGuard.h
View File

@@ -20,6 +20,8 @@
#pragma once
#include <util/config/Config.h>
#include <util/log/Logger.h>
#include <web/IntervalSweepHandler.h>
#include <web/WhitelistHandler.h>
#include <boost/asio.hpp>
@@ -253,66 +255,6 @@ private:
}
};
/**
* @brief Sweep handler using a steady_timer and boost::asio::io_context.
*/
class IntervalSweepHandler
{
std::chrono::milliseconds sweepInterval_;
std::reference_wrapper<boost::asio::io_context> ctx_;
boost::asio::steady_timer timer_;
BaseDOSGuard* dosGuard_ = nullptr;
public:
/**
* @brief Construct a new interval-based sweep handler.
*
* @param config Clio config
* @param ctx The boost::asio::io_context
*/
IntervalSweepHandler(util::Config const& config, boost::asio::io_context& ctx)
: sweepInterval_{std::max(1u, static_cast<uint32_t>(config.valueOr("dos_guard.sweep_interval", 1.0) * 1000.0))}
, ctx_{std::ref(ctx)}
, timer_{ctx.get_executor()}
{
}
~IntervalSweepHandler()
{
timer_.cancel();
}
/**
* @brief This setup member function is called by @ref BasicDOSGuard during its initialization.
*
* @param guard Pointer to the dos guard
*/
void
setup(BaseDOSGuard* guard)
{
assert(dosGuard_ == nullptr);
dosGuard_ = guard;
assert(dosGuard_ != nullptr);
createTimer();
}
private:
void
createTimer()
{
timer_.expires_after(sweepInterval_);
timer_.async_wait([this](boost::system::error_code const& error) {
if (error == boost::asio::error::operation_aborted)
return;
dosGuard_->clear();
boost::asio::post(ctx_.get().get_executor(), [this] { createTimer(); });
});
}
};
using DOSGuard = BasicDOSGuard<web::WhitelistHandler, IntervalSweepHandler>;
using DOSGuard = BasicDOSGuard<web::WhitelistHandler, web::IntervalSweepHandler>;
} // namespace web

64
src/web/IntervalSweepHandler.cpp Normal file
View File

@@ -0,0 +1,64 @@
//------------------------------------------------------------------------------
/*
This file is part of clio: https://github.com/XRPLF/clio
Copyright (c) 2023, the clio developers.
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#include <web/IntervalSweepHandler.h>
#include <web/DOSGuard.h>
#include <algorithm>
#include <ctime>
namespace web {
IntervalSweepHandler::IntervalSweepHandler(util::Config const& config, boost::asio::io_context& ctx)
: sweepInterval_{std::max(1u, static_cast<uint32_t>(config.valueOr("dos_guard.sweep_interval", 1.0) * 1000.0))}
, ctx_{std::ref(ctx)}
, timer_{ctx.get_executor()}
{
}
IntervalSweepHandler::~IntervalSweepHandler()
{
boost::asio::post(ctx_.get(), [this]() { timer_.cancel(); });
}
void
IntervalSweepHandler::setup(web::BaseDOSGuard* guard)
{
assert(dosGuard_ == nullptr);
dosGuard_ = guard;
assert(dosGuard_ != nullptr);
createTimer();
}
void
IntervalSweepHandler::createTimer()
{
timer_.expires_after(sweepInterval_);
timer_.async_wait([this](boost::system::error_code const& error) {
if (error == boost::asio::error::operation_aborted)
return;
dosGuard_->clear();
boost::asio::post(ctx_.get(), [this] { createTimer(); });
});
}
} // namespace web

59
src/web/impl/IntervalSweepHandler.h → src/web/IntervalSweepHandler.h
View File

@@ -19,15 +19,15 @@
#pragma once
#include <util/config/Config.h>
#include <boost/asio.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/system/error_code.hpp>
#include <algorithm>
#include <chrono>
#include <ctime>
namespace web::detail {
namespace web {
class BaseDOSGuard;
/**
* @brief Sweep handler using a steady_timer and boost::asio::io_context.
@@ -42,52 +42,29 @@ class IntervalSweepHandler
public:
/**
* @brief Construct a new interval-based sweep handler
* @brief Construct a new interval-based sweep handler.
*
* @param config Clio config
* @param ctx The boost::asio::io_context
* @param config Clio config to use
* @param ctx The boost::asio::io_context to use
*/
IntervalSweepHandler(util::Config const& config, boost::asio::io_context& ctx)
: sweepInterval_{std::max(1u, static_cast<uint32_t>(config.valueOr("dos_guard.sweep_interval", 1.0) * 1000.0))}
, ctx_{std::ref(ctx)}
, timer_{ctx.get_executor()}
{
}
~IntervalSweepHandler()
{
timer_.cancel();
}
IntervalSweepHandler(util::Config const& config, boost::asio::io_context& ctx);
/**
* @brief This setup member function is called by @ref BasicDOSGuard during
* its initialization.
* @brief Cancels the sweep timer.
*/
~IntervalSweepHandler();
/**
* @brief This setup member function is called by @ref BasicDOSGuard during its initialization.
*
* @param guard Pointer to the dos guard
*/
void
setup(web::BaseDOSGuard* guard)
{
assert(dosGuard_ == nullptr);
dosGuard_ = guard;
assert(dosGuard_ != nullptr);
createTimer();
}
setup(web::BaseDOSGuard* guard);
private:
void
createTimer()
{
timer_.expires_after(sweepInterval_);
timer_.async_wait([this](boost::system::error_code const& error) {
if (error == boost::asio::error::operation_aborted)
return;
dosGuard_->clear();
boost::asio::post(ctx_.get().get_executor(), [this] { createTimer(); });
});
}
createTimer();
};
} // namespace web::detail
} // namespace web

20
src/web/WhitelistHandler.h
View File

@@ -20,6 +20,7 @@
#pragma once
#include <boost/asio.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <fmt/core.h>
#include <regex>
@@ -30,8 +31,7 @@
namespace web {
/**
* @brief A whitelist to remove rate limits of certain IP addresses
*
* @brief A whitelist to remove rate limits of certain IP addresses.
*/
class Whitelist
{
@@ -41,7 +41,7 @@ class Whitelist
public:
/**
* @brief Add network address to whitelist
* @brief Add network address to whitelist.
*
* @param net Network part of the ip address
* @throws std::runtime::error when the network address is not valid
@@ -66,7 +66,7 @@ public:
}
/**
* @brief Checks to see if ip address is whitelisted
* @brief Checks to see if ip address is whitelisted.
*
* @param ip IP address
* @throws std::runtime::error when the network address is not valid
@@ -130,15 +130,18 @@ private:
};
/**
* @brief A simple handler to add/check elements in a whitelist
*
* @param arr map of net addresses to add to whitelist
* @brief A simple handler to add/check elements in a whitelist.
*/
class WhitelistHandler
{
Whitelist whitelist_;
public:
/**
* @brief Adds all whitelisted IPs and masks from the given config.
*
* @param config The Clio config to use
*/
WhitelistHandler(util::Config const& config)
{
std::unordered_set<std::string> arr = getWhitelist(config);
@@ -146,6 +149,9 @@ public:
whitelist_.add(net);
}
/**
* @return true if the given IP is whitelisted; false otherwise
*/
bool
isWhiteListed(std::string_view ip) const
{