OpenLedger.h

#pragma once
 
#include <xrpld/core/Config.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/ledger/CachedSLEs.h>
#include <xrpl/ledger/CanonicalTXSet.h>
#include <xrpl/ledger/Ledger.h>
#include <xrpl/ledger/OpenView.h>
 
#include <mutex>
 
namespace xrpl {
 
// How many total extra passes we make
// We must ensure we make at least one non-retriable pass
#define LEDGER_TOTAL_PASSES 3
 
// How many extra retry passes we
// make if the previous retry pass made changes
#define LEDGER_RETRY_PASSES 1
 
using OrderedTxs = CanonicalTXSet;
 
//------------------------------------------------------------------------------
 
class OpenLedger
{
private:
    beast::Journal const j_;
    CachedSLEs& cache_;
    std::mutex mutable modify_mutex_;
    std::mutex mutable current_mutex_;
    std::shared_ptr<OpenView const> current_;
 
public:
    using modify_type = std::function<bool(OpenView&, beast::Journal)>;
 
    OpenLedger() = delete;
    OpenLedger(OpenLedger const&) = delete;
    OpenLedger&
    operator=(OpenLedger const&) = delete;
 
    explicit OpenLedger(
        std::shared_ptr<Ledger const> const& ledger,
        CachedSLEs& cache,
        beast::Journal journal);
 
    bool
    empty() const;
 
    std::shared_ptr<OpenView const>
    current() const;
 
    bool
    modify(modify_type const& f);
 
    void
    accept(
        Application& app,
        Rules const& rules,
        std::shared_ptr<Ledger const> const& ledger,
        OrderedTxs const& locals,
        bool retriesFirst,
        OrderedTxs& retries,
        ApplyFlags flags,
        std::string const& suffix = "",
        modify_type const& f = {});
 
private:
    template <class FwdRange>
    static void
    apply(
        Application& app,
        OpenView& view,
        ReadView const& check,
        FwdRange const& txs,
        OrderedTxs& retries,
        ApplyFlags flags,
        beast::Journal j);
 
    enum Result { success, failure, retry };
 
    std::shared_ptr<OpenView>
    create(Rules const& rules, std::shared_ptr<Ledger const> const& ledger);
 
    static Result
    apply_one(
        Application& app,
        OpenView& view,
        std::shared_ptr<STTx const> const& tx,
        bool retry,
        ApplyFlags flags,
        beast::Journal j);
};
 
//------------------------------------------------------------------------------
 
template <class FwdRange>
void
OpenLedger::apply(
    Application& app,
    OpenView& view,
    ReadView const& check,
    FwdRange const& txs,
    OrderedTxs& retries,
    ApplyFlags flags,
    beast::Journal j)
{
    for (auto iter = txs.begin(); iter != txs.end(); ++iter)
    {
        try
        {
            // Dereferencing the iterator can throw since it may be transformed.
            auto const tx = *iter;
            auto const txId = tx->getTransactionID();
            if (check.txExists(txId))
                continue;
            auto const result = apply_one(app, view, tx, true, flags, j);
            if (result == Result::retry)
                retries.insert(tx);
        }
        catch (std::exception const& e)
        {
            JLOG(j.error()) << "OpenLedger::apply: Caught exception: " << e.what();
        }
    }
    bool retry = true;
    for (int pass = 0; pass < LEDGER_TOTAL_PASSES; ++pass)
    {
        int changes = 0;
        auto iter = retries.begin();
        while (iter != retries.end())
        {
            switch (apply_one(app, view, iter->second, retry, flags, j))
            {
                case Result::success:
                    ++changes;
                    [[fallthrough]];
                case Result::failure:
                    iter = retries.erase(iter);
                    break;
                case Result::retry:
                    ++iter;
            }
        }
        // A non-retry pass made no changes
        if (!changes && !retry)
            return;
        // Stop retriable passes
        if (!changes || (pass >= LEDGER_RETRY_PASSES))
            retry = false;
    }
 
    // If there are any transactions left, we must have
    // tried them in at least one final pass
    XRPL_ASSERT(retries.empty() || !retry, "xrpl::OpenLedger::apply : valid retries");
}
 
//------------------------------------------------------------------------------
 
// For debug logging
 
std::string
debugTxstr(std::shared_ptr<STTx const> const& tx);
 
std::string
debugTostr(OrderedTxs const& set);
 
std::string
debugTostr(SHAMap const& set);
 
std::string
debugTostr(std::shared_ptr<ReadView const> const& view);
 
}  // namespace xrpl