base.h

Go to the documentation of this file.

// Copyright (c) 2017-2018 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_INDEX_BASE_H
#define BITCOIN_INDEX_BASE_H
 
#include <dbwrapper.h>
#include <interfaces/chain.h>
#include <util/threadinterrupt.h>
#include <validationinterface.h>
 
#include <string>
 
class CBlock;
class CBlockIndex;
class Chainstate;
class ChainstateManager;
 
struct IndexSummary {
    std::string name;
    bool synced{false};
    int best_block_height{0};
    BlockHash best_block_hash{};
};
 
class BaseIndex : public CValidationInterface {
protected:
    class DB : public CDBWrapper {
    public:
        DB(const fs::path &path, size_t n_cache_size, bool f_memory = false,
           bool f_wipe = false, bool f_obfuscate = false);
 
        bool ReadBestBlock(CBlockLocator &locator) const;
 
        void WriteBestBlock(CDBBatch &batch, const CBlockLocator &locator);
    };
 
private:
    std::atomic<bool> m_init{false};
    std::atomic<bool> m_synced{false};
 
    std::atomic<const CBlockIndex *> m_best_block_index{nullptr};
 
    std::thread m_thread_sync;
    CThreadInterrupt m_interrupt;
 
    void ThreadSync();
 
    bool Commit();
 
    virtual bool AllowPrune() const = 0;
 
    template <typename... Args>
    void FatalErrorf(const char *fmt, const Args &...args);
 
protected:
    std::unique_ptr<interfaces::Chain> m_chain;
    Chainstate *m_chainstate{nullptr};
    const std::string m_name;
 
    void BlockConnected(ChainstateRole role,
                        const std::shared_ptr<const CBlock> &block,
                        const CBlockIndex *pindex) override;
 
    void ChainStateFlushed(ChainstateRole role,
                           const CBlockLocator &locator) override;
 
    [[nodiscard]] virtual bool
    CustomInit(const std::optional<interfaces::BlockKey> &block) {
        return true;
    }
 
    virtual bool WriteBlock(const CBlock &block, const CBlockIndex *pindex) {
        return true;
    }
 
    virtual bool CustomCommit(CDBBatch &batch) { return true; }
 
    virtual bool Rewind(const CBlockIndex *current_tip,
                        const CBlockIndex *new_tip);
 
    virtual DB &GetDB() const = 0;
 
    void SetBestBlockIndex(const CBlockIndex *block);
 
public:
    BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name);
    virtual ~BaseIndex();
 
    const std::string &GetName() const LIFETIMEBOUND { return m_name; }
 
    bool BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(::cs_main);
 
    void Interrupt();
 
    [[nodiscard]] bool Init();
 
    [[nodiscard]] bool StartBackgroundSync();
 
    void Stop();
 
    IndexSummary GetSummary() const;
};
 
#endif // BITCOIN_INDEX_BASE_H