BlockChainSync.h

Go to the documentation of this file.

// Aleth: Ethereum C++ client, tools and libraries.
// Copyright 2019 Aleth Authors.
// Licensed under the GNU General Public License, Version 3.
 
#pragma once
 
#include <mutex>
#include <unordered_map>
 
#include <libdevcore/Guards.h>
#include <libethcore/Common.h>
#include <libethcore/BlockHeader.h>
#include <libp2p/Common.h>
#include "CommonNet.h"
 
namespace dev
{
 
class RLPStream;
 
namespace eth
{
class EthereumCapability;
class BlockQueue;
class EthereumPeer;
 
class BlockChainSync final: public HasInvariants
{
public:
    explicit BlockChainSync(EthereumCapability& _host);
    ~BlockChainSync();
    void abortSync(); 
 
    bool isSyncing() const;
 
    void restartSync();
 
    void completeSync();
 
    void onPeerStatus(EthereumPeer const& _peer);
 
    void onPeerBlockHeaders(NodeID const& _peerID, RLP const& _r);
 
    void onPeerBlockBodies(NodeID const& _peerID, RLP const& _r);
 
    void onPeerNewBlock(NodeID const& _peerID, RLP const& _r);
 
    void onPeerNewHashes(NodeID const& _peerID, std::vector<std::pair<h256, u256>> const& _hashes);
 
    void onPeerAborting();
 
    void onBlockImported(BlockHeader const& _info);
 
    SyncStatus status() const;
 
    static char const* stateName(SyncState _s) { return s_stateNames[static_cast<int>(_s)]; }
 
private:
    void continueSync();
 
    void pauseSync();
 
    EthereumCapability& host() { return m_host; }
    EthereumCapability const& host() const { return m_host; }
 
    void resetSync();
    void syncPeer(NodeID const& _peerID, bool _force);
    void requestBlocks(NodeID const& _peerID);
    void clearPeerDownload(NodeID const& _peerID);
    void clearPeerDownload();
    void collectBlocks();
    bool requestDaoForkBlockHeader(NodeID const& _peerID);
    bool verifyDaoChallengeResponse(RLP const& _r);
    void logImported(unsigned _success, unsigned _future, unsigned _got, unsigned _unknown);
 
private:
    struct Header
    {
        bytes data;     
        h256 hash;      
        h256 parent;    
    };
 
    struct HeaderId
    {
        h256 transactionsRoot;
        h256 uncles;
 
        bool operator==(HeaderId const& _other) const
        {
            return transactionsRoot == _other.transactionsRoot && uncles == _other.uncles;
        }
    };
 
    struct HeaderIdHash
    {
        std::size_t operator()(const HeaderId& _k) const
        {
            size_t seed = 0;
            h256::hash hasher;
            boost::hash_combine(seed, hasher(_k.transactionsRoot));
            boost::hash_combine(seed, hasher(_k.uncles));
            return seed;
        }
    };
 
    EthereumCapability& m_host;
    Handler<> m_bqRoomAvailable;                
    mutable RecursiveMutex x_sync;
    std::set<NodeID> m_daoChallengedPeers;
    std::atomic<SyncState> m_state{SyncState::Idle};        
    h256Hash m_knownNewHashes;                  
    unsigned m_chainStartBlock = 0;
    unsigned m_startingBlock = 0;               
    unsigned m_highestBlock = 0;                
    std::unordered_set<unsigned> m_downloadingHeaders;      
    std::unordered_set<unsigned> m_downloadingBodies;       
    std::map<unsigned, std::vector<Header>> m_headers;      
    std::map<unsigned, std::vector<bytes>> m_bodies;        
    std::map<NodeID, std::vector<unsigned>> m_headerSyncPeers;
    std::map<NodeID, std::vector<unsigned>> m_bodySyncPeers;
    std::unordered_map<HeaderId, unsigned, HeaderIdHash> m_headerIdToNumber;
    bool m_haveCommonHeader = false;            
    unsigned m_lastImportedBlock = 0;           
    h256 m_lastImportedBlockHash;               
    u256 m_syncingTotalDifficulty;              
 
    Logger m_logger{createLogger(VerbosityDebug, "sync")};
    Logger m_loggerInfo{createLogger(VerbosityInfo, "sync")};
    Logger m_loggerDetail{createLogger(VerbosityTrace, "sync")};
 
private:
    static char const* const s_stateNames[static_cast<int>(SyncState::Size)];
    bool invariants() const override;
    void logNewBlock(h256 const& _h);
};
 
std::ostream& operator<<(std::ostream& _out, SyncStatus const& _sync);
 
}
}