feat: introduce new bridge interface NetHandler to separate network logic and consensus

Author: knst

src/init.cpp

@@ -250,6 +250,9 @@ void Interrupt(NodeContext& node)
     if (node.active_ctx) {
         node.active_ctx->Interrupt();
     }
+    if (node.peerman) {
+        node.peerman->InterruptHandlers();
+    }
     if (node.llmq_ctx) {
         node.llmq_ctx->Interrupt();
     }
@@ -285,7 +288,10 @@ void PrepareShutdown(NodeContext& node)
     StopREST();
     StopRPC();
     StopHTTPServer();
+    if (node.peerman) node.peerman->RemoveHandlers();
+
     if (node.active_ctx) node.active_ctx->Stop();
+    if (node.peerman) node.peerman->StopHandlers();
     if (node.llmq_ctx) node.llmq_ctx->Stop();
 
     for (const auto& client : node.chain_clients) {
@@ -2286,6 +2292,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // ********************************************************* Step 10a: schedule Dash-specific tasks
 
     node.llmq_ctx->Start(*node.peerman);
+    node.peerman->StartHandlers();
     if (node.active_ctx) node.active_ctx->Start(*node.connman, *node.peerman);
 
     node.scheduler->scheduleEvery(std::bind(&CNetFulfilledRequestManager::DoMaintenance, std::ref(*node.netfulfilledman)), std::chrono::minutes{1});

src/net_processing.cpp

@@ -637,6 +637,21 @@ class PeerManagerImpl final : public PeerManager
     void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds) override;
     bool IsBanned(NodeId pnode) override EXCLUSIVE_LOCKS_REQUIRED(cs_main, !m_peer_mutex);
     size_t GetRequestedObjectCount(NodeId nodeid) const override EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
+    /** Implements external handlers logic */
+    void AddExtraHandler(std::unique_ptr<NetHandler>&& handler) override;
+    void RemoveHandlers() override;
+    void StartHandlers() override;
+    void StopHandlers() override;
+    void InterruptHandlers() override;
+
+    /** Implement PeerManagerInternal */
+    void PeerMisbehaving(const NodeId pnode, const int howmuch, const std::string& message = "") override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    void PeerEraseObjectRequest(const NodeId nodeid, const CInv& inv) override EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    void PeerRelayInv(const CInv& inv) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    void PeerRelayInvFiltered(const CInv& inv, const CTransaction& relatedTx) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    void PeerRelayInvFiltered(const CInv& inv, const uint256& relatedTxHash) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    void PeerAskPeersForTransaction(const uint256& txid) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 private:
     void _RelayTransaction(const uint256& txid) EXCLUSIVE_LOCKS_REQUIRED(cs_main, !m_peer_mutex);
 
@@ -1067,6 +1082,8 @@ class PeerManagerImpl final : public PeerManager
     std::vector<std::pair<uint256, CTransactionRef>> vExtraTxnForCompact GUARDED_BY(g_msgproc_mutex);
     /** Offset into vExtraTxnForCompact to insert the next tx */
     size_t vExtraTxnForCompactIt GUARDED_BY(g_msgproc_mutex) = 0;
+
+    std::vector<std::unique_ptr<NetHandler>> m_handlers;
 };
 
 // Keeps track of the time (in microseconds) when transactions were requested last time
@@ -1625,6 +1642,46 @@ size_t PeerManagerImpl::GetRequestedObjectCount(NodeId nodeid) const
     return state->m_object_download.m_object_process_time.size();
 }
 
