src/xrpld/core/Config.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/hash/uhash.h>
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/config/BasicConfig.h>
#include <xrpl/core/StartUpType.h>
#include <xrpl/protocol/Fees.h>
#include <xrpl/protocol/SystemParameters.h>  // VFALCO Breaks levelization
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/rdb/DatabaseCon.h>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_set>
#include <utility>
#include <vector>
 
namespace xrpl {
 
class Rules;
 
//------------------------------------------------------------------------------
 
enum class SizedItem : std::size_t {
    SweepInterval = 0,
    TreeCacheSize,
    TreeCacheAge,
    LedgerSize,
    LedgerAge,
    LedgerFetch,
    HashNodeDbCache,
    TxnDbCache,
    LgrDbCache,
    OpenFinalLimit,
    BurstSize,
    RamSizeGb,
    AccountIdCacheSize,
};

struct FeeSetup
{
    XRPAmount referenceFee{10};

    XRPAmount accountReserve{10 * kDropsPerXrp};

    XRPAmount ownerReserve{2 * kDropsPerXrp};
 
    /* (Remember to update the example cfg files when changing any of these
     * values.) */

    [[nodiscard]] Fees
    toFees() const
    {
        return Fees{referenceFee, accountReserve, ownerReserve};
    }
};
 
//  This entire derived class is deprecated.
//  For new config information use the style implied
//  in the base class. For existing config information
//  try to refactor code to use the new style.
//
class Config : public BasicConfig
{
public:
    // Settings related to the configuration file location and directories
    static constexpr std::string_view kConfigFileName = "xrpld.cfg";
    static constexpr std::string_view kConfigLegacyName = "rippled.cfg";
    static constexpr std::string_view kDatabaseDirName = "db";
    static constexpr std::string_view kValidatorsFileName = "validators.txt";

    [[nodiscard]] std::filesystem::path
    getDebugLogFile() const;
 
private:
    std::filesystem::path configFile_;
 
public:
    std::filesystem::path configDir;
 
private:
    std::filesystem::path debugLogfile_;
 
    void
    load();
    beast::Journal const j_;
 
    bool quiet_ = false;   // Minimize logging verbosity.
    bool silent_ = false;  // No output to console after startup.
    bool runStandalone_ = false;
 
    bool useTxTables_ = true;

    bool signingEnabled_ = false;
 
    // The amount of RAM, in bytes, that we detected on this system.
    std::uint64_t const ramSize_;
 
public:
    bool doImport = false;
    bool elbSupport = false;
 
    // Entries from [ips] config stanza
    std::vector<std::string> ips;
 
    // Entries from [ips_fixed] config stanza
    std::vector<std::string> ipsFixed;
 
    StartUpType startUp = StartUpType::Normal;
 
    bool startValid = false;
 
    std::string startLedger;
 
    std::optional<UInt256> trapTxHash;
 
    // Network parameters
    uint32_t networkId = 0;
 
    // Note: The following parameters do not relate to the UNL or trust at all
    // Minimum number of nodes to consider the network present
    std::size_t networkQuorum = 1;
 
    // Peer networking parameters
    // 1 = relay, 0 = do not relay (but process), -1 = drop completely (do NOT
    // process)
    int relayUntrustedValidations = 1;
    int relayUntrustedProposals = 0;
 
    // True to ask peers not to relay current IP.
    bool peerPrivate = false;
    // peers_max is a legacy configuration, which is going to be replaced
    // with individual inbound peers peers_in_max and outbound peers
    // peers_out_max configuration. for now we support both the legacy and
    // the new configuration. if peers_max is configured then peers_in_max and
    // peers_out_max are ignored.
    std::size_t peersMax = 0;
    std::size_t peersOutMax = 0;
    std::size_t peersInMax = 0;
 
    // Path searching: these were reasonable default values at some point but
    //                 further research is needed to decide if they still are
    //                 and whether all of them are needed.
    //
    //                 The performance and resource consumption of a server can
    //                 be dramatically impacted by changing these configuration
    //                 options; higher values result in exponentially higher
    //                 resource usage.
    //
    //                 Servers operating as validators disable path finding by
    //                 default by setting the `PATH_SEARCH_MAX` option to 0
    //                 unless it is explicitly set in the configuration file.
    int pathSearchOld = 2;
    int pathSearch = 2;
    int pathSearchFast = 2;
    int pathSearchMax = 3;
 
    // Validation
    std::optional<std::size_t> validationQuorum;  // validations to consider ledger authoritative
 
    FeeSetup fees;
 
    // Node storage configuration
    std::uint32_t ledgerHistory = 256;
    std::uint32_t fetchDepth = 1000000000;
 
    // Tunable that adjusts various parameters, typically associated
    // with hardware parameters (RAM size and CPU cores). The default
    // is 'tiny'.
    std::size_t nodeSize = 0;
 
    bool sslVerify = true;
    std::string sslVerifyFile;
    std::string sslVerifyDir;
 
    // Compression
    bool compression = false;
 
    // Enable the experimental Ledger Replay functionality
    bool ledgerReplay = false;
 
