From 06069b3913dda048f5d640a662b0852f86346ace Mon Sep 17 00:00:00 2001 From: TheCharlatan Date: Wed, 24 Jan 2024 14:12:33 +0100 Subject: [PATCH] scripted-diff: Rename MainSignals to ValidationSignals -BEGIN VERIFY SCRIPT- s() { git grep -l "$1" src | xargs sed -i "s/$1/$2/g"; } s 'CMainSignals' 'ValidationSignals' s 'MainSignalsImpl' 'ValidationSignalsImpl' -END VERIFY SCRIPT- --- src/bitcoin-chainstate.cpp | 2 +- src/init.cpp | 2 +- src/kernel/chainstatemanager_opts.h | 4 +-- src/kernel/mempool_options.h | 4 +-- src/node/context.h | 4 +-- src/node/interfaces.cpp | 6 ++-- src/test/util/setup_common.cpp | 2 +- src/test/validationinterface_tests.cpp | 4 +-- src/txmempool.h | 4 +-- src/validation.cpp | 2 +- src/validationinterface.cpp | 48 +++++++++++++------------- src/validationinterface.h | 12 +++---- 12 files changed, 47 insertions(+), 47 deletions(-) diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp index f90ae93eca6..c4ff4f8ff7b 100644 --- a/src/bitcoin-chainstate.cpp +++ b/src/bitcoin-chainstate.cpp @@ -74,7 +74,7 @@ int main(int argc, char* argv[]) // Start the lightweight task scheduler thread scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { scheduler.serviceQueue(); }); - CMainSignals validation_signals{scheduler}; + ValidationSignals validation_signals{scheduler}; // Gather some entropy once per minute. scheduler.scheduleEvery(RandAddPeriodic, std::chrono::minutes{1}); diff --git a/src/init.cpp b/src/init.cpp index a90f868977f..3db22e71f9f 100644 --- a/src/init.cpp +++ b/src/init.cpp @@ -1164,7 +1164,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info) }, std::chrono::minutes{5}); assert(!node.validation_signals); - node.validation_signals = std::make_unique(scheduler); + node.validation_signals = std::make_unique(scheduler); auto& validation_signals = *node.validation_signals; // Create client interfaces for wallets that are supposed to be loaded diff --git a/src/kernel/chainstatemanager_opts.h b/src/kernel/chainstatemanager_opts.h index 766a812d91b..de5f78494a2 100644 --- a/src/kernel/chainstatemanager_opts.h +++ b/src/kernel/chainstatemanager_opts.h @@ -18,7 +18,7 @@ #include class CChainParams; -class CMainSignals; +class ValidationSignals; static constexpr bool DEFAULT_CHECKPOINTS_ENABLED{true}; static constexpr auto DEFAULT_MAX_TIP_AGE{24h}; @@ -45,7 +45,7 @@ struct ChainstateManagerOpts { DBOptions coins_db{}; CoinsViewOptions coins_view{}; Notifications& notifications; - CMainSignals* signals{nullptr}; + ValidationSignals* signals{nullptr}; //! Number of script check worker threads. Zero means no parallel verification. int worker_threads_num{0}; }; diff --git a/src/kernel/mempool_options.h b/src/kernel/mempool_options.h index 1f69df95ff2..0850b2e60e1 100644 --- a/src/kernel/mempool_options.h +++ b/src/kernel/mempool_options.h @@ -13,7 +13,7 @@ #include #include -class CMainSignals; +class ValidationSignals; /** Default for -maxmempool, maximum megabytes of mempool memory usage */ static constexpr unsigned int DEFAULT_MAX_MEMPOOL_SIZE_MB{300}; @@ -59,7 +59,7 @@ struct MemPoolOptions { bool persist_v1_dat{DEFAULT_PERSIST_V1_DAT}; MemPoolLimits limits{}; - CMainSignals* signals{nullptr}; + ValidationSignals* signals{nullptr}; }; } // namespace kernel diff --git a/src/node/context.h b/src/node/context.h index 189e5e6ae4a..245f230aece 100644 --- a/src/node/context.h +++ b/src/node/context.h @@ -20,7 +20,7 @@ class BanMan; class BaseIndex; class CBlockPolicyEstimator; class CConnman; -class CMainSignals; +class ValidationSignals; class CScheduler; class CTxMemPool; class ChainstateManager; @@ -74,7 +74,7 @@ struct NodeContext { //! Issues blocking calls about sync status, errors and warnings std::unique_ptr notifications; //! Issues calls about blocks and transactions - std::unique_ptr validation_signals; + std::unique_ptr validation_signals; std::atomic exit_status{EXIT_SUCCESS}; //! Declare default constructor and destructor that are not inline, so code diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp index 1814834f359..f9a372e3de9 100644 --- a/src/node/interfaces.cpp +++ b/src/node/interfaces.cpp @@ -460,7 +460,7 @@ public: class NotificationsHandlerImpl : public Handler { public: - explicit NotificationsHandlerImpl(CMainSignals& signals, std::shared_ptr notifications) + explicit NotificationsHandlerImpl(ValidationSignals& signals, std::shared_ptr notifications) : m_signals{signals}, m_proxy{std::make_shared(std::move(notifications))} { m_signals.RegisterSharedValidationInterface(m_proxy); @@ -473,7 +473,7 @@ public: m_proxy.reset(); } } - CMainSignals& m_signals; + ValidationSignals& m_signals; std::shared_ptr m_proxy; }; @@ -823,7 +823,7 @@ public: NodeContext* context() override { return &m_node; } ArgsManager& args() { return *Assert(m_node.args); } ChainstateManager& chainman() { return *Assert(m_node.chainman); } - CMainSignals& validation_signals() { return *Assert(m_node.validation_signals); } + ValidationSignals& validation_signals() { return *Assert(m_node.validation_signals); } NodeContext& m_node; }; } // namespace diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp index 8e9e771b53e..d93edbc3325 100644 --- a/src/test/util/setup_common.cpp +++ b/src/test/util/setup_common.cpp @@ -171,7 +171,7 @@ ChainTestingSetup::ChainTestingSetup(const ChainType chainType, const std::vecto // from blocking due to queue overrun. m_node.scheduler = std::make_unique(); m_node.scheduler->m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { m_node.scheduler->serviceQueue(); }); - m_node.validation_signals = std::make_unique(*m_node.scheduler); + m_node.validation_signals = std::make_unique(*m_node.scheduler); m_node.fee_estimator = std::make_unique(FeeestPath(*m_node.args), DEFAULT_ACCEPT_STALE_FEE_ESTIMATES); m_node.mempool = std::make_unique(MemPoolOptionsForTest(m_node)); diff --git a/src/test/validationinterface_tests.cpp b/src/test/validationinterface_tests.cpp index 1e883c4f202..a46cfc30292 100644 --- a/src/test/validationinterface_tests.cpp +++ b/src/test/validationinterface_tests.cpp @@ -52,7 +52,7 @@ BOOST_AUTO_TEST_CASE(unregister_validation_interface_race) class TestInterface : public CValidationInterface { public: - TestInterface(CMainSignals& signals, std::function on_call = nullptr, std::function on_destroy = nullptr) + TestInterface(ValidationSignals& signals, std::function on_call = nullptr, std::function on_destroy = nullptr) : m_on_call(std::move(on_call)), m_on_destroy(std::move(on_destroy)), m_signals{signals} { } @@ -72,7 +72,7 @@ public: } std::function m_on_call; std::function m_on_destroy; - CMainSignals& m_signals; + ValidationSignals& m_signals; }; // Regression test to ensure UnregisterAllValidationInterfaces calls don't diff --git a/src/txmempool.h b/src/txmempool.h index 5e0f22229b1..32f2c024f76 100644 --- a/src/txmempool.h +++ b/src/txmempool.h @@ -40,7 +40,7 @@ #include class CChain; -class CMainSignals; +class ValidationSignals; /** Fake height value used in Coin to signify they are only in the memory pool (since 0.8) */ static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF; @@ -448,7 +448,7 @@ public: const Limits m_limits; - CMainSignals* const m_signals; + ValidationSignals* const m_signals; /** Create a new CTxMemPool. * Sanity checks will be off by default for performance, because otherwise diff --git a/src/validation.cpp b/src/validation.cpp index 7490ad012f0..9def734fcc1 100644 --- a/src/validation.cpp +++ b/src/validation.cpp @@ -3213,7 +3213,7 @@ static bool NotifyHeaderTip(ChainstateManager& chainman) LOCKS_EXCLUDED(cs_main) return fNotify; } -static void LimitValidationInterfaceQueue(CMainSignals& signals) LOCKS_EXCLUDED(cs_main) { +static void LimitValidationInterfaceQueue(ValidationSignals& signals) LOCKS_EXCLUDED(cs_main) { AssertLockNotHeld(cs_main); if (signals.CallbacksPending() > 10) { diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp index 4ab66336da7..25b1e561dcc 100644 --- a/src/validationinterface.cpp +++ b/src/validationinterface.cpp @@ -22,14 +22,14 @@ std::string RemovalReasonToString(const MemPoolRemovalReason& r) noexcept; /** - * MainSignalsImpl manages a list of shared_ptr callbacks. + * ValidationSignalsImpl manages a list of shared_ptr callbacks. * * A std::unordered_map is used to track what callbacks are currently * registered, and a std::list is used to store the callbacks that are * currently registered as well as any callbacks that are just unregistered * and about to be deleted when they are done executing. */ -class MainSignalsImpl +class ValidationSignalsImpl { private: Mutex m_mutex; @@ -47,7 +47,7 @@ public: // our own queue here :( SerialTaskRunner m_task_runner; - explicit MainSignalsImpl(CScheduler& scheduler LIFETIMEBOUND) : m_task_runner(scheduler) {} + explicit ValidationSignalsImpl(CScheduler& scheduler LIFETIMEBOUND) : m_task_runner(scheduler) {} void Register(std::shared_ptr callbacks) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) { @@ -94,56 +94,56 @@ public: } }; -CMainSignals::CMainSignals(CScheduler& scheduler) - : m_internals{std::make_unique(scheduler)} {} +ValidationSignals::ValidationSignals(CScheduler& scheduler) + : m_internals{std::make_unique(scheduler)} {} -CMainSignals::~CMainSignals() {} +ValidationSignals::~ValidationSignals() {} -void CMainSignals::FlushBackgroundCallbacks() +void ValidationSignals::FlushBackgroundCallbacks() { m_internals->m_task_runner.flush(); } -size_t CMainSignals::CallbacksPending() +size_t ValidationSignals::CallbacksPending() { return m_internals->m_task_runner.size(); } -void CMainSignals::RegisterSharedValidationInterface(std::shared_ptr callbacks) +void ValidationSignals::RegisterSharedValidationInterface(std::shared_ptr callbacks) { // Each connection captures the shared_ptr to ensure that each callback is // executed before the subscriber is destroyed. For more details see #18338. m_internals->Register(std::move(callbacks)); } -void CMainSignals::RegisterValidationInterface(CValidationInterface* callbacks) +void ValidationSignals::RegisterValidationInterface(CValidationInterface* callbacks) { // Create a shared_ptr with a no-op deleter - CValidationInterface lifecycle // is managed by the caller. RegisterSharedValidationInterface({callbacks, [](CValidationInterface*){}}); } -void CMainSignals::UnregisterSharedValidationInterface(std::shared_ptr callbacks) +void ValidationSignals::UnregisterSharedValidationInterface(std::shared_ptr callbacks) { UnregisterValidationInterface(callbacks.get()); } -void CMainSignals::UnregisterValidationInterface(CValidationInterface* callbacks) +void ValidationSignals::UnregisterValidationInterface(CValidationInterface* callbacks) { m_internals->Unregister(callbacks); } -void CMainSignals::UnregisterAllValidationInterfaces() +void ValidationSignals::UnregisterAllValidationInterfaces() { m_internals->Clear(); } -void CMainSignals::CallFunctionInValidationInterfaceQueue(std::function func) +void ValidationSignals::CallFunctionInValidationInterfaceQueue(std::function func) { m_internals->m_task_runner.insert(std::move(func)); } -void CMainSignals::SyncWithValidationInterfaceQueue() +void ValidationSignals::SyncWithValidationInterfaceQueue() { AssertLockNotHeld(cs_main); // Block until the validation queue drains @@ -171,7 +171,7 @@ void CMainSignals::SyncWithValidationInterfaceQueue() #define LOG_EVENT(fmt, ...) \ LogPrint(BCLog::VALIDATION, fmt "\n", __VA_ARGS__) -void CMainSignals::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) { +void ValidationSignals::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) { // Dependencies exist that require UpdatedBlockTip events to be delivered in the order in which // the chain actually updates. One way to ensure this is for the caller to invoke this signal // in the same critical section where the chain is updated @@ -185,7 +185,7 @@ void CMainSignals::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockInd fInitialDownload); } -void CMainSignals::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence) +void ValidationSignals::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence) { auto event = [tx, mempool_sequence, this] { m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.TransactionAddedToMempool(tx, mempool_sequence); }); @@ -195,7 +195,7 @@ void CMainSignals::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx tx.info.m_tx->GetWitnessHash().ToString()); } -void CMainSignals::TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) { +void ValidationSignals::TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) { auto event = [tx, reason, mempool_sequence, this] { m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.TransactionRemovedFromMempool(tx, reason, mempool_sequence); }); }; @@ -205,7 +205,7 @@ void CMainSignals::TransactionRemovedFromMempool(const CTransactionRef& tx, MemP RemovalReasonToString(reason)); } -void CMainSignals::BlockConnected(ChainstateRole role, const std::shared_ptr &pblock, const CBlockIndex *pindex) { +void ValidationSignals::BlockConnected(ChainstateRole role, const std::shared_ptr &pblock, const CBlockIndex *pindex) { auto event = [role, pblock, pindex, this] { m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockConnected(role, pblock, pindex); }); }; @@ -214,7 +214,7 @@ void CMainSignals::BlockConnected(ChainstateRole role, const std::shared_ptrnHeight); } -void CMainSignals::MempoolTransactionsRemovedForBlock(const std::vector& txs_removed_for_block, unsigned int nBlockHeight) +void ValidationSignals::MempoolTransactionsRemovedForBlock(const std::vector& txs_removed_for_block, unsigned int nBlockHeight) { auto event = [txs_removed_for_block, nBlockHeight, this] { m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.MempoolTransactionsRemovedForBlock(txs_removed_for_block, nBlockHeight); }); @@ -224,7 +224,7 @@ void CMainSignals::MempoolTransactionsRemovedForBlock(const std::vector& pblock, const CBlockIndex* pindex) +void ValidationSignals::BlockDisconnected(const std::shared_ptr& pblock, const CBlockIndex* pindex) { auto event = [pblock, pindex, this] { m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockDisconnected(pblock, pindex); }); @@ -234,7 +234,7 @@ void CMainSignals::BlockDisconnected(const std::shared_ptr& pblock pindex->nHeight); } -void CMainSignals::ChainStateFlushed(ChainstateRole role, const CBlockLocator &locator) { +void ValidationSignals::ChainStateFlushed(ChainstateRole role, const CBlockLocator &locator) { auto event = [role, locator, this] { m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.ChainStateFlushed(role, locator); }); }; @@ -242,13 +242,13 @@ void CMainSignals::ChainStateFlushed(ChainstateRole role, const CBlockLocator &l locator.IsNull() ? "null" : locator.vHave.front().ToString()); } -void CMainSignals::BlockChecked(const CBlock& block, const BlockValidationState& state) { +void ValidationSignals::BlockChecked(const CBlock& block, const BlockValidationState& state) { LOG_EVENT("%s: block hash=%s state=%s", __func__, block.GetHash().ToString(), state.ToString()); m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockChecked(block, state); }); } -void CMainSignals::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr &block) { +void ValidationSignals::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr &block) { LOG_EVENT("%s: block hash=%s", __func__, block->GetHash().ToString()); m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NewPoWValidBlock(pindex, block); }); } diff --git a/src/validationinterface.h b/src/validationinterface.h index fa63570c1fe..4bd46da2df4 100644 --- a/src/validationinterface.h +++ b/src/validationinterface.h @@ -150,19 +150,19 @@ protected: * has been received and connected to the headers tree, though not validated yet. */ virtual void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr& block) {}; - friend class CMainSignals; + friend class ValidationSignals; friend class ValidationInterfaceTest; }; -class MainSignalsImpl; -class CMainSignals { +class ValidationSignalsImpl; +class ValidationSignals { private: - std::unique_ptr m_internals; + std::unique_ptr m_internals; public: - CMainSignals(CScheduler& scheduler LIFETIMEBOUND); + ValidationSignals(CScheduler& scheduler LIFETIMEBOUND); - ~CMainSignals(); + ~ValidationSignals(); /** Call any remaining callbacks on the calling thread */ void FlushBackgroundCallbacks();