test: insert stall to ensure proper timing of test

With this change in place, `process_next_nakamoto_block_deadlock` will
timeout without the fix, and run successfully with the fix in place.

Author: obycode

stackslib/src/chainstate/nakamoto/coordinator/tests.rs

@@ -48,6 +48,7 @@ use crate::chainstate::nakamoto::tests::get_account;
 use crate::chainstate::nakamoto::tests::node::TestStacker;
 use crate::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockObtainMethod, NakamotoChainState, NakamotoStagingBlocksConnRef,
+    TEST_PROCESS_BLOCK_STALL,
 };
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::pox_4_tests::{get_stacking_minimum, get_tip};
@@ -2495,6 +2496,7 @@ fn process_next_nakamoto_block_deadlock() {
     info!("Creating peer");
 
     let mut peer = boot_plan.boot_into_nakamoto_peer(vec![], None);
+    let mut sortition_db = peer.sortdb().reopen().unwrap();
     let (chainstate, _) = &mut peer
         .stacks_node
         .as_mut()
@@ -2503,20 +2505,26 @@ fn process_next_nakamoto_block_deadlock() {
         .reopen()
         .unwrap();
 
-    // Lock the sortdb
-    info!("  -------------------------------   TRYING TO LOCK THE SORTDB");
-    let mut sortition_db = peer.sortdb().reopen().unwrap();
-    let sort_tx = sortition_db.tx_begin().unwrap();
-    info!("  -------------------------------   SORTDB LOCKED");
+    TEST_PROCESS_BLOCK_STALL.lock().unwrap().replace(true);
 
     let miner_thread = std::thread::spawn(move || {
         info!("  -------------------------------   MINING TENURE");
         let (block, burn_height, ..) =
             peer.single_block_tenure(&private_key, |_| {}, |_| {}, |_| true);
-        peer.try_process_block(&block).unwrap();
         info!("  -------------------------------   TENURE MINED");
     });
 
+    // Wait a bit, to ensure the miner has reached the stall
+    std::thread::sleep(std::time::Duration::from_secs(10));
+
+    // Lock the sortdb
+    info!("  -------------------------------   TRYING TO LOCK THE SORTDB");
+    let sort_tx = sortition_db.tx_begin().unwrap();
+    info!("  -------------------------------   SORTDB LOCKED");
+
+    // Un-stall the block processing
+    TEST_PROCESS_BLOCK_STALL.lock().unwrap().replace(false);
+
     // Wait a bit, to ensure the tenure will have grabbed any locks it needs
     std::thread::sleep(std::time::Duration::from_secs(10));
 

stackslib/src/chainstate/nakamoto/mod.rs

@@ -270,6 +270,10 @@ lazy_static! {
     ];
 }
 
+// Cause an artifical stall in block-processing, for testing.
+#[cfg(any(test, feature = "testing"))]
+pub static TEST_PROCESS_BLOCK_STALL: std::sync::Mutex<Option<bool>> = std::sync::Mutex::new(None);
+
 /// Trait for common MARF getters between StacksDBConn and StacksDBTx
 pub trait StacksDBIndexed {
     fn get(&mut self, tip: &StacksBlockId, key: &str) -> Result<Option<String>, DBError>;
@@ -1722,6 +1726,17 @@ impl NakamotoChainState {
         canonical_sortition_tip: &SortitionId,
         dispatcher_opt: Option<&'a T>,
     ) -> Result<Option<StacksEpochReceipt>, ChainstateError> {
+        #[cfg(any(test, feature = "testing"))]
+        {
+            if *TEST_PROCESS_BLOCK_STALL.lock().unwrap() == Some(true) {
+                // Do an extra check just so we don't log EVERY time.
+                warn!("Block processing is stalled due to testing directive.");
+                while *TEST_PROCESS_BLOCK_STALL.lock().unwrap() == Some(true) {
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                }
+                info!("Block processing is no longer stalled due to testing directive.");
+            }
+        }
         let nakamoto_blocks_db = stacks_chain_state.nakamoto_blocks_db();
         let Some((next_ready_block, block_size)) =
             nakamoto_blocks_db.next_ready_nakamoto_block(stacks_chain_state.db())?