    // Work queue limits
    int maxTransactions = 250;
    static constexpr int kMaxJobQueueTx = 1000;
    static constexpr int kMinJobQueueTx = 100;
 
    // Optional override for the per-connection subscription cap. Unset means
    // use the built-in default (kMaxSubscriptionsPerConnection in InfoSub.h).
    // Kept as an override here, rather than the default itself, so the core
    // module need not depend on the server module that owns the constant.
    std::optional<std::size_t> maxSubscriptionsPerConnection;
 
    // Amendment majority time
    std::chrono::seconds amendmentMajorityTime = kDefaultAmendmentMajorityTime;
 
    // Thread pool configuration (0 = choose for me)
    int workers = 0;          // jobqueue thread count. default: upto 6
    int ioWorkers = 0;        // io svc thread count. default: 2
    int prefetchWorkers = 0;  // prefetch thread count. default: 4
 
    // Can only be set in code, specifically unit tests
    bool forceMultiThread = false;
 
    // Normally the sweep timer is automatically deduced based on the node
    // size, but we allow admins to explicitly set it in the config.
    std::optional<int> sweepInterval;
 
    // Reduce-relay - Experimental parameters to control p2p routing algorithms
 
    // Enable base squelching of duplicate validation/proposal messages
    bool vpReduceRelayBaseSquelchEnable = false;

    // 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                                 //
    std::size_t vpReduceRelaySquelchMaxSelectedPeers = 5;
 
    // Transaction reduce-relay feature
    bool txReduceRelayEnable = false;
    // If tx reduce-relay feature is disabled
    // and this flag is enabled then some
    // tx-related metrics is collected. It
    // is ignored if tx reduce-relay feature is
    // enabled. It is used in debugging to compare
    // metrics with the feature disabled/enabled.
    bool txReduceRelayMetrics = false;
    // Minimum peers a server should have before
    // selecting random peers
    std::size_t txReduceRelayMinPeers = 20;
    // Percentage of peers with the tx reduce-relay feature enabled
    // to relay to out of total active peers
    std::size_t txRelayPercentage = 25;
 
    // These override the command line client settings
    std::optional<beast::ip::Endpoint> rpcIp;
 
    std::unordered_set<UInt256, beast::Uhash<>> features;
 
    std::string serverDomain;
 
    // How long can a peer remain in the "unknown" state
    std::chrono::seconds maxUnknownTime{600};
 
    // How long can a peer remain in the "diverged" state
    std::chrono::seconds maxDivergedTime{300};
 
    // Optional overrides for how many manifests are kept in the cache and
    // carried in one TMManifests message, split by whether this node lists the
    // validator. Unset means use the built-in defaults (kMaxUntrustedCount and
    // kMaxTrustedCount in Manifest.h). Kept as overrides here, rather than the
    // defaults themselves, so the core module need not depend on the server
    // module that owns the constants.
    std::optional<std::size_t> maxUntrustedCount;
    std::optional<std::size_t> maxTrustedCount;
 
    // Bounds for both counts above. The lower bound leaves room for a small
    // network or a deliberately tight limit; note that setting a count below
    // what peers actually send means their manifest messages are dropped for
    // being oversized. The upper bound keeps the implied message size well
    // under the overall protocol message limit.
    static constexpr std::size_t kMinManifestCount = 50;
    static constexpr std::size_t kMaxManifestCount = 1000;
 
    // Enable the beta API version
    bool betaRpcApi = false;
 
    // First, attempt to load the latest ledger directly from disk.
    bool fastLoad = false;
    // When starting xrpld with existing database it do not know it has those
    // ledgers locally until the server naturally tries to backfill. This makes
    // is difficult to test some functionality (in particular performance
    // testing sidechains). With this variable the user is able to force xrpld
    // to consider the ledger range to be present. It should be used for testing
    // only.
    std::optional<std::pair<std::uint32_t, std::uint32_t>> forcedLedgerRangePresent;
 
    std::optional<std::size_t> validatorListThreshold;
 
public:
    Config();
 
    /* Be very careful to make sure these bool params
        are in the right order. */
    void
    setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStandalone);
 
    void
    setupControl(bool bQuiet, bool bSilent, bool bStandalone);

    void
    loadFromString(std::string const& fileContents);
 
    [[nodiscard]] bool
    quiet() const
    {
        return quiet_;
    }
    [[nodiscard]] bool
    silent() const
    {
        return silent_;
    }
    [[nodiscard]] bool
    standalone() const
    {
        return runStandalone_;
    }
 
    [[nodiscard]] bool
    useTxTables() const
    {
        return useTxTables_;
    }
 
    [[nodiscard]] bool
    canSign() const
    {
        return signingEnabled_;
    }

    [[nodiscard]] int
    getValueFor(SizedItem item, std::optional<std::size_t> node = std::nullopt) const;
 
    [[nodiscard]] beast::Journal
    journal() const
    {
        return j_;
    }
};
 
FeeSetup
setupFeeVote(Section const& section);
 
DatabaseCon::Setup
setupDatabaseCon(Config const& c, std::optional<beast::Journal> j = std::nullopt);
 
}  // namespace xrpl