mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-04-15 23:51:35 +02:00
Merge #20811: refactor: move net_processing implementation details out of header
c97f70c861ac6959b8116a9bca3031edeb2b2aaa net_processing: move Peer definition to .cpp (Anthony Towns)
e0f2e6d2df7117a8dbf17c63c5149fc53a6fe2b2 net_processing: move PeerManagerImpl into cpp file (Anthony Towns)
a568b82febb3ecbd5ebb7c3f9da27e762b0c68f6 net_processing: split PeerManager into interface and implementation classes (Anthony Towns)
0df3d3fd6bbbd0e06116797177ba797580553250 net_processing: make more of PeerManager private (Anthony Towns)
0d246a59b606c51728d10cb70004a6eedb951bca net, net_processing: move NetEventsInterface method docs to net.h (Anthony Towns)
Pull request description:
Moves the implementation details of `PeerManager` and all of `struct Peer` into net_processing.cpp.
ACKs for top commit:
jnewbery:
ACK c97f70c861ac6959b8116a9bca3031edeb2b2aaa
Sjors:
ACK c97f70c861ac6959b8116a9bca3031edeb2b2aaa
laanwj:
Code review ACK c97f70c861ac6959b8116a9bca3031edeb2b2aaa
vasild:
ACK c97f70c861ac6959b8116a9bca3031edeb2b2aaa
Tree-SHA512: 2e081e491d981c61bd78436a6a6c2eb41d3c2d86a1a8ef9d4d6f801b82cb64a8bf707a96db3429418d1704cffb60a657d1037a0336cbc8173fb79aef9eb72001
This commit is contained in:
Wladimir J. van der Laan
commit
60427ee35f
@ -1410,8 +1410,8 @@ bool AppInitMain(const util::Ref& context, NodeContext& node, interfaces::BlockA
|
||||
ChainstateManager& chainman = *Assert(node.chainman);
|
||||
|
||||
assert(!node.peerman);
|
||||
node.peerman = std::make_unique<PeerManager>(chainparams, *node.connman, node.banman.get(),
|
||||
*node.scheduler, chainman, *node.mempool, ignores_incoming_txs);
|
||||
node.peerman = PeerManager::make(chainparams, *node.connman, node.banman.get(),
|
||||
*node.scheduler, chainman, *node.mempool, ignores_incoming_txs);
|
||||
RegisterValidationInterface(node.peerman.get());
|
||||
|
||||
// sanitize comments per BIP-0014, format user agent and check total size
|
||||
|
||||
23
src/net.h
23
src/net.h
@ -760,11 +760,30 @@ private:
|
||||
class NetEventsInterface
|
||||
{
|
||||
public:
|
||||
virtual bool ProcessMessages(CNode* pnode, std::atomic<bool>& interrupt) = 0;
|
||||
virtual bool SendMessages(CNode* pnode) EXCLUSIVE_LOCKS_REQUIRED(pnode->cs_sendProcessing) = 0;
|
||||
/** Initialize a peer (setup state, queue any initial messages) */
|
||||
virtual void InitializeNode(CNode* pnode) = 0;
|
||||
|
||||
/** Handle removal of a peer (clear state) */
|
||||
virtual void FinalizeNode(const CNode& node, bool& update_connection_time) = 0;
|
||||
|
||||
/**
|
||||
* Process protocol messages received from a given node
|
||||
*
|
||||
* @param[in] pnode The node which we have received messages from.
|
||||
* @param[in] interrupt Interrupt condition for processing threads
|
||||
* @return True if there is more work to be done
|
||||
*/
|
||||
virtual bool ProcessMessages(CNode* pnode, std::atomic<bool>& interrupt) = 0;
|
||||
|
||||
/**
|
||||
* Send queued protocol messages to a given node.
|
||||
*
|
||||
* @param[in] pnode The node which we are sending messages to.
|
||||
* @return True if there is more work to be done
|
||||
*/
|
||||
virtual bool SendMessages(CNode* pnode) EXCLUSIVE_LOCKS_REQUIRED(pnode->cs_sendProcessing) = 0;
|
||||
|
||||
|
||||
protected:
|
||||
/**
|
||||
* Protected destructor so that instances can only be deleted by derived classes.
|
||||
|
||||
@ -26,6 +26,7 @@
|
||||
#include <streams.h>
|
||||
#include <tinyformat.h>
|
||||
#include <txmempool.h>
|
||||
#include <txrequest.h>
|
||||
#include <util/check.h> // For NDEBUG compile time check
|
||||
#include <util/strencodings.h>
|
||||
#include <util/system.h>
|
||||
@ -167,6 +168,186 @@ std::map<uint256, std::map<uint256, COrphanTx>::iterator> g_orphans_by_wtxid GUA
|
||||
void EraseOrphansFor(NodeId peer);
|
||||
|
||||
// Internal stuff
|
||||
namespace {
|
||||
/**
|
||||
* Data structure for an individual peer. This struct is not protected by
|
||||
* cs_main since it does not contain validation-critical data.
|
||||
*
|
||||
* Memory is owned by shared pointers and this object is destructed when
|
||||
* the refcount drops to zero.
|
||||
*
|
||||
* Mutexes inside this struct must not be held when locking m_peer_mutex.
|
||||
*
|
||||
* TODO: move most members from CNodeState to this structure.
|
||||
* TODO: move remaining application-layer data members from CNode to this structure.
|
||||
*/
|
||||
struct Peer {
|
||||
/** Same id as the CNode object for this peer */
|
||||
const NodeId m_id{0};
|
||||
|
||||
/** Protects misbehavior data members */
|
||||
Mutex m_misbehavior_mutex;
|
||||
/** Accumulated misbehavior score for this peer */
|
||||
int m_misbehavior_score GUARDED_BY(m_misbehavior_mutex){0};
|
||||
/** Whether this peer should be disconnected and marked as discouraged (unless it has the noban permission). */
|
||||
bool m_should_discourage GUARDED_BY(m_misbehavior_mutex){false};
|
||||
|
||||
/** Protects block inventory data members */
|
||||
Mutex m_block_inv_mutex;
|
||||
/** List of blocks that we'll announce via an `inv` message.
|
||||
* There is no final sorting before sending, as they are always sent
|
||||
* immediately and in the order requested. */
|
||||
std::vector<uint256> m_blocks_for_inv_relay GUARDED_BY(m_block_inv_mutex);
|
||||
/** Unfiltered list of blocks that we'd like to announce via a `headers`
|
||||
* message. If we can't announce via a `headers` message, we'll fall back to
|
||||
* announcing via `inv`. */
|
||||
std::vector<uint256> m_blocks_for_headers_relay GUARDED_BY(m_block_inv_mutex);
|
||||
/** The final block hash that we sent in an `inv` message to this peer.
|
||||
* When the peer requests this block, we send an `inv` message to trigger
|
||||
* the peer to request the next sequence of block hashes.
|
||||
* Most peers use headers-first syncing, which doesn't use this mechanism */
|
||||
uint256 m_continuation_block GUARDED_BY(m_block_inv_mutex) {};
|
||||
|
||||
/** This peer's reported block height when we connected */
|
||||
std::atomic<int> m_starting_height{-1};
|
||||
|
||||
/** Set of txids to reconsider once their parent transactions have been accepted **/
|
||||
std::set<uint256> m_orphan_work_set GUARDED_BY(g_cs_orphans);
|
||||
|
||||
/** Protects m_getdata_requests **/
|
||||
Mutex m_getdata_requests_mutex;
|
||||
/** Work queue of items requested by this peer **/
|
||||
std::deque<CInv> m_getdata_requests GUARDED_BY(m_getdata_requests_mutex);
|
||||
|
||||
explicit Peer(NodeId id) : m_id(id) {}
|
||||
};
|
||||
|
||||
using PeerRef = std::shared_ptr<Peer>;
|
||||
|
||||
class PeerManagerImpl final : public PeerManager
|
||||
{
|
||||
public:
|
||||
PeerManagerImpl(const CChainParams& chainparams, CConnman& connman, BanMan* banman,
|
||||
CScheduler& scheduler, ChainstateManager& chainman, CTxMemPool& pool,
|
||||
bool ignore_incoming_txs);
|
||||
|
||||
/** Overridden from CValidationInterface. */
|
||||
void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override;
|
||||
void BlockDisconnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex* pindex) override;
|
||||
void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
|
||||
void BlockChecked(const CBlock& block, const BlockValidationState& state) override;
|
||||
void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock) override;
|
||||
|
||||
/** Implement NetEventsInterface */
|
||||
void InitializeNode(CNode* pnode) override;
|
||||
void FinalizeNode(const CNode& node, bool& fUpdateConnectionTime) override;
|
||||
bool ProcessMessages(CNode* pfrom, std::atomic<bool>& interrupt) override;
|
||||
bool SendMessages(CNode* pto) override EXCLUSIVE_LOCKS_REQUIRED(pto->cs_sendProcessing);
|
||||
|
||||
/** Implement PeerManager */
|
||||
void CheckForStaleTipAndEvictPeers() override;
|
||||
bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) override;
|
||||
bool IgnoresIncomingTxs() override { return m_ignore_incoming_txs; }
|
||||
void SetBestHeight(int height) override { m_best_height = height; };
|
||||
void Misbehaving(const NodeId pnode, const int howmuch, const std::string& message) override;
|
||||
void ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv,
|
||||
const std::chrono::microseconds time_received, const std::atomic<bool>& interruptMsgProc) override;
|
||||
|
||||
private:
|
||||
/** Consider evicting an outbound peer based on the amount of time they've been behind our tip */
|
||||
void ConsiderEviction(CNode& pto, int64_t time_in_seconds) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
|
||||
|
||||
/** If we have extra outbound peers, try to disconnect the one with the oldest block announcement */
|
||||
void EvictExtraOutboundPeers(int64_t time_in_seconds) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
|
||||
|
||||
/** Retrieve unbroadcast transactions from the mempool and reattempt sending to peers */
|
||||
void ReattemptInitialBroadcast(CScheduler& scheduler) const;
|
||||
|
||||
/** Get a shared pointer to the Peer object.
|
||||
* May return an empty shared_ptr if the Peer object can't be found. */
|
||||
PeerRef GetPeerRef(NodeId id) const;
|
||||
|
||||
/** Get a shared pointer to the Peer object and remove it from m_peer_map.
|
||||
* May return an empty shared_ptr if the Peer object can't be found. */
|
||||
PeerRef RemovePeer(NodeId id);
|
||||
|
||||
/**
|
||||
* Potentially mark a node discouraged based on the contents of a BlockValidationState object
|
||||
*
|
||||
* @param[in] via_compact_block this bool is passed in because net_processing should
|
||||
* punish peers differently depending on whether the data was provided in a compact
|
||||
* block message or not. If the compact block had a valid header, but contained invalid
|
||||
* txs, the peer should not be punished. See BIP 152.
|
||||
*
|
||||
* @return Returns true if the peer was punished (probably disconnected)
|
||||
*/
|
||||
bool MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
|
||||
bool via_compact_block, const std::string& message = "");
|
||||
|
||||
/**
|
||||
* Potentially disconnect and discourage a node based on the contents of a TxValidationState object
|
||||
*
|
||||
* @return Returns true if the peer was punished (probably disconnected)
|
||||
*/
|
||||
bool MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state, const std::string& message = "");
|
||||
|
||||
/** Maybe disconnect a peer and discourage future connections from its address.
|
||||
*
|
||||
* @param[in] pnode The node to check.
|
||||
* @return True if the peer was marked for disconnection in this function
|
||||
*/
|
||||
bool MaybeDiscourageAndDisconnect(CNode& pnode);
|
||||
|
||||
void ProcessOrphanTx(std::set<uint256>& orphan_work_set) EXCLUSIVE_LOCKS_REQUIRED(cs_main, g_cs_orphans);
|
||||
/** Process a single headers message from a peer. */
|
||||
void ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
|
||||
const std::vector<CBlockHeader>& headers,
|
||||
bool via_compact_block);
|
||||
|
||||
void SendBlockTransactions(CNode& pfrom, const CBlock& block, const BlockTransactionsRequest& req);
|
||||
|
||||
/** Register with TxRequestTracker that an INV has been received from a
|
||||
* peer. The announcement parameters are decided in PeerManager and then
|
||||
* passed to TxRequestTracker. */
|
||||
void AddTxAnnouncement(const CNode& node, const GenTxid& gtxid, std::chrono::microseconds current_time)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
|
||||
|
||||
/** Send a version message to a peer */
|
||||
void PushNodeVersion(CNode& pnode, int64_t nTime);
|
||||
|
||||
const CChainParams& m_chainparams;
|
||||
CConnman& m_connman;
|
||||
/** Pointer to this node's banman. May be nullptr - check existence before dereferencing. */
|
||||
BanMan* const m_banman;
|
||||
ChainstateManager& m_chainman;
|
||||
CTxMemPool& m_mempool;
|
||||
TxRequestTracker m_txrequest GUARDED_BY(::cs_main);
|
||||
|
||||
/** The height of the best chain */
|
||||
std::atomic<int> m_best_height{-1};
|
||||
|
||||
int64_t m_stale_tip_check_time; //!< Next time to check for stale tip
|
||||
|
||||
/** Whether this node is running in blocks only mode */
|
||||
const bool m_ignore_incoming_txs;
|
||||
|
||||
/** Whether we've completed initial sync yet, for determining when to turn
|
||||
* on extra block-relay-only peers. */
|
||||
bool m_initial_sync_finished{false};
|
||||
|
||||
/** Protects m_peer_map. This mutex must not be locked while holding a lock
|
||||
* on any of the mutexes inside a Peer object. */
|
||||
mutable Mutex m_peer_mutex;
|
||||
/**
|
||||
* Map of all Peer objects, keyed by peer id. This map is protected
|
||||
* by the m_peer_mutex. Once a shared pointer reference is
|
||||
* taken, the lock may be released. Individual fields are protected by
|
||||
* their own locks.
|
||||
*/
|
||||
std::map<NodeId, PeerRef> m_peer_map GUARDED_BY(m_peer_mutex);
|
||||
};
|
||||
} // namespace
|
||||
|
||||
namespace {
|
||||
/** Number of nodes with fSyncStarted. */
|
||||
int nSyncStarted GUARDED_BY(cs_main) = 0;
|
||||
@ -683,7 +864,7 @@ static void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vec
|
||||
|
||||
} // namespace
|
||||
|
||||
void PeerManager::PushNodeVersion(CNode& pnode, int64_t nTime)
|
||||
void PeerManagerImpl::PushNodeVersion(CNode& pnode, int64_t nTime)
|
||||
{
|
||||
// Note that pnode->GetLocalServices() is a reflection of the local
|
||||
// services we were offering when the CNode object was created for this
|
||||
@ -709,7 +890,7 @@ void PeerManager::PushNodeVersion(CNode& pnode, int64_t nTime)
|
||||
}
|
||||
}
|
||||
|
||||
void PeerManager::AddTxAnnouncement(const CNode& node, const GenTxid& gtxid, std::chrono::microseconds current_time)
|
||||
void PeerManagerImpl::AddTxAnnouncement(const CNode& node, const GenTxid& gtxid, std::chrono::microseconds current_time)
|
||||
{
|
||||
AssertLockHeld(::cs_main); // For m_txrequest
|
||||
NodeId nodeid = node.GetId();
|
||||
@ -745,7 +926,8 @@ void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds)
|
||||
if (state) state->m_last_block_announcement = time_in_seconds;
|
||||
}
|
||||
|
||||
void PeerManager::InitializeNode(CNode *pnode) {
|
||||
void PeerManagerImpl::InitializeNode(CNode *pnode)
|
||||
{
|
||||
CAddress addr = pnode->addr;
|
||||
std::string addrName = pnode->GetAddrName();
|
||||
NodeId nodeid = pnode->GetId();
|
||||
@ -764,7 +946,7 @@ void PeerManager::InitializeNode(CNode *pnode) {
|
||||
}
|
||||
}
|
||||
|
||||
void PeerManager::ReattemptInitialBroadcast(CScheduler& scheduler) const
|
||||
void PeerManagerImpl::ReattemptInitialBroadcast(CScheduler& scheduler) const
|
||||
{
|
||||
std::set<uint256> unbroadcast_txids = m_mempool.GetUnbroadcastTxs();
|
||||
|
||||
@ -785,7 +967,8 @@ void PeerManager::ReattemptInitialBroadcast(CScheduler& scheduler) const
|
||||
scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); }, delta);
|
||||
}
|
||||
|
||||
void PeerManager::FinalizeNode(const CNode& node, bool& fUpdateConnectionTime) {
|
||||
void PeerManagerImpl::FinalizeNode(const CNode& node, bool& fUpdateConnectionTime)
|
||||
{
|
||||
NodeId nodeid = node.GetId();
|
||||
fUpdateConnectionTime = false;
|
||||
LOCK(cs_main);
|
||||
@ -839,14 +1022,14 @@ void PeerManager::FinalizeNode(const CNode& node, bool& fUpdateConnectionTime) {
|
||||
LogPrint(BCLog::NET, "Cleared nodestate for peer=%d\n", nodeid);
|
||||
}
|
||||
|
||||
PeerRef PeerManager::GetPeerRef(NodeId id) const
|
||||
PeerRef PeerManagerImpl::GetPeerRef(NodeId id) const
|
||||
{
|
||||
LOCK(m_peer_mutex);
|
||||
auto it = m_peer_map.find(id);
|
||||
return it != m_peer_map.end() ? it->second : nullptr;
|
||||
}
|
||||
|
||||
PeerRef PeerManager::RemovePeer(NodeId id)
|
||||
PeerRef PeerManagerImpl::RemovePeer(NodeId id)
|
||||
{
|
||||
PeerRef ret;
|
||||
LOCK(m_peer_mutex);
|
||||
@ -858,7 +1041,8 @@ PeerRef PeerManager::RemovePeer(NodeId id)
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool PeerManager::GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) {
|
||||
bool PeerManagerImpl::GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats)
|
||||
{
|
||||
{
|
||||
LOCK(cs_main);
|
||||
CNodeState* state = State(nodeid);
|
||||
@ -1015,7 +1199,7 @@ unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans)
|
||||
return nEvicted;
|
||||
}
|
||||
|
||||
void PeerManager::Misbehaving(const NodeId pnode, const int howmuch, const std::string& message)
|
||||
void PeerManagerImpl::Misbehaving(const NodeId pnode, const int howmuch, const std::string& message)
|
||||
{
|
||||
assert(howmuch > 0);
|
||||
|
||||
@ -1033,8 +1217,8 @@ void PeerManager::Misbehaving(const NodeId pnode, const int howmuch, const std::
|
||||
}
|
||||
}
|
||||
|
||||
bool PeerManager::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
|
||||
bool via_compact_block, const std::string& message)
|
||||
bool PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
|
||||
bool via_compact_block, const std::string& message)
|
||||
{
|
||||
switch (state.GetResult()) {
|
||||
case BlockValidationResult::BLOCK_RESULT_UNSET:
|
||||
@ -1083,7 +1267,7 @@ bool PeerManager::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationSt
|
||||
return false;
|
||||
}
|
||||
|
||||
bool PeerManager::MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state, const std::string& message)
|
||||
bool PeerManagerImpl::MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state, const std::string& message)
|
||||
{
|
||||
switch (state.GetResult()) {
|
||||
case TxValidationResult::TX_RESULT_UNSET:
|
||||
@ -1129,9 +1313,16 @@ static bool BlockRequestAllowed(const CBlockIndex* pindex, const Consensus::Para
|
||||
(GetBlockProofEquivalentTime(*pindexBestHeader, *pindex, *pindexBestHeader, consensusParams) < STALE_RELAY_AGE_LIMIT);
|
||||
}
|
||||
|
||||
PeerManager::PeerManager(const CChainParams& chainparams, CConnman& connman, BanMan* banman,
|
||||
CScheduler& scheduler, ChainstateManager& chainman, CTxMemPool& pool,
|
||||
bool ignore_incoming_txs)
|
||||
std::unique_ptr<PeerManager> PeerManager::make(const CChainParams& chainparams, CConnman& connman, BanMan* banman,
|
||||
CScheduler& scheduler, ChainstateManager& chainman, CTxMemPool& pool,
|
||||
bool ignore_incoming_txs)
|
||||
{
|
||||
return std::make_unique<PeerManagerImpl>(chainparams, connman, banman, scheduler, chainman, pool, ignore_incoming_txs);
|
||||
}
|
||||
|
||||
PeerManagerImpl::PeerManagerImpl(const CChainParams& chainparams, CConnman& connman, BanMan* banman,
|
||||
CScheduler& scheduler, ChainstateManager& chainman, CTxMemPool& pool,
|
||||
bool ignore_incoming_txs)
|
||||
: m_chainparams(chainparams),
|
||||
m_connman(connman),
|
||||
m_banman(banman),
|
||||
@ -1171,7 +1362,7 @@ PeerManager::PeerManager(const CChainParams& chainparams, CConnman& connman, Ban
|
||||
* block, remember the recently confirmed transactions, and delete tracked
|
||||
* announcements for them. Also save the time of the last tip update.
|
||||
*/
|
||||
void PeerManager::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
|
||||
void PeerManagerImpl::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
|
||||
{
|
||||
{
|
||||
LOCK(g_cs_orphans);
|
||||
@ -1222,7 +1413,7 @@ void PeerManager::BlockConnected(const std::shared_ptr<const CBlock>& pblock, co
|
||||
}
|
||||
}
|
||||
|
||||
void PeerManager::BlockDisconnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex* pindex)
|
||||
void PeerManagerImpl::BlockDisconnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex* pindex)
|
||||
{
|
||||
// To avoid relay problems with transactions that were previously
|
||||
// confirmed, clear our filter of recently confirmed transactions whenever
|
||||
@ -1247,7 +1438,8 @@ static bool fWitnessesPresentInMostRecentCompactBlock GUARDED_BY(cs_most_recent_
|
||||
* Maintain state about the best-seen block and fast-announce a compact block
|
||||
* to compatible peers.
|
||||
*/
|
||||
void PeerManager::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock) {
|
||||
void PeerManagerImpl::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock)
|
||||
{
|
||||
std::shared_ptr<const CBlockHeaderAndShortTxIDs> pcmpctblock = std::make_shared<const CBlockHeaderAndShortTxIDs> (*pblock, true);
|
||||
const CNetMsgMaker msgMaker(PROTOCOL_VERSION);
|
||||
|
||||
@ -1294,9 +1486,9 @@ void PeerManager::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_
|
||||
* Update our best height and announce any block hashes which weren't previously
|
||||
* in ::ChainActive() to our peers.
|
||||
*/
|
||||
void PeerManager::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload)
|
||||
void PeerManagerImpl::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload)
|
||||
{
|
||||
m_best_height = pindexNew->nHeight;
|
||||
SetBestHeight(pindexNew->nHeight);
|
||||
SetServiceFlagsIBDCache(!fInitialDownload);
|
||||
|
||||
// Don't relay inventory during initial block download.
|
||||
@ -1333,7 +1525,8 @@ void PeerManager::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockInde
|
||||
* Handle invalid block rejection and consequent peer discouragement, maintain which
|
||||
* peers announce compact blocks.
|
||||
*/
|
||||
void PeerManager::BlockChecked(const CBlock& block, const BlockValidationState& state) {
|
||||
void PeerManagerImpl::BlockChecked(const CBlock& block, const BlockValidationState& state)
|
||||
{
|
||||
LOCK(cs_main);
|
||||
|
||||
const uint256 hash(block.GetHash());
|
||||
@ -1761,7 +1954,8 @@ static uint32_t GetFetchFlags(const CNode& pfrom) EXCLUSIVE_LOCKS_REQUIRED(cs_ma
|
||||
return nFetchFlags;
|
||||
}
|
||||
|
||||
void PeerManager::SendBlockTransactions(CNode& pfrom, const CBlock& block, const BlockTransactionsRequest& req) {
|
||||
void PeerManagerImpl::SendBlockTransactions(CNode& pfrom, const CBlock& block, const BlockTransactionsRequest& req)
|
||||
{
|
||||
BlockTransactions resp(req);
|
||||
for (size_t i = 0; i < req.indexes.size(); i++) {
|
||||
if (req.indexes[i] >= block.vtx.size()) {
|
||||
@ -1776,9 +1970,9 @@ void PeerManager::SendBlockTransactions(CNode& pfrom, const CBlock& block, const
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCKTXN, resp));
|
||||
}
|
||||
|
||||
void PeerManager::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
|
||||
const std::vector<CBlockHeader>& headers,
|
||||
bool via_compact_block)
|
||||
void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
|
||||
const std::vector<CBlockHeader>& headers,
|
||||
bool via_compact_block)
|
||||
{
|
||||
const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
|
||||
size_t nCount = headers.size();
|
||||
@ -1970,7 +2164,7 @@ void PeerManager::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
|
||||
* may be added to if accepting an orphan causes its children to be
|
||||
* reconsidered.
|
||||
*/
|
||||
void PeerManager::ProcessOrphanTx(std::set<uint256>& orphan_work_set)
|
||||
void PeerManagerImpl::ProcessOrphanTx(std::set<uint256>& orphan_work_set)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
AssertLockHeld(g_cs_orphans);
|
||||
@ -2267,9 +2461,9 @@ static void ProcessGetCFCheckPt(CNode& peer, CDataStream& vRecv, const CChainPar
|
||||
connman.PushMessage(&peer, std::move(msg));
|
||||
}
|
||||
|
||||
void PeerManager::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv,
|
||||
const std::chrono::microseconds time_received,
|
||||
const std::atomic<bool>& interruptMsgProc)
|
||||
void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv,
|
||||
const std::chrono::microseconds time_received,
|
||||
const std::atomic<bool>& interruptMsgProc)
|
||||
{
|
||||
LogPrint(BCLog::NET, "received: %s (%u bytes) peer=%d\n", SanitizeString(msg_type), vRecv.size(), pfrom.GetId());
|
||||
|
||||
@ -3755,7 +3949,7 @@ void PeerManager::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDat
|
||||
return;
|
||||
}
|
||||
|
||||
bool PeerManager::MaybeDiscourageAndDisconnect(CNode& pnode)
|
||||
bool PeerManagerImpl::MaybeDiscourageAndDisconnect(CNode& pnode)
|
||||
{
|
||||
const NodeId peer_id{pnode.GetId()};
|
||||
PeerRef peer = GetPeerRef(peer_id);
|
||||
@ -3797,7 +3991,7 @@ bool PeerManager::MaybeDiscourageAndDisconnect(CNode& pnode)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool PeerManager::ProcessMessages(CNode* pfrom, std::atomic<bool>& interruptMsgProc)
|
||||
bool PeerManagerImpl::ProcessMessages(CNode* pfrom, std::atomic<bool>& interruptMsgProc)
|
||||
{
|
||||
bool fMoreWork = false;
|
||||
|
||||
@ -3872,7 +4066,7 @@ bool PeerManager::ProcessMessages(CNode* pfrom, std::atomic<bool>& interruptMsgP
|
||||
return fMoreWork;
|
||||
}
|
||||
|
||||
void PeerManager::ConsiderEviction(CNode& pto, int64_t time_in_seconds)
|
||||
void PeerManagerImpl::ConsiderEviction(CNode& pto, int64_t time_in_seconds)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
|
||||
@ -3925,7 +4119,7 @@ void PeerManager::ConsiderEviction(CNode& pto, int64_t time_in_seconds)
|
||||
}
|
||||
}
|
||||
|
||||
void PeerManager::EvictExtraOutboundPeers(int64_t time_in_seconds)
|
||||
void PeerManagerImpl::EvictExtraOutboundPeers(int64_t time_in_seconds)
|
||||
{
|
||||
// If we have any extra block-relay-only peers, disconnect the youngest unless
|
||||
// it's given us a block -- in which case, compare with the second-youngest, and
|
||||
@ -4026,7 +4220,7 @@ void PeerManager::EvictExtraOutboundPeers(int64_t time_in_seconds)
|
||||
}
|
||||
}
|
||||
|
||||
void PeerManager::CheckForStaleTipAndEvictPeers()
|
||||
void PeerManagerImpl::CheckForStaleTipAndEvictPeers()
|
||||
{
|
||||
LOCK(cs_main);
|
||||
|
||||
@ -4073,7 +4267,7 @@ public:
|
||||
};
|
||||
}
|
||||
|
||||
bool PeerManager::SendMessages(CNode* pto)
|
||||
bool PeerManagerImpl::SendMessages(CNode* pto)
|
||||
{
|
||||
PeerRef peer = GetPeerRef(pto->GetId());
|
||||
const Consensus::Params& consensusParams = m_chainparams.GetConsensus();
|
||||
|
||||
@ -6,19 +6,13 @@
|
||||
#ifndef BITCOIN_NET_PROCESSING_H
|
||||
#define BITCOIN_NET_PROCESSING_H
|
||||
|
||||
#include <consensus/params.h>
|
||||
#include <net.h>
|
||||
#include <sync.h>
|
||||
#include <txrequest.h>
|
||||
#include <validationinterface.h>
|
||||
|
||||
class BlockTransactionsRequest;
|
||||
class BlockValidationState;
|
||||
class CBlockHeader;
|
||||
class CChainParams;
|
||||
class CTxMemPool;
|
||||
class ChainstateManager;
|
||||
class TxValidationState;
|
||||
|
||||
extern RecursiveMutex cs_main;
|
||||
extern RecursiveMutex g_cs_orphans;
|
||||
@ -39,216 +33,39 @@ struct CNodeStateStats {
|
||||
std::vector<int> vHeightInFlight;
|
||||
};
|
||||
|
||||
/**
|
||||
* Data structure for an individual peer. This struct is not protected by
|
||||
* cs_main since it does not contain validation-critical data.
|
||||
*
|
||||
* Memory is owned by shared pointers and this object is destructed when
|
||||
* the refcount drops to zero.
|
||||
*
|
||||
* Mutexes inside this struct must not be held when locking m_peer_mutex.
|
||||
*
|
||||
* TODO: move most members from CNodeState to this structure.
|
||||
* TODO: move remaining application-layer data members from CNode to this structure.
|
||||
*/
|
||||
struct Peer {
|
||||
/** Same id as the CNode object for this peer */
|
||||
const NodeId m_id{0};
|
||||
|
||||
/** Protects misbehavior data members */
|
||||
Mutex m_misbehavior_mutex;
|
||||
/** Accumulated misbehavior score for this peer */
|
||||
int m_misbehavior_score GUARDED_BY(m_misbehavior_mutex){0};
|
||||
/** Whether this peer should be disconnected and marked as discouraged (unless it has the noban permission). */
|
||||
bool m_should_discourage GUARDED_BY(m_misbehavior_mutex){false};
|
||||
|
||||
/** Protects block inventory data members */
|
||||
Mutex m_block_inv_mutex;
|
||||
/** List of blocks that we'll announce via an `inv` message.
|
||||
* There is no final sorting before sending, as they are always sent
|
||||
* immediately and in the order requested. */
|
||||
std::vector<uint256> m_blocks_for_inv_relay GUARDED_BY(m_block_inv_mutex);
|
||||
/** Unfiltered list of blocks that we'd like to announce via a `headers`
|
||||
* message. If we can't announce via a `headers` message, we'll fall back to
|
||||
* announcing via `inv`. */
|
||||
std::vector<uint256> m_blocks_for_headers_relay GUARDED_BY(m_block_inv_mutex);
|
||||
/** The final block hash that we sent in an `inv` message to this peer.
|
||||
* When the peer requests this block, we send an `inv` message to trigger
|
||||
* the peer to request the next sequence of block hashes.
|
||||
* Most peers use headers-first syncing, which doesn't use this mechanism */
|
||||
uint256 m_continuation_block GUARDED_BY(m_block_inv_mutex) {};
|
||||
|
||||
/** This peer's reported block height when we connected */
|
||||
std::atomic<int> m_starting_height{-1};
|
||||
|
||||
/** Set of txids to reconsider once their parent transactions have been accepted **/
|
||||
std::set<uint256> m_orphan_work_set GUARDED_BY(g_cs_orphans);
|
||||
|
||||
/** Protects m_getdata_requests **/
|
||||
Mutex m_getdata_requests_mutex;
|
||||
/** Work queue of items requested by this peer **/
|
||||
std::deque<CInv> m_getdata_requests GUARDED_BY(m_getdata_requests_mutex);
|
||||
|
||||
explicit Peer(NodeId id) : m_id(id) {}
|
||||
};
|
||||
|
||||
using PeerRef = std::shared_ptr<Peer>;
|
||||
|
||||
class PeerManager final : public CValidationInterface, public NetEventsInterface {
|
||||
class PeerManager : public CValidationInterface, public NetEventsInterface
|
||||
{
|
||||
public:
|
||||
PeerManager(const CChainParams& chainparams, CConnman& connman, BanMan* banman,
|
||||
CScheduler& scheduler, ChainstateManager& chainman, CTxMemPool& pool,
|
||||
bool ignore_incoming_txs);
|
||||
static std::unique_ptr<PeerManager> make(const CChainParams& chainparams, CConnman& connman, BanMan* banman,
|
||||
CScheduler& scheduler, ChainstateManager& chainman, CTxMemPool& pool,
|
||||
bool ignore_incoming_txs);
|
||||
virtual ~PeerManager() { }
|
||||
|
||||
/**
|
||||
* Overridden from CValidationInterface.
|
||||
*/
|
||||
void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override;
|
||||
void BlockDisconnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex* pindex) override;
|
||||
/**
|
||||
* Overridden from CValidationInterface.
|
||||
*/
|
||||
void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
|
||||
/**
|
||||
* Overridden from CValidationInterface.
|
||||
*/
|
||||
void BlockChecked(const CBlock& block, const BlockValidationState& state) override;
|
||||
/**
|
||||
* Overridden from CValidationInterface.
|
||||
*/
|
||||
void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock) override;
|
||||
/** Get statistics from node state */
|
||||
virtual bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) = 0;
|
||||
|
||||
/** Initialize a peer by adding it to mapNodeState and pushing a message requesting its version */
|
||||
void InitializeNode(CNode* pnode) override;
|
||||
/** Handle removal of a peer by updating various state and removing it from mapNodeState */
|
||||
void FinalizeNode(const CNode& node, bool& fUpdateConnectionTime) override;
|
||||
/**
|
||||
* Process protocol messages received from a given node
|
||||
*
|
||||
* @param[in] pfrom The node which we have received messages from.
|
||||
* @param[in] interrupt Interrupt condition for processing threads
|
||||
*/
|
||||
bool ProcessMessages(CNode* pfrom, std::atomic<bool>& interrupt) override;
|
||||
/**
|
||||
* Send queued protocol messages to be sent to a give node.
|
||||
*
|
||||
* @param[in] pto The node which we are sending messages to.
|
||||
* @return True if there is more work to be done
|
||||
*/
|
||||
bool SendMessages(CNode* pto) override EXCLUSIVE_LOCKS_REQUIRED(pto->cs_sendProcessing);
|
||||
/** Whether this node ignores txs received over p2p. */
|
||||
virtual bool IgnoresIncomingTxs() = 0;
|
||||
|
||||
/** Consider evicting an outbound peer based on the amount of time they've been behind our tip */
|
||||
void ConsiderEviction(CNode& pto, int64_t time_in_seconds) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
|
||||
/** Evict extra outbound peers. If we think our tip may be stale, connect to an extra outbound */
|
||||
void CheckForStaleTipAndEvictPeers();
|
||||
/** If we have extra outbound peers, try to disconnect the one with the oldest block announcement */
|
||||
void EvictExtraOutboundPeers(int64_t time_in_seconds) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
|
||||
/** Retrieve unbroadcast transactions from the mempool and reattempt sending to peers */
|
||||
void ReattemptInitialBroadcast(CScheduler& scheduler) const;
|
||||
|
||||
/** Process a single message from a peer. Public for fuzz testing */
|
||||
void ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv,
|
||||
const std::chrono::microseconds time_received, const std::atomic<bool>& interruptMsgProc);
|
||||
/** Set the best height */
|
||||
virtual void SetBestHeight(int height) = 0;
|
||||
|
||||
/**
|
||||
* Increment peer's misbehavior score. If the new value >= DISCOURAGEMENT_THRESHOLD, mark the node
|
||||
* to be discouraged, meaning the peer might be disconnected and added to the discouragement filter.
|
||||
* Public for unit testing.
|
||||
*/
|
||||
void Misbehaving(const NodeId pnode, const int howmuch, const std::string& message);
|
||||
|
||||
/** Get statistics from node state */
|
||||
bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats);
|
||||
|
||||
/** Set the best height */
|
||||
void SetBestHeight(int height) { m_best_height = height; };
|
||||
|
||||
/** Whether this node ignores txs received over p2p. */
|
||||
bool IgnoresIncomingTxs() { return m_ignore_incoming_txs; };
|
||||
|
||||
private:
|
||||
/** Get a shared pointer to the Peer object.
|
||||
* May return an empty shared_ptr if the Peer object can't be found. */
|
||||
PeerRef GetPeerRef(NodeId id) const;
|
||||
|
||||
/** Get a shared pointer to the Peer object and remove it from m_peer_map.
|
||||
* May return an empty shared_ptr if the Peer object can't be found. */
|
||||
PeerRef RemovePeer(NodeId id);
|
||||
virtual void Misbehaving(const NodeId pnode, const int howmuch, const std::string& message) = 0;
|
||||
|
||||
/**
|
||||
* Potentially mark a node discouraged based on the contents of a BlockValidationState object
|
||||
*
|
||||
* @param[in] via_compact_block this bool is passed in because net_processing should
|
||||
* punish peers differently depending on whether the data was provided in a compact
|
||||
* block message or not. If the compact block had a valid header, but contained invalid
|
||||
* txs, the peer should not be punished. See BIP 152.
|
||||
*
|
||||
* @return Returns true if the peer was punished (probably disconnected)
|
||||
* Evict extra outbound peers. If we think our tip may be stale, connect to an extra outbound.
|
||||
* Public for unit testing.
|
||||
*/
|
||||
bool MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
|
||||
bool via_compact_block, const std::string& message = "");
|
||||
virtual void CheckForStaleTipAndEvictPeers() = 0;
|
||||
|
||||
/**
|
||||
* Potentially disconnect and discourage a node based on the contents of a TxValidationState object
|
||||
*
|
||||
* @return Returns true if the peer was punished (probably disconnected)
|
||||
*/
|
||||
bool MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state, const std::string& message = "");
|
||||
|
||||
/** Maybe disconnect a peer and discourage future connections from its address.
|
||||
*
|
||||
* @param[in] pnode The node to check.
|
||||
* @return True if the peer was marked for disconnection in this function
|
||||
*/
|
||||
bool MaybeDiscourageAndDisconnect(CNode& pnode);
|
||||
|
||||
void ProcessOrphanTx(std::set<uint256>& orphan_work_set) EXCLUSIVE_LOCKS_REQUIRED(cs_main, g_cs_orphans);
|
||||
/** Process a single headers message from a peer. */
|
||||
void ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
|
||||
const std::vector<CBlockHeader>& headers,
|
||||
bool via_compact_block);
|
||||
|
||||
void SendBlockTransactions(CNode& pfrom, const CBlock& block, const BlockTransactionsRequest& req);
|
||||
|
||||
/** Register with TxRequestTracker that an INV has been received from a
|
||||
* peer. The announcement parameters are decided in PeerManager and then
|
||||
* passed to TxRequestTracker. */
|
||||
void AddTxAnnouncement(const CNode& node, const GenTxid& gtxid, std::chrono::microseconds current_time)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
|
||||
|
||||
/** Send a version message to a peer */
|
||||
void PushNodeVersion(CNode& pnode, int64_t nTime);
|
||||
|
||||
const CChainParams& m_chainparams;
|
||||
CConnman& m_connman;
|
||||
/** Pointer to this node's banman. May be nullptr - check existence before dereferencing. */
|
||||
BanMan* const m_banman;
|
||||
ChainstateManager& m_chainman;
|
||||
CTxMemPool& m_mempool;
|
||||
TxRequestTracker m_txrequest GUARDED_BY(::cs_main);
|
||||
|
||||
/** The height of the best chain */
|
||||
std::atomic<int> m_best_height{-1};
|
||||
|
||||
int64_t m_stale_tip_check_time; //!< Next time to check for stale tip
|
||||
|
||||
/** Whether this node is running in blocks only mode */
|
||||
const bool m_ignore_incoming_txs;
|
||||
|
||||
/** Whether we've completed initial sync yet, for determining when to turn
|
||||
* on extra block-relay-only peers. */
|
||||
bool m_initial_sync_finished{false};
|
||||
|
||||
/** Protects m_peer_map. This mutex must not be locked while holding a lock
|
||||
* on any of the mutexes inside a Peer object. */
|
||||
mutable Mutex m_peer_mutex;
|
||||
/**
|
||||
* Map of all Peer objects, keyed by peer id. This map is protected
|
||||
* by the m_peer_mutex. Once a shared pointer reference is
|
||||
* taken, the lock may be released. Individual fields are protected by
|
||||
* their own locks.
|
||||
*/
|
||||
std::map<NodeId, PeerRef> m_peer_map GUARDED_BY(m_peer_mutex);
|
||||
/** Process a single message from a peer. Public for fuzz testing */
|
||||
virtual void ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv,
|
||||
const std::chrono::microseconds time_received, const std::atomic<bool>& interruptMsgProc) = 0;
|
||||
};
|
||||
|
||||
/** Relay transaction to every node */
|
||||
|
||||
@ -80,8 +80,8 @@ BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
|
||||
{
|
||||
const CChainParams& chainparams = Params();
|
||||
auto connman = MakeUnique<CConnman>(0x1337, 0x1337);
|
||||
auto peerLogic = std::make_unique<PeerManager>(chainparams, *connman, nullptr, *m_node.scheduler,
|
||||
*m_node.chainman, *m_node.mempool, false);
|
||||
auto peerLogic = PeerManager::make(chainparams, *connman, nullptr, *m_node.scheduler,
|
||||
*m_node.chainman, *m_node.mempool, false);
|
||||
|
||||
// Mock an outbound peer
|
||||
CAddress addr1(ip(0xa0b0c001), NODE_NONE);
|
||||
@ -150,8 +150,8 @@ BOOST_AUTO_TEST_CASE(stale_tip_peer_management)
|
||||
{
|
||||
const CChainParams& chainparams = Params();
|
||||
auto connman = MakeUnique<CConnmanTest>(0x1337, 0x1337);
|
||||
auto peerLogic = std::make_unique<PeerManager>(chainparams, *connman, nullptr, *m_node.scheduler,
|
||||
*m_node.chainman, *m_node.mempool, false);
|
||||
auto peerLogic = PeerManager::make(chainparams, *connman, nullptr, *m_node.scheduler,
|
||||
*m_node.chainman, *m_node.mempool, false);
|
||||
|
||||
constexpr int max_outbound_full_relay = MAX_OUTBOUND_FULL_RELAY_CONNECTIONS;
|
||||
CConnman::Options options;
|
||||
@ -224,8 +224,8 @@ BOOST_AUTO_TEST_CASE(peer_discouragement)
|
||||
const CChainParams& chainparams = Params();
|
||||
auto banman = MakeUnique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
|
||||
auto connman = MakeUnique<CConnman>(0x1337, 0x1337);
|
||||
auto peerLogic = std::make_unique<PeerManager>(chainparams, *connman, banman.get(), *m_node.scheduler,
|
||||
*m_node.chainman, *m_node.mempool, false);
|
||||
auto peerLogic = PeerManager::make(chainparams, *connman, banman.get(), *m_node.scheduler,
|
||||
*m_node.chainman, *m_node.mempool, false);
|
||||
|
||||
banman->ClearBanned();
|
||||
CAddress addr1(ip(0xa0b0c001), NODE_NONE);
|
||||
@ -271,8 +271,8 @@ BOOST_AUTO_TEST_CASE(DoS_bantime)
|
||||
const CChainParams& chainparams = Params();
|
||||
auto banman = MakeUnique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
|
||||
auto connman = MakeUnique<CConnman>(0x1337, 0x1337);
|
||||
auto peerLogic = std::make_unique<PeerManager>(chainparams, *connman, banman.get(), *m_node.scheduler,
|
||||
*m_node.chainman, *m_node.mempool, false);
|
||||
auto peerLogic = PeerManager::make(chainparams, *connman, banman.get(), *m_node.scheduler,
|
||||
*m_node.chainman, *m_node.mempool, false);
|
||||
|
||||
banman->ClearBanned();
|
||||
int64_t nStartTime = GetTime();
|
||||
|
||||
@ -192,9 +192,9 @@ TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const
|
||||
|
||||
m_node.banman = MakeUnique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
|
||||
m_node.connman = MakeUnique<CConnman>(0x1337, 0x1337); // Deterministic randomness for tests.
|
||||
m_node.peerman = std::make_unique<PeerManager>(chainparams, *m_node.connman, m_node.banman.get(),
|
||||
*m_node.scheduler, *m_node.chainman, *m_node.mempool,
|
||||
false);
|
||||
m_node.peerman = PeerManager::make(chainparams, *m_node.connman, m_node.banman.get(),
|
||||
*m_node.scheduler, *m_node.chainman, *m_node.mempool,
|
||||
false);
|
||||
{
|
||||
CConnman::Options options;
|
||||
options.m_msgproc = m_node.peerman.get();
|
||||
|
||||
@ -13,7 +13,7 @@ mutex:CConnman::ThreadOpenConnections
|
||||
mutex:CConnman::ThreadOpenAddedConnections
|
||||
mutex:CConnman::SocketHandler
|
||||
mutex:UpdateTip
|
||||
mutex:PeerManager::UpdatedBlockTip
|
||||
mutex:PeerManagerImpl::UpdatedBlockTip
|
||||
mutex:g_best_block_mutex
|
||||
|
||||
# race (TODO fix)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user