ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-04-29 15:37:57 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
12b7316f713fb1c720c1955c0236ad4e5380d9c7
rippled/src/xrpld/core/detail/Config.cpp
Pratik Mankawde e07391fe78 chore: apply rename script (rippled → xrpld) 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-04-29 12:25:03 +01:00

1352 lines
46 KiB
C++
Raw Blame History

#include <xrpld/core/Config.h>
#include <xrpld/core/ConfigSections.h>
#include <xrpl/basics/BasicConfig.h>
#include <xrpl/basics/FileUtilities.h>
#include <xrpl/basics/Log.h>
#include <xrpl/basics/StringUtilities.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/contract.h>
#include <xrpl/beast/core/LexicalCast.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/net/HTTPClient.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/SystemParameters.h>
#include <xrpl/rdb/DBInit.h>
#include <xrpl/rdb/DatabaseCon.h>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/format/free_funcs.hpp>
#include <boost/multiprecision/detail/endian.hpp>
#include <boost/predef.h>
#include <boost/regex.hpp> // IWYU pragma: keep
#include <boost/regex/v5/regex.hpp>
#include <boost/regex/v5/regex_match.hpp>
#include <boost/system/detail/error_code.hpp>
#include <algorithm>
#include <array>
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <limits>
#include <memory>
#include <optional>
#include <regex>
#include <sstream>
#include <stdexcept>
#include <string>
#include <thread>
#include <type_traits>
#include <utility>
#include <vector>
#if BOOST_OS_WINDOWS
#include <sysinfoapi.h>
namespace xrpl::detail {
[[nodiscard]] std::uint64_t
getMemorySize()
{
if (MEMORYSTATUSEX msx{sizeof(MEMORYSTATUSEX)}; GlobalMemoryStatusEx(&msx))
return static_cast<std::uint64_t>(msx.ullTotalPhys);
return 0;
}
} // namespace xrpl::detail
#endif
#if BOOST_OS_LINUX
#include <sys/sysinfo.h> // IWYU pragma: keep
namespace xrpl::detail {
[[nodiscard]] std::uint64_t
getMemorySize()
{
if (struct sysinfo si{}; sysinfo(&si) == 0)
return static_cast<std::uint64_t>(si.totalram) * si.mem_unit;
return 0;
}
} // namespace xrpl::detail
#endif
#if BOOST_OS_MACOS
#include <sys/sysctl.h>
namespace xrpl::detail {
[[nodiscard]] std::uint64_t
getMemorySize()
{
int mib[] = {CTL_HW, HW_MEMSIZE};
std::int64_t ram = 0;
size_t size = sizeof(ram);
if (sysctl(mib, 2, &ram, &size, NULL, 0) == 0)
return static_cast<std::uint64_t>(ram);
return 0;
}
} // namespace xrpl::detail
#endif
namespace xrpl {
// clang-format off
// The configurable node sizes are "tiny", "small", "medium", "large", "huge"
inline constexpr std::array<std::pair<SizedItem, std::array<int, 5>>, 13>
sizedItems
{{
// FIXME: We should document each of these items, explaining exactly
// what they control and whether there exists an explicit
// config option that can be used to override the default.
// tiny small medium large huge
{SizedItem::sweepInterval, {{ 10, 30, 60, 90, 120 }}},
{SizedItem::treeCacheSize, {{ 262144, 524288, 2097152, 4194304, 8388608 }}},
{SizedItem::treeCacheAge, {{ 30, 60, 90, 120, 900 }}},
{SizedItem::ledgerSize, {{ 32, 32, 64, 256, 384 }}},
{SizedItem::ledgerAge, {{ 30, 60, 180, 300, 600 }}},
{SizedItem::ledgerFetch, {{ 2, 3, 4, 5, 8 }}},
{SizedItem::hashNodeDBCache, {{ 4, 12, 24, 64, 128 }}},
{SizedItem::txnDBCache, {{ 4, 12, 24, 64, 128 }}},
{SizedItem::lgrDBCache, {{ 4, 8, 16, 32, 128 }}},
{SizedItem::openFinalLimit, {{ 8, 16, 32, 64, 128 }}},
{SizedItem::burstSize, {{ 4, 8, 16, 32, 48 }}},
{SizedItem::ramSizeGB, {{ 6, 8, 12, 24, 0 }}},
{SizedItem::accountIdCacheSize, {{ 20047, 50053, 77081, 150061, 300007 }}}
}};
// clang-format on
// Ensure that the order of entries in the table corresponds to the
// order of entries in the enum:
static_assert(
[]() constexpr -> bool {
std::underlying_type_t<SizedItem> idx = 0;
for (auto const& i : sizedItems)
{
if (static_cast<std::underlying_type_t<SizedItem>>(i.first) != idx)
return false;
++idx;
}
return true;
}(),
"Mismatch between sized item enum & array indices");
//
// TODO: Check permissions on config file before using it.
//
#define SECTION_DEFAULT_NAME ""
IniFileSections
parseIniFile(std::string const& strInput, bool const bTrim)
{
std::string strData(strInput);
std::vector<std::string> vLines;
IniFileSections secResult;
// Convert DOS format to unix.
boost::algorithm::replace_all(strData, "\r\n", "\n");
// Convert MacOS format to unix.
boost::algorithm::replace_all(strData, "\r", "\n");
boost::algorithm::split(vLines, strData, boost::algorithm::is_any_of("\n"));
// Set the default Section name.
std::string strSection = SECTION_DEFAULT_NAME; // NOLINT(readability-redundant-string-init)
// Initialize the default Section.
secResult[strSection] = IniFileSections::mapped_type();
// Parse each line.
for (auto& strValue : vLines)
{
if (bTrim)
boost::algorithm::trim(strValue);
if (strValue.empty() || strValue[0] == '#')
{
// Blank line or comment, do nothing.
}
else if (strValue[0] == '[' && strValue[strValue.length() - 1] == ']')
{
// New Section.
strSection = strValue.substr(1, strValue.length() - 2);
secResult.emplace(strSection, IniFileSections::mapped_type{});
}
else
{
// Another line for Section.
if (!strValue.empty())
secResult[strSection].push_back(strValue);
}
}
return secResult;
}
IniFileSections::mapped_type*
getIniFileSection(IniFileSections& secSource, std::string const& strSection)
{
if (auto it = secSource.find(strSection); it != secSource.end())
return &(it->second);
return nullptr;
}
bool
getSingleSection(
IniFileSections& secSource,
std::string const& strSection,
std::string& strValue,
beast::Journal j)
{
auto const pmtEntries = getIniFileSection(secSource, strSection);
if ((pmtEntries != nullptr) && pmtEntries->size() == 1)
{
strValue = (*pmtEntries)[0];
return true;
}
if (pmtEntries != nullptr)
{
JLOG(j.warn()) << "Section '" << strSection << "': requires 1 line not "
<< pmtEntries->size() << " lines.";
}
return false;
}
//------------------------------------------------------------------------------
//
// Config
//
//------------------------------------------------------------------------------
char const* const Config::configFileName = "xrpld.cfg";
char const* const Config::configLegacyName = "xrpld.cfg";
char const* const Config::databaseDirName = "db";
char const* const Config::validatorsFileName = "validators.txt";
[[nodiscard]] static std::string
getEnvVar(char const* name)
{
std::string value;
if (auto const v = std::getenv(name); v != nullptr)
value = v;
return value;
}
Config::Config()
: j_(beast::Journal::getNullSink()), ramSize_(detail::getMemorySize() / (1024 * 1024 * 1024))
{
}
void
Config::setupControl(bool bQuiet, bool bSilent, bool bStandalone)
{
XRPL_ASSERT(NODE_SIZE == 0, "xrpl::Config::setupControl : node size not set");
QUIET = bQuiet || bSilent;
SILENT = bSilent;
RUN_STANDALONE = bStandalone;
// We try to autodetect the appropriate node size by checking available
// RAM and CPU resources. We default to "tiny" for standalone mode.
if (!bStandalone)
{
// First, check against 'minimum' RAM requirements per node size:
auto const& threshold = sizedItems[std::underlying_type_t<SizedItem>(SizedItem::ramSizeGB)];
auto ns = std::ranges::find_if(threshold.second, [this](std::size_t limit) {
return (limit == 0) || (ramSize_ < limit);
});
XRPL_ASSERT(ns != threshold.second.end(), "xrpl::Config::setupControl : valid node size");
if (ns != threshold.second.end())
NODE_SIZE = std::distance(threshold.second.begin(), ns);
// Adjust the size based on the number of hardware threads of
// execution available to us:
if (auto const hc = std::thread::hardware_concurrency(); hc != 0)
NODE_SIZE = std::min<std::size_t>(hc / 2, NODE_SIZE);
}
XRPL_ASSERT(NODE_SIZE <= 4, "xrpl::Config::setupControl : node size is set");
}
void
Config::setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStandalone)
{
setupControl(bQuiet, bSilent, bStandalone);
// Determine the config and data directories.
// If the config file is found in the current working
// directory, use the current working directory as the
// config directory and that with "db" as the data
// directory.
boost::filesystem::path dataDir;
if (!strConf.empty())
{
// --conf=<path> : everything is relative that file.
CONFIG_FILE = strConf;
CONFIG_DIR = boost::filesystem::absolute(CONFIG_FILE);
CONFIG_DIR.remove_filename();
dataDir = CONFIG_DIR / databaseDirName;
}
else
{
do
{
// Check if either of the config files exist in the current working
// directory, in which case the databases will be stored in a
// subdirectory.
CONFIG_DIR = boost::filesystem::current_path();
dataDir = CONFIG_DIR / databaseDirName;
CONFIG_FILE = CONFIG_DIR / configFileName;
if (boost::filesystem::exists(CONFIG_FILE))
break;
CONFIG_FILE = CONFIG_DIR / configLegacyName;
if (boost::filesystem::exists(CONFIG_FILE))
break;
// Check if the home directory is set, and optionally the XDG config
// and/or data directories, as the config may be there. See
// http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html.
auto const strHome = getEnvVar("HOME");
if (!strHome.empty())
{
auto strXdgConfigHome = getEnvVar("XDG_CONFIG_HOME");
auto strXdgDataHome = getEnvVar("XDG_DATA_HOME");
if (strXdgConfigHome.empty())
{
// $XDG_CONFIG_HOME was not set, use default based on $HOME.
strXdgConfigHome = strHome + "/.config";
}
if (strXdgDataHome.empty())
{
// $XDG_DATA_HOME was not set, use default based on $HOME.
strXdgDataHome = strHome + "/.local/share";
}
// Check if either of the config files exist in the XDG config
// dir.
dataDir = strXdgDataHome + "/" + systemName();
CONFIG_DIR = strXdgConfigHome + "/" + systemName();
CONFIG_FILE = CONFIG_DIR / configFileName;
if (boost::filesystem::exists(CONFIG_FILE))
break;
CONFIG_FILE = CONFIG_DIR / configLegacyName;
if (boost::filesystem::exists(CONFIG_FILE))
break;
}
// As a last resort, check the system config directory.
dataDir = "/var/opt/" + systemName();
CONFIG_DIR = "/etc/opt/" + systemName();
CONFIG_FILE = CONFIG_DIR / configFileName;
if (boost::filesystem::exists(CONFIG_FILE))
break;
CONFIG_FILE = CONFIG_DIR / configLegacyName;
} while (false);
}
// Update default values
load();
{
// load() may have set a new value for the dataDir
std::string const dbPath(legacy("database_path"));
if (!dbPath.empty())
{
dataDir = boost::filesystem::path(dbPath);
}
else if (RUN_STANDALONE)
{
dataDir.clear();
}
}
if (!dataDir.empty())
{
boost::system::error_code ec;
boost::filesystem::create_directories(dataDir, ec);
if (ec)
Throw<std::runtime_error>(boost::str(boost::format("Can not create %s") % dataDir));
legacy("database_path", boost::filesystem::absolute(dataDir).string());
}
HTTPClient::initializeSSLContext(
this->SSL_VERIFY_DIR, this->SSL_VERIFY_FILE, this->SSL_VERIFY, j_);
if (RUN_STANDALONE)
LEDGER_HISTORY = 0;
Section const ledgerTxTablesSection = section("ledger_tx_tables");
get_if_exists(ledgerTxTablesSection, "use_tx_tables", USE_TX_TABLES);
Section const& nodeDbSection{section(ConfigSection::nodeDatabase())};
get_if_exists(nodeDbSection, "fast_load", FAST_LOAD);
}
// 0 ports are allowed for unit tests, but still not allowed to be present in
// config file
static void
checkZeroPorts(Config const& config)
{
if (!config.exists("server"))
return;
for (auto const& name : config.section("server").values())
{
if (!config.exists(name))
return;
auto const& section = config[name];
auto const optResult = section.get("port");
if (optResult)
{
auto const port = beast::lexicalCast<std::uint16_t>(*optResult);
if (port == 0u)
{
std::stringstream ss;
ss << "Invalid value '" << *optResult << "' for key 'port' in [" << name << "]";
Throw<std::runtime_error>(ss.str());
}
}
}
}
void
Config::load()
{
// NOTE: this writes to cerr because we want cout to be reserved
// for the writing of the json response (so that stdout can be part of a
// pipeline, for instance)
if (!QUIET)
std::cerr << "Loading: " << CONFIG_FILE << "\n";
boost::system::error_code ec;
auto const fileContents = getFileContents(ec, CONFIG_FILE);
if (ec)
{
std::cerr << "Failed to read '" << CONFIG_FILE << "'." << ec.value() << ": " << ec.message()
<< std::endl;
return;
}
loadFromString(fileContents);
checkZeroPorts(*this);
}
void
Config::loadFromString(std::string const& fileContents)
{
IniFileSections secConfig = parseIniFile(fileContents, true);
build(secConfig);
if (auto s = getIniFileSection(secConfig, SECTION_IPS))
IPS = *s;
if (auto s = getIniFileSection(secConfig, SECTION_IPS_FIXED))
IPS_FIXED = *s;
// if the user has specified ip:port then replace : with a space.
{
auto replaceColons = [](std::vector<std::string>& strVec) {
static std::regex const e(":([0-9]+)$");
for (auto& line : strVec)
{
// skip anything that might be an ipv6 address
if (std::count(line.begin(), line.end(), ':') != 1)
continue;
std::string const result = std::regex_replace(line, e, " $1");
// sanity check the result of the replace, should be same length
// as input
if (result.size() == line.size())
line = result;
}
};
replaceColons(IPS_FIXED);
replaceColons(IPS);
}
{
std::string dbPath;
if (getSingleSection(secConfig, "database_path", dbPath, j_))
{
boost::filesystem::path const p(dbPath);
legacy("database_path", boost::filesystem::absolute(p).string());
}
}
std::string strTemp;
if (getSingleSection(secConfig, SECTION_NETWORK_ID, strTemp, j_))
{
if (strTemp == "main")
{
NETWORK_ID = 0;
}
else if (strTemp == "testnet")
{
NETWORK_ID = 1;
}
else if (strTemp == "devnet")
{
NETWORK_ID = 2;
}
else
{
NETWORK_ID = beast::lexicalCastThrow<uint32_t>(strTemp);
}
}
if (getSingleSection(secConfig, SECTION_PEER_PRIVATE, strTemp, j_))
PEER_PRIVATE = beast::lexicalCastThrow<bool>(strTemp);
if (getSingleSection(secConfig, SECTION_PEERS_MAX, strTemp, j_))
{
PEERS_MAX = beast::lexicalCastThrow<std::size_t>(strTemp);
}
else
{
std::optional<std::size_t> peers_in_max{};
if (getSingleSection(secConfig, SECTION_PEERS_IN_MAX, strTemp, j_))
{
peers_in_max = beast::lexicalCastThrow<std::size_t>(strTemp);
if (*peers_in_max > 1000)
{
Throw<std::runtime_error>("Invalid value specified in [" SECTION_PEERS_IN_MAX
"] section; the value must be less or equal than 1000");
}
}
std::optional<std::size_t> peers_out_max{};
if (getSingleSection(secConfig, SECTION_PEERS_OUT_MAX, strTemp, j_))
{
peers_out_max = beast::lexicalCastThrow<std::size_t>(strTemp);
if (*peers_out_max < 10 || *peers_out_max > 1000)
{
Throw<std::runtime_error>("Invalid value specified in [" SECTION_PEERS_OUT_MAX
"] section; the value must be in range 10-1000");
}
}
// if one section is configured then the other must be configured too
if ((peers_in_max && !peers_out_max) || (peers_out_max && !peers_in_max))
{
Throw<std::runtime_error>("Both sections [" SECTION_PEERS_IN_MAX
"]"
"and [" SECTION_PEERS_OUT_MAX "] must be configured");
}
if (peers_in_max && peers_out_max)
{
PEERS_IN_MAX = *peers_in_max;
PEERS_OUT_MAX = *peers_out_max;
}
}
if (getSingleSection(secConfig, SECTION_NODE_SIZE, strTemp, j_))
{
if (boost::iequals(strTemp, "tiny"))
{
NODE_SIZE = 0;
}
else if (boost::iequals(strTemp, "small"))
{
NODE_SIZE = 1;
}
else if (boost::iequals(strTemp, "medium"))
{
NODE_SIZE = 2;
}
else if (boost::iequals(strTemp, "large"))
{
NODE_SIZE = 3;
}
else if (boost::iequals(strTemp, "huge"))
{
NODE_SIZE = 4;
}
else
{
NODE_SIZE = std::min<std::size_t>(4, beast::lexicalCastThrow<std::size_t>(strTemp));
}
}
if (getSingleSection(secConfig, SECTION_SIGNING_SUPPORT, strTemp, j_))
signingEnabled_ = beast::lexicalCastThrow<bool>(strTemp);
if (getSingleSection(secConfig, SECTION_ELB_SUPPORT, strTemp, j_))
ELB_SUPPORT = beast::lexicalCastThrow<bool>(strTemp);
getSingleSection(secConfig, SECTION_SSL_VERIFY_FILE, SSL_VERIFY_FILE, j_);
getSingleSection(secConfig, SECTION_SSL_VERIFY_DIR, SSL_VERIFY_DIR, j_);
if (getSingleSection(secConfig, SECTION_SSL_VERIFY, strTemp, j_))
SSL_VERIFY = beast::lexicalCastThrow<bool>(strTemp);
if (getSingleSection(secConfig, SECTION_RELAY_VALIDATIONS, strTemp, j_))
{
if (boost::iequals(strTemp, "all"))
{
RELAY_UNTRUSTED_VALIDATIONS = 1;
}
else if (boost::iequals(strTemp, "trusted"))
{
RELAY_UNTRUSTED_VALIDATIONS = 0;
}
else if (boost::iequals(strTemp, "drop_untrusted"))
{
RELAY_UNTRUSTED_VALIDATIONS = -1;
}
else
{
Throw<std::runtime_error>("Invalid value specified in [" SECTION_RELAY_VALIDATIONS
"] section");
}
}
if (getSingleSection(secConfig, SECTION_RELAY_PROPOSALS, strTemp, j_))
{
if (boost::iequals(strTemp, "all"))
{
RELAY_UNTRUSTED_PROPOSALS = 1;
}
else if (boost::iequals(strTemp, "trusted"))
{
RELAY_UNTRUSTED_PROPOSALS = 0;
}
else if (boost::iequals(strTemp, "drop_untrusted"))
{
RELAY_UNTRUSTED_PROPOSALS = -1;
}
else
{
Throw<std::runtime_error>("Invalid value specified in [" SECTION_RELAY_PROPOSALS
"] section");
}
}
if (exists(SECTION_VALIDATION_SEED) && exists(SECTION_VALIDATOR_TOKEN))
{
Throw<std::runtime_error>("Cannot have both [" SECTION_VALIDATION_SEED
"] and [" SECTION_VALIDATOR_TOKEN "] config sections");
}
if (getSingleSection(secConfig, SECTION_NETWORK_QUORUM, strTemp, j_))
NETWORK_QUORUM = beast::lexicalCastThrow<std::size_t>(strTemp);
FEES = setup_FeeVote(section("voting"));
/* [fee_default] is documented in the example config files as useful for
* things like offline transaction signing. Until that's completely
* deprecated, allow it to override the [voting] section. */
if (getSingleSection(secConfig, SECTION_FEE_DEFAULT, strTemp, j_))
FEES.reference_fee = beast::lexicalCastThrow<std::uint64_t>(strTemp);
if (getSingleSection(secConfig, SECTION_LEDGER_HISTORY, strTemp, j_))
{
if (boost::iequals(strTemp, "full"))
{
LEDGER_HISTORY = std::numeric_limits<decltype(LEDGER_HISTORY)>::max();
}
else if (boost::iequals(strTemp, "none"))
{
LEDGER_HISTORY = 0;
}
else
{
LEDGER_HISTORY = beast::lexicalCastThrow<std::uint32_t>(strTemp);
}
}
if (getSingleSection(secConfig, SECTION_FETCH_DEPTH, strTemp, j_))
{
if (boost::iequals(strTemp, "none"))
{
FETCH_DEPTH = 0;
}
else if (boost::iequals(strTemp, "full"))
{
FETCH_DEPTH = std::numeric_limits<decltype(FETCH_DEPTH)>::max();
}
else
{
FETCH_DEPTH = beast::lexicalCastThrow<std::uint32_t>(strTemp);
}
FETCH_DEPTH = std::max<uint32_t>(FETCH_DEPTH, 10);
}
// By default, validators don't have pathfinding enabled, unless it is
// explicitly requested by the server's admin.
if (exists(SECTION_VALIDATION_SEED) || exists(SECTION_VALIDATOR_TOKEN))
PATH_SEARCH_MAX = 0;
if (getSingleSection(secConfig, SECTION_PATH_SEARCH_OLD, strTemp, j_))
PATH_SEARCH_OLD = beast::lexicalCastThrow<int>(strTemp);
if (getSingleSection(secConfig, SECTION_PATH_SEARCH, strTemp, j_))
PATH_SEARCH = beast::lexicalCastThrow<int>(strTemp);
if (getSingleSection(secConfig, SECTION_PATH_SEARCH_FAST, strTemp, j_))
PATH_SEARCH_FAST = beast::lexicalCastThrow<int>(strTemp);
if (getSingleSection(secConfig, SECTION_PATH_SEARCH_MAX, strTemp, j_))
PATH_SEARCH_MAX = beast::lexicalCastThrow<int>(strTemp);
if (getSingleSection(secConfig, SECTION_DEBUG_LOGFILE, strTemp, j_))
DEBUG_LOGFILE = strTemp;
if (getSingleSection(secConfig, SECTION_SWEEP_INTERVAL, strTemp, j_))
{
SWEEP_INTERVAL = beast::lexicalCastThrow<std::size_t>(strTemp);
if (SWEEP_INTERVAL < 10 || SWEEP_INTERVAL > 600)
{
Throw<std::runtime_error>("Invalid " SECTION_SWEEP_INTERVAL
": must be between 10 and 600 inclusive");
}
}
if (getSingleSection(secConfig, SECTION_WORKERS, strTemp, j_))
{
WORKERS = beast::lexicalCastThrow<int>(strTemp);
if (WORKERS < 1 || WORKERS > 1024)
{
Throw<std::runtime_error>("Invalid " SECTION_WORKERS
": must be between 1 and 1024 inclusive.");
}
}
if (getSingleSection(secConfig, SECTION_IO_WORKERS, strTemp, j_))
{
IO_WORKERS = beast::lexicalCastThrow<int>(strTemp);
if (IO_WORKERS < 1 || IO_WORKERS > 1024)
{
Throw<std::runtime_error>("Invalid " SECTION_IO_WORKERS
": must be between 1 and 1024 inclusive.");
}
}
if (getSingleSection(secConfig, SECTION_PREFETCH_WORKERS, strTemp, j_))
{
PREFETCH_WORKERS = beast::lexicalCastThrow<int>(strTemp);
if (PREFETCH_WORKERS < 1 || PREFETCH_WORKERS > 1024)
{
Throw<std::runtime_error>("Invalid " SECTION_PREFETCH_WORKERS
": must be between 1 and 1024 inclusive.");
}
}
if (getSingleSection(secConfig, SECTION_COMPRESSION, strTemp, j_))
COMPRESSION = beast::lexicalCastThrow<bool>(strTemp);
if (getSingleSection(secConfig, SECTION_LEDGER_REPLAY, strTemp, j_))
LEDGER_REPLAY = beast::lexicalCastThrow<bool>(strTemp);
if (exists(SECTION_REDUCE_RELAY))
{
auto sec = section(SECTION_REDUCE_RELAY);
///////////////////// !!TEMPORARY CODE BLOCK!! ////////////////////////
// vp_enable config option is deprecated by vp_base_squelch_enable //
// This option is kept for backwards compatibility. When squelching //
// is the default algorithm, it must be replaced with: //
// VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = //
// sec.value_or("vp_base_squelch_enable", true); //
if (sec.exists("vp_base_squelch_enable") && sec.exists("vp_enable"))
{
Throw<std::runtime_error>("Invalid " SECTION_REDUCE_RELAY
" cannot specify both vp_base_squelch_enable and vp_enable "
"options. "
"vp_enable was deprecated and replaced by "
"vp_base_squelch_enable");
}
if (sec.exists("vp_base_squelch_enable"))
{
VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = sec.value_or("vp_base_squelch_enable", false);
}
else if (sec.exists("vp_enable"))
{
VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = sec.value_or("vp_enable", false);
}
else
{
VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = false;
}
///////////////// !!END OF TEMPORARY CODE BLOCK!! /////////////////////
///////////////////// !!TEMPORARY CODE BLOCK!! ///////////////////////
// Temporary squelching config for the peers selected as a source of //
// validator messages. The config must be removed once squelching is //
// made the default routing algorithm. //
VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS =
sec.value_or("vp_base_squelch_max_selected_peers", 5);
if (VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS < 3)
{
Throw<std::runtime_error>("Invalid " SECTION_REDUCE_RELAY
" vp_base_squelch_max_selected_peers must be "
"greater than or equal to 3");
}
///////////////// !!END OF TEMPORARY CODE BLOCK!! /////////////////////
TX_REDUCE_RELAY_ENABLE = sec.value_or("tx_enable", false);
TX_REDUCE_RELAY_METRICS = sec.value_or("tx_metrics", false);
TX_REDUCE_RELAY_MIN_PEERS = sec.value_or("tx_min_peers", 20);
TX_RELAY_PERCENTAGE = sec.value_or("tx_relay_percentage", 25);
if (TX_RELAY_PERCENTAGE < 10 || TX_RELAY_PERCENTAGE > 100 || TX_REDUCE_RELAY_MIN_PEERS < 10)
{
Throw<std::runtime_error>("Invalid " SECTION_REDUCE_RELAY
", tx_min_peers must be greater than or equal to 10"
", tx_relay_percentage must be greater than or equal to 10 "
"and less than or equal to 100");
}
}
if (getSingleSection(secConfig, SECTION_MAX_TRANSACTIONS, strTemp, j_))
{
MAX_TRANSACTIONS =
std::clamp(beast::lexicalCastThrow<int>(strTemp), MIN_JOB_QUEUE_TX, MAX_JOB_QUEUE_TX);
}
if (getSingleSection(secConfig, SECTION_SERVER_DOMAIN, strTemp, j_))
{
if (!isProperlyFormedTomlDomain(strTemp))
{
Throw<std::runtime_error>(
"Invalid " SECTION_SERVER_DOMAIN
": the domain name does not appear to meet the requirements.");
}
SERVER_DOMAIN = strTemp;
}
if (exists(SECTION_OVERLAY))
{
auto const sec = section(SECTION_OVERLAY);
using namespace std::chrono;
try
{
if (auto val = sec.get("max_unknown_time"))
MAX_UNKNOWN_TIME = seconds{beast::lexicalCastThrow<std::uint32_t>(*val)};
}
catch (...)
{
Throw<std::runtime_error>("Invalid value 'max_unknown_time' in " SECTION_OVERLAY
": must be of the form '<number>' representing seconds.");
}
if (MAX_UNKNOWN_TIME < seconds{300} || MAX_UNKNOWN_TIME > seconds{1800})
{
Throw<std::runtime_error>(
"Invalid value 'max_unknown_time' in " SECTION_OVERLAY
": the time must be between 300 and 1800 seconds, inclusive.");
}
try
{
if (auto val = sec.get("max_diverged_time"))
MAX_DIVERGED_TIME = seconds{beast::lexicalCastThrow<std::uint32_t>(*val)};
}
catch (...)
{
Throw<std::runtime_error>("Invalid value 'max_diverged_time' in " SECTION_OVERLAY
": must be of the form '<number>' representing seconds.");
}
if (MAX_DIVERGED_TIME < seconds{60} || MAX_DIVERGED_TIME > seconds{900})
{
Throw<std::runtime_error>("Invalid value 'max_diverged_time' in " SECTION_OVERLAY
": the time must be between 60 and 900 seconds, inclusive.");
}
}
if (getSingleSection(secConfig, SECTION_AMENDMENT_MAJORITY_TIME, strTemp, j_))
{
using namespace std::chrono;
boost::regex const re("^\\s*(\\d+)\\s*(minutes|hours|days|weeks)\\s*(\\s+.*)?$");
boost::smatch match;
if (!boost::regex_match(strTemp, match, re))
{
Throw<std::runtime_error>("Invalid " SECTION_AMENDMENT_MAJORITY_TIME
", must be: [0-9]+ [minutes|hours|days|weeks]");
}
std::uint32_t const duration = beast::lexicalCastThrow<std::uint32_t>(match[1].str());
if (boost::iequals(match[2], "minutes"))
{
AMENDMENT_MAJORITY_TIME = minutes(duration);
}
else if (boost::iequals(match[2], "hours"))
{
AMENDMENT_MAJORITY_TIME = hours(duration);
}
else if (boost::iequals(match[2], "days"))
{
AMENDMENT_MAJORITY_TIME = days(duration);
}
else if (boost::iequals(match[2], "weeks"))
{
AMENDMENT_MAJORITY_TIME = weeks(duration);
}
if (AMENDMENT_MAJORITY_TIME < minutes(15))
{
Throw<std::runtime_error>("Invalid " SECTION_AMENDMENT_MAJORITY_TIME
", the minimum amount of time an amendment must hold a "
"majority is 15 minutes");
}
}
if (getSingleSection(secConfig, SECTION_BETA_RPC_API, strTemp, j_))
BETA_RPC_API = beast::lexicalCastThrow<bool>(strTemp);
// Do not load trusted validator configuration for standalone mode
if (!RUN_STANDALONE)
{
// If a file was explicitly specified, then throw if the
// path is malformed or if the file does not exist or is
// not a file.
// If the specified file is not an absolute path, then look
// for it in the same directory as the config file.
// If no path was specified, then look for validators.txt
// in the same directory as the config file, but don't complain
// if we can't find it.
boost::filesystem::path validatorsFile;
if (getSingleSection(secConfig, SECTION_VALIDATORS_FILE, strTemp, j_))
{
validatorsFile = strTemp;
if (validatorsFile.empty())
{
Throw<std::runtime_error>("Invalid path specified in [" SECTION_VALIDATORS_FILE
"]");
}
if (!validatorsFile.is_absolute() && !CONFIG_DIR.empty())
validatorsFile = CONFIG_DIR / validatorsFile;
if (!boost::filesystem::exists(validatorsFile))
{
Throw<std::runtime_error>(
"The file specified in [" SECTION_VALIDATORS_FILE
"] "
"does not exist: " +
validatorsFile.string());
}
else if (
!boost::filesystem::is_regular_file(validatorsFile) &&
!boost::filesystem::is_symlink(validatorsFile))
{
Throw<std::runtime_error>(
"Invalid file specified in [" SECTION_VALIDATORS_FILE "]: " +
validatorsFile.string());
}
}
else if (!CONFIG_DIR.empty())
{
validatorsFile = CONFIG_DIR / validatorsFileName;
if (!validatorsFile.empty())
{
if (!boost::filesystem::exists(validatorsFile))
{
validatorsFile.clear();
}
else if (
!boost::filesystem::is_regular_file(validatorsFile) &&
!boost::filesystem::is_symlink(validatorsFile))
{
validatorsFile.clear();
}
}
}
if (!validatorsFile.empty() && boost::filesystem::exists(validatorsFile) &&
(boost::filesystem::is_regular_file(validatorsFile) ||
boost::filesystem::is_symlink(validatorsFile)))
{
boost::system::error_code ec;
auto const data = getFileContents(ec, validatorsFile);
if (ec)
{
Throw<std::runtime_error>(
"Failed to read '" + validatorsFile.string() + "'." +
std::to_string(ec.value()) + ": " + ec.message());
}
auto iniFile = parseIniFile(data, true);
auto entries = getIniFileSection(iniFile, SECTION_VALIDATORS);
if (entries != nullptr)
section(SECTION_VALIDATORS).append(*entries);
auto valKeyEntries = getIniFileSection(iniFile, SECTION_VALIDATOR_KEYS);
if (valKeyEntries != nullptr)
section(SECTION_VALIDATOR_KEYS).append(*valKeyEntries);
auto valSiteEntries = getIniFileSection(iniFile, SECTION_VALIDATOR_LIST_SITES);
if (valSiteEntries != nullptr)
section(SECTION_VALIDATOR_LIST_SITES).append(*valSiteEntries);
auto valListKeys = getIniFileSection(iniFile, SECTION_VALIDATOR_LIST_KEYS);
if (valListKeys != nullptr)
section(SECTION_VALIDATOR_LIST_KEYS).append(*valListKeys);
auto valListThreshold = getIniFileSection(iniFile, SECTION_VALIDATOR_LIST_THRESHOLD);
if (valListThreshold != nullptr)
section(SECTION_VALIDATOR_LIST_THRESHOLD).append(*valListThreshold);
if ((entries == nullptr) && (valKeyEntries == nullptr) && (valListKeys == nullptr))
{
Throw<std::runtime_error>(
"The file specified in [" SECTION_VALIDATORS_FILE
"] "
"does not contain a [" SECTION_VALIDATORS
"], "
"[" SECTION_VALIDATOR_KEYS
"] or "
"[" SECTION_VALIDATOR_LIST_KEYS
"]"
" section: " +
validatorsFile.string());
}
}
VALIDATOR_LIST_THRESHOLD = [&]() -> std::optional<std::size_t> {
auto const& listThreshold = section(SECTION_VALIDATOR_LIST_THRESHOLD);
if (listThreshold.lines().empty())
{
return std::nullopt;
}
if (listThreshold.values().size() == 1)
{
auto strTemp = listThreshold.values()[0];
auto const listThreshold = beast::lexicalCastThrow<std::size_t>(strTemp);
if (listThreshold == 0)
{
return std::nullopt; // NOTE: Explicitly ask for computed
}
if (listThreshold > section(SECTION_VALIDATOR_LIST_KEYS).values().size())
{
Throw<std::runtime_error>(
"Value in config section "
"[" SECTION_VALIDATOR_LIST_THRESHOLD
"] exceeds the number of configured list keys");
}
return listThreshold;
}
Throw<std::runtime_error>(
"Config section "
"[" SECTION_VALIDATOR_LIST_THRESHOLD "] should contain single value only");
}();
// Consolidate [validator_keys] and [validators]
section(SECTION_VALIDATORS).append(section(SECTION_VALIDATOR_KEYS).lines());
if (!section(SECTION_VALIDATOR_LIST_SITES).lines().empty() &&
section(SECTION_VALIDATOR_LIST_KEYS).lines().empty())
{
Throw<std::runtime_error>(
"[" + std::string(SECTION_VALIDATOR_LIST_KEYS) + "] config section is missing");
}
}
{
auto const part = section("features");
for (auto const& s : part.values())
{
if (auto const f = getRegisteredFeature(s))
{
features.insert(*f);
}
else
{
Throw<std::runtime_error>("Unknown feature: " + s + " in config file.");
}
}
}
// This doesn't properly belong here, but check to make sure that the
// value specified for network_quorum is achievable:
{
auto pm = PEERS_MAX;
// FIXME this apparently magic value is actually defined as a constant
// elsewhere (see defaultMaxPeers) but we handle this check here.
if (pm == 0)
pm = 21;
if (NETWORK_QUORUM > pm)
{
Throw<std::runtime_error>(
"The minimum number of required peers (network_quorum) exceeds "
"the maximum number of allowed peers (peers_max)");
}
}
}
boost::filesystem::path
Config::getDebugLogFile() const
{
auto log_file = DEBUG_LOGFILE;
if (!log_file.empty() && !log_file.is_absolute())
{
// Unless an absolute path for the log file is specified, the
// path is relative to the config file directory.
log_file = boost::filesystem::absolute(log_file, CONFIG_DIR);
}
if (!log_file.empty())
{
auto log_dir = log_file.parent_path();
if (!boost::filesystem::is_directory(log_dir))
{
boost::system::error_code ec;
boost::filesystem::create_directories(log_dir, ec);
// If we fail, we warn but continue so that the calling code can
// decide how to handle this situation.
if (ec)
{
std::cerr << "Unable to create log file path " << log_dir << ": " << ec.message()
<< '\n';
}
}
}
return log_file;
}
int
Config::getValueFor(SizedItem item, std::optional<std::size_t> node) const
{
auto const index = static_cast<std::underlying_type_t<SizedItem>>(item);
XRPL_ASSERT(index < sizedItems.size(), "xrpl::Config::getValueFor : valid index input");
XRPL_ASSERT(!node || *node <= 4, "xrpl::Config::getValueFor : unset or valid node");
return sizedItems.at(index).second.at(node.value_or(NODE_SIZE));
}
FeeSetup
setup_FeeVote(Section const& section)
{
FeeSetup setup;
{
std::uint64_t temp = 0;
if (set(temp, "reference_fee", section) &&
temp <= std::numeric_limits<XRPAmount::value_type>::max())
setup.reference_fee = temp;
}
{
std::uint32_t temp = 0;
if (set(temp, "account_reserve", section))
setup.account_reserve = temp;
if (set(temp, "owner_reserve", section))
setup.owner_reserve = temp;
}
return setup;
}
DatabaseCon::Setup
setup_DatabaseCon(Config const& c, std::optional<beast::Journal> j)
{
DatabaseCon::Setup setup;
setup.startUp = c.START_UP;
setup.standAlone = c.standalone();
setup.dataDir = c.legacy("database_path");
if (!setup.standAlone && setup.dataDir.empty())
{
Throw<std::runtime_error>("database_path must be set.");
}
if (!setup.globalPragma)
{
auto const& sqlite = c.section("sqlite");
auto result = std::make_unique<std::vector<std::string>>();
result->reserve(3);
// defaults
std::string safety_level;
std::string journal_mode = "wal";
std::string synchronous = "normal";
std::string temp_store = "file";
bool showRiskWarning = false;
if (set(safety_level, "safety_level", sqlite))
{
if (boost::iequals(safety_level, "low"))
{
// low safety defaults
journal_mode = "memory";
synchronous = "off";
temp_store = "memory";
showRiskWarning = true;
}
else if (!boost::iequals(safety_level, "high"))
{
Throw<std::runtime_error>("Invalid safety_level value: " + safety_level);
}
}
{
// #journal_mode Valid values : delete, truncate, persist,
// memory, wal, off
if (set(journal_mode, "journal_mode", sqlite) && !safety_level.empty())
{
Throw<std::runtime_error>(
"Configuration file may not define both "
"\"safety_level\" and \"journal_mode\"");
}
bool const higherRisk =
boost::iequals(journal_mode, "memory") || boost::iequals(journal_mode, "off");
showRiskWarning = showRiskWarning || higherRisk;
if (higherRisk || boost::iequals(journal_mode, "delete") ||
boost::iequals(journal_mode, "truncate") ||
boost::iequals(journal_mode, "persist") || boost::iequals(journal_mode, "wal"))
{
result->emplace_back(
boost::str(boost::format(CommonDBPragmaJournal) % journal_mode));
}
else
{
Throw<std::runtime_error>("Invalid journal_mode value: " + journal_mode);
}
}
{
// #synchronous Valid values : off, normal, full, extra
if (set(synchronous, "synchronous", sqlite) && !safety_level.empty())
{
Throw<std::runtime_error>(
"Configuration file may not define both "
"\"safety_level\" and \"synchronous\"");
}
bool const higherRisk = boost::iequals(synchronous, "off");
showRiskWarning = showRiskWarning || higherRisk;
if (higherRisk || boost::iequals(synchronous, "normal") ||
boost::iequals(synchronous, "full") || boost::iequals(synchronous, "extra"))
{
result->emplace_back(boost::str(boost::format(CommonDBPragmaSync) % synchronous));
}
else
{
Throw<std::runtime_error>("Invalid synchronous value: " + synchronous);
}
}
{
// #temp_store Valid values : default, file, memory
if (set(temp_store, "temp_store", sqlite) && !safety_level.empty())
{
Throw<std::runtime_error>(
"Configuration file may not define both "
"\"safety_level\" and \"temp_store\"");
}
bool const higherRisk = boost::iequals(temp_store, "memory");
showRiskWarning = showRiskWarning || higherRisk;
if (higherRisk || boost::iequals(temp_store, "default") ||
boost::iequals(temp_store, "file"))
{
result->emplace_back(boost::str(boost::format(CommonDBPragmaTemp) % temp_store));
}
else
{
Throw<std::runtime_error>("Invalid temp_store value: " + temp_store);
}
}
if (showRiskWarning && j && c.LEDGER_HISTORY > SQLITE_TUNING_CUTOFF)
{
JLOG(j->warn()) << "reducing the data integrity guarantees from the "
"default [sqlite] behavior is not recommended for "
"nodes storing large amounts of history, because of the "
"difficulty inherent in rebuilding corrupted data.";
}
XRPL_ASSERT(
result->size() == 3, "xrpl::setup_DatabaseCon::globalPragma : result size is 3");
setup.globalPragma = std::move(result);
}
setup.useGlobalPragma = true;
auto setPragma = [](std::string& pragma, std::string const& key, int64_t value) {
pragma = "PRAGMA " + key + "=" + std::to_string(value) + ";";
};
// Lgr Pragma
setPragma(setup.lgrPragma[0], "journal_size_limit", 1582080);
// TX Pragma
int64_t page_size = 4096;
int64_t journal_size_limit = 1582080;
if (c.exists("sqlite"))
{
auto& s = c.section("sqlite");
set(journal_size_limit, "journal_size_limit", s);
set(page_size, "page_size", s);
if (page_size < 512 || page_size > 65536)
Throw<std::runtime_error>("Invalid page_size. Must be between 512 and 65536.");
if ((page_size & (page_size - 1)) != 0)
Throw<std::runtime_error>("Invalid page_size. Must be a power of 2.");
}
setPragma(setup.txPragma[0], "page_size", page_size);
setPragma(setup.txPragma[1], "journal_size_limit", journal_size_limit);
setPragma(setup.txPragma[2], "max_page_count", 4294967294);
setPragma(setup.txPragma[3], "mmap_size", 17179869184);
return setup;
}
} // namespace xrpl
Reference in New Issue View Git Blame Copy Permalink