LedgerReplayTask.h

#pragma once
 
#include <xrpld/app/ledger/InboundLedger.h>
#include <xrpld/app/ledger/detail/TimeoutCounter.h>
#include <xrpld/app/main/Application.h>
 
#include <vector>
 
namespace xrpl {
class InboundLedgers;
class Ledger;
class LedgerDeltaAcquire;
class LedgerReplayer;
class SkipListAcquire;
namespace test {
class LedgerReplayClient;
}  // namespace test
 
class LedgerReplayTask final : public TimeoutCounter,
                               public std::enable_shared_from_this<LedgerReplayTask>,
                               public CountedObject<LedgerReplayTask>
{
public:
    class TaskParameter
    {
    public:
        // set on construct
        InboundLedger::Reason reason_;
        uint256 finishHash_;
        std::uint32_t totalLedgers_;  // including the start and the finish
 
        // to be updated
        std::uint32_t finishSeq_ = 0;
        std::vector<uint256> skipList_ = {};  // including the finishHash
        uint256 startHash_ = {};
        std::uint32_t startSeq_ = 0;
        bool full_ = false;
 
        TaskParameter(
            InboundLedger::Reason r,
            uint256 const& finishLedgerHash,
            std::uint32_t totalNumLedgers);
 
        bool
        update(uint256 const& hash, std::uint32_t seq, std::vector<uint256> const& sList);
 
        bool
        canMergeInto(TaskParameter const& existingTask) const;
    };
 
    LedgerReplayTask(
        Application& app,
        InboundLedgers& inboundLedgers,
        LedgerReplayer& replayer,
        std::shared_ptr<SkipListAcquire>& skipListAcquirer,
        TaskParameter const& parameter);
 
    ~LedgerReplayTask();
 
    void
    init();
 
    void
    addDelta(std::shared_ptr<LedgerDeltaAcquire> const& delta);
 
    TaskParameter const&
    getTaskParameter() const
    {
        return parameter_;
    }
 
    bool
    finished() const;
 
private:
    void
    onTimer(bool progress, ScopedLockType& sl) override;
 
    std::weak_ptr<TimeoutCounter>
    pmDowncast() override;
 
    void
    updateSkipList(uint256 const& hash, std::uint32_t seq, std::vector<uint256> const& sList);
 
    void
    deltaReady(uint256 const& deltaHash);
 
    void
    trigger(ScopedLockType& sl);
 
    void
    tryAdvance(ScopedLockType& sl);
 
    InboundLedgers& inboundLedgers_;
    LedgerReplayer& replayer_;
    TaskParameter parameter_;
    uint32_t maxTimeouts_;
    std::shared_ptr<SkipListAcquire> skipListAcquirer_;
    std::shared_ptr<Ledger const> parent_ = {};
    uint32_t deltaToBuild_ = 0;  // should not build until have parent
    std::vector<std::shared_ptr<LedgerDeltaAcquire>> deltas_;
 
    friend class test::LedgerReplayClient;
};
 
}  // namespace xrpl