LedgerHistory.h

#ifndef XRPL_APP_LEDGER_LEDGERHISTORY_H_INCLUDED
#define XRPL_APP_LEDGER_LEDGERHISTORY_H_INCLUDED
 
#include <xrpld/app/ledger/Ledger.h>
#include <xrpld/app/main/Application.h>
 
#include <xrpl/beast/insight/Collector.h>
#include <xrpl/protocol/RippleLedgerHash.h>
 
#include <optional>
 
namespace ripple {
 
// VFALCO TODO Rename to OldLedgers ?
 
class LedgerHistory
{
public:
    LedgerHistory(
        beast::insight::Collector::ptr const& collector,
        Application& app);
 
    bool
    insert(std::shared_ptr<Ledger const> const& ledger, bool validated);
 
    float
    getCacheHitRate()
    {
        return m_ledgers_by_hash.getHitRate();
    }
 
    std::shared_ptr<Ledger const>
    getLedgerBySeq(LedgerIndex ledgerIndex);
 
    std::shared_ptr<Ledger const>
    getLedgerByHash(LedgerHash const& ledgerHash);
 
    LedgerHash
    getLedgerHash(LedgerIndex ledgerIndex);
 
    void
    sweep()
    {
        m_ledgers_by_hash.sweep();
        m_consensus_validated.sweep();
    }
 
    void
    builtLedger(
        std::shared_ptr<Ledger const> const&,
        uint256 const& consensusHash,
        Json::Value);
 
    void
    validatedLedger(
        std::shared_ptr<Ledger const> const&,
        std::optional<uint256> const& consensusHash);
 
    bool
    fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash);
 
    void
    clearLedgerCachePrior(LedgerIndex seq);
 
private:
    void
    handleMismatch(
        LedgerHash const& built,
        LedgerHash const& valid,
        std::optional<uint256> const& builtConsensusHash,
        std::optional<uint256> const& validatedConsensusHash,
        Json::Value const& consensus);
 
    Application& app_;
    beast::insight::Collector::ptr collector_;
    beast::insight::Counter mismatch_counter_;
 
    using LedgersByHash = TaggedCache<LedgerHash, Ledger const>;
 
    LedgersByHash m_ledgers_by_hash;
 
    // Maps ledger indexes to the corresponding hashes
    // For debug and logging purposes
    struct cv_entry
    {
        // Hash of locally built ledger
        std::optional<LedgerHash> built;
        // Hash of the validated ledger
        std::optional<LedgerHash> validated;
        // Hash of locally accepted consensus transaction set
        std::optional<uint256> builtConsensusHash;
        // Hash of validated consensus transaction set
        std::optional<uint256> validatedConsensusHash;
        // Consensus metadata of built ledger
        std::optional<Json::Value> consensus;
    };
    using ConsensusValidated = TaggedCache<LedgerIndex, cv_entry>;
    ConsensusValidated m_consensus_validated;
 
    // Maps ledger indexes to the corresponding hash.
    std::map<LedgerIndex, LedgerHash> mLedgersByIndex;  // validated ledgers
 
    beast::Journal j_;
};
 
}  // namespace ripple
 
#endif