+void PeerManagerImpl::AddExtraHandler(std::unique_ptr<NetHandler>&& handler)
+{
+    assert(handler != nullptr);
+    if (auto i = dynamic_cast<CValidationInterface*>(handler.get()); i != nullptr) {
+        RegisterValidationInterface(i);
+    }
+    m_handlers.emplace_back(std::move(handler));
+}
+
+void PeerManagerImpl::RemoveHandlers()
+{
+    InterruptHandlers();
+    StopHandlers();
+    m_handlers.clear();
+}
+
+void PeerManagerImpl::StartHandlers()
+{
+    for (auto& handler : m_handlers) {
+        handler->Start();
+    }
+}
+
+void PeerManagerImpl::StopHandlers()
+{
+    for (auto& handler : m_handlers) {
+        if (auto i = dynamic_cast<CValidationInterface*>(handler.get()); i != nullptr) {
+            UnregisterValidationInterface(i);
+        }
+        handler->Stop();
+    }
+}
+
+void PeerManagerImpl::InterruptHandlers()
+{
+    for (auto& handler : m_handlers) {
+        handler->Interrupt();
+    }
+}
+
 void PeerManagerImpl::UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds)
 {
     LOCK(cs_main);
@@ -5395,6 +5452,9 @@ void PeerManagerImpl::ProcessMessage(
         }
 
         PostProcessMessage(m_llmq_ctx->isman->ProcessMessage(pfrom.GetId(), msg_type, vRecv), pfrom.GetId());
+        for (const auto& handler : m_handlers) {
+            handler->ProcessMessage(pfrom, msg_type, vRecv);
+        }
         return;
     }
 
@@ -6470,3 +6530,33 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
     } // release cs_main
     return true;
 }
+
+void PeerManagerImpl::PeerMisbehaving(const NodeId pnode, const int howmuch, const std::string& message)
+{
+    Misbehaving(pnode, howmuch, message);
+}
+
+void PeerManagerImpl::PeerEraseObjectRequest(const NodeId nodeid, const CInv& inv)
+{
+    EraseObjectRequest(nodeid, inv);
+}
+
+void PeerManagerImpl::PeerRelayInv(const CInv& inv)
+{
+    RelayInv(inv);
+}
+
+void PeerManagerImpl::PeerRelayInvFiltered(const CInv& inv, const CTransaction& relatedTx)
+{
+    RelayInvFiltered(inv, relatedTx);
+}
+
+void PeerManagerImpl::PeerRelayInvFiltered(const CInv& inv, const uint256& relatedTxHash)
+{
+    RelayInvFiltered(inv, relatedTxHash);
+}
+
+void PeerManagerImpl::PeerAskPeersForTransaction(const uint256& txid)
+{
+    AskPeersForTransaction(txid);
+}

src/net_processing.h

@@ -55,7 +55,36 @@ struct CNodeStateStats {
     ServiceFlags their_services;
 };
 
-class PeerManager : public CValidationInterface, public NetEventsInterface
+class PeerManagerInternal
+{
+public:
+    virtual void PeerMisbehaving(const NodeId pnode, const int howmuch, const std::string& message = "") = 0;
+    virtual void PeerEraseObjectRequest(const NodeId nodeid, const CInv& inv) = 0;
+    virtual void PeerRelayInv(const CInv& inv) = 0;
+    virtual void PeerRelayInvFiltered(const CInv& inv, const CTransaction& relatedTx) = 0;
+    virtual void PeerRelayInvFiltered(const CInv& inv, const uint256& relatedTxHash) = 0;
+    virtual void PeerAskPeersForTransaction(const uint256& txid) = 0;
+};
+
+class NetHandler
+{
+public:
+    NetHandler(PeerManagerInternal* peer_manager) : m_peer_manager{Assert(peer_manager)} {}
+    virtual ~NetHandler() {
+        Interrupt();
+        Stop();
+    }
+
+    virtual void Start() {}
+    virtual void Stop() {}
+    virtual void Interrupt() {}
+    virtual void ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv) {}
+protected:
+    PeerManagerInternal* m_peer_manager;
+};
+
+
+class PeerManager : public CValidationInterface, public NetEventsInterface, public PeerManagerInternal
 {
 public:
     static std::unique_ptr<PeerManager> make(const CChainParams& chainparams, CConnman& connman, AddrMan& addrman,
@@ -133,6 +162,12 @@ class PeerManager : public CValidationInterface, public NetEventsInterface
     virtual bool IsBanned(NodeId pnode) = 0;
 
     virtual size_t GetRequestedObjectCount(NodeId nodeid) const = 0;
+
+    virtual void AddExtraHandler(std::unique_ptr<NetHandler>&& handler) = 0;
+    virtual void RemoveHandlers() = 0;
+    virtual void StartHandlers() = 0;
+    virtual void StopHandlers() = 0;
+    virtual void InterruptHandlers() = 0;
 };
 
 #endif // BITCOIN_NET_PROCESSING_H