init: add pause_load_mempool test hook

A new -test=pause_load_mempool argument lets the test framework pause
node initialization right before loading the mempool. When set, the
node checks for the existence of a pause_load_mempool file and waits
until that file is removed.

Use this mechanism to test that savemempool fails before the mempool
is loaded, and that getmempoolinfo's "loaded" field is false.

Also add a test to ensure the pause can be interrupted.

Author: Sjors

src/common/args.cpp

@@ -769,6 +769,7 @@ const std::vector<std::string> TEST_OPTIONS_DOC{
     "addrman (use deterministic addrman)",
     "reindex_after_failure_noninteractive_yes (When asked for a reindex after failure interactively, simulate as-if answered with 'yes')",
     "bip94 (enforce BIP94 consensus rules)",
+    "pause_load_mempool (pause startup before loading mempool until regtest/pause_load_mempool is removed)",
 };
 
 bool HasTestOption(const ArgsManager& args, const std::string& test_option)

src/init.cpp

@@ -745,6 +745,17 @@ static void StartupNotify(const ArgsManager& args)
 }
 #endif
 
+static void MaybeWaitForTestPause(const ArgsManager& args, const util::SignalInterrupt& interrupt, const std::string& test_option)
+{
+    if (!HasTestOption(args, test_option)) return;
+    const fs::path pause_file{args.GetDataDirNet() / fs::PathFromString(test_option)};
+
+    LogInfo("Waiting for test pause file %s to be removed\n", fs::PathToString(pause_file));
+    while (!interrupt && fs::exists(pause_file)) {
+        UninterruptibleSleep(std::chrono::milliseconds{10});
+    }
+}
+
 static bool AppInitServers(NodeContext& node)
 {
     const ArgsManager& args = *Assert(node.args);
@@ -2044,6 +2055,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
         // Load mempool from disk
         if (auto* pool{chainman.ActiveChainstate().GetMempool()}) {
+            MaybeWaitForTestPause(args, chainman.m_interrupt, "pause_load_mempool");
             LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {});
             pool->SetLoadTried(!chainman.m_interrupt);
         }

test/functional/feature_init.py

@@ -292,12 +292,28 @@ def init_empty_test(self):
         for option in options:
             self.restart_node(1, option)
 
+    def init_pause_load_mempool_interrupt_test(self):
+        self.log.info("Test interrupting startup while pause_load_mempool is active")
+        node = self.nodes[0]
+        pause_file = node.chain_path / "pause_load_mempool"
+        pause_file.touch()
+
+        with node.busy_wait_for_debug_log([b"Waiting for test pause file"]):
+            self.start_breakable(node, extra_args=["-test=pause_load_mempool"], wait_for_import=False)
+
+        self.sigterm_node(node)
+        pause_file.unlink()
+
+        self.check_clean_start(node, [])
+        self.stop_node(0)
+
     def run_test(self):
         self.init_pid_test()
         self.init_stress_test_interrupt()
         self.init_stress_test_removals()
         self.break_wait_test()
         self.init_empty_test()
+        self.init_pause_load_mempool_interrupt_test()
 
 
 if __name__ == '__main__':

test/functional/mempool_persist.py

@@ -52,7 +52,7 @@
 class MempoolPersistTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 3
-        self.extra_args = [[], ["-persistmempool=0"], []]
+        self.extra_args = [["-test=pause_load_mempool"], ["-persistmempool=0"], []]
         self.uses_wallet = None
 
     def run_test(self):
@@ -114,7 +114,15 @@ def run_test(self):
         # Give this node a head-start, so we can be "extra-sure" that it didn't load anything later
         # Also don't store the mempool, to keep the datadir clean
         self.start_node(1, extra_args=["-persistmempool=0"])
-        self.start_node(0)
+        # Pause this node during init, in order to check that we can't save
+        # the mempool before it's loaded.
+        pause_file = self.nodes[0].chain_path / "pause_load_mempool"
+        pause_file.touch()
+        self.start_node(0, wait_for_import=False)
+        assert not self.nodes[0].getmempoolinfo()["loaded"]
+        assert_raises_rpc_error(-1, "The mempool was not loaded yet", self.nodes[0].savemempool)
+        pause_file.unlink()
+        self.nodes[0].wait_until(lambda: self.nodes[0].getmempoolinfo()["loaded"])
         self.start_node(2)
         assert self.nodes[0].getmempoolinfo()["loaded"]  # start_node is blocking on the mempool being loaded
         assert self.nodes[2].getmempoolinfo()["loaded"]