chore: Move replay-mock-mining to stacks-node binary

Author: jbencin

stackslib/src/main.rs

@@ -39,7 +39,6 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fs::{File, OpenOptions};
 use std::io::prelude::*;
 use std::io::BufReader;
-use std::path::PathBuf;
 use std::time::Instant;
 use std::{env, fs, io, process, thread};
 
@@ -94,7 +93,7 @@ use stacks_common::util::hash::{hex_bytes, to_hex, Hash160};
 use stacks_common::util::retry::LogReader;
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::vrf::VRFProof;
-use stacks_common::util::{deserialize_json_from_file, get_epoch_time_ms, log, sleep_ms};
+use stacks_common::util::{get_epoch_time_ms, log, sleep_ms};
 
 #[cfg_attr(test, mutants::skip)]
 fn main() {
@@ -1341,88 +1340,6 @@ simulating a miner.
         );
         return;
     }
-    if argv[1] == "replay-mock-mining" {
-        let print_help_and_exit = || {
-            let n = &argv[0];
-            eprintln!("Usage:");
-            eprintln!("  {n} <mock-miner-output-dir>");
-            process::exit(1);
-        };
-
-        // Process CLI args
-        let dir = argv
-            .get(2)
-            .map(PathBuf::from)
-            .map(fs::canonicalize)
-            .transpose()
-            .unwrap_or_else(|e| panic!("Not a valid path: {e}"))
-            .unwrap_or_else(print_help_and_exit);
-
-        if !dir.is_dir() {
-            panic!("Not a valid directory: {dir:?}");
-        }
-
-        // Read entries in directory
-        let dir_entries = dir
-            .read_dir()
-            .unwrap_or_else(|e| panic!("Failed to read directory: {e}"))
-            .filter_map(|e| e.ok());
-
-        // Get filenames, filtering out anything that isn't a regular file
-        let filenames = dir_entries.filter_map(|e| match e.file_type() {
-            Ok(t) if t.is_file() => e.file_name().into_string().ok(),
-            _ => None,
-        });
-
-        // Get vec of (block_height, filename), to prepare for sorting
-        //
-        // NOTE: Trusting the filename is not ideal. We could sort on data read from the file,
-        // but that requires reading all files
-        let re = Regex::new(r"^([0-9]+\.json)$").unwrap();
-        let mut indexed_files = filenames
-            .filter_map(|filename| {
-                // Use regex to extract block number from filename
-                let Some(cap) = re.captures(&filename) else {
-                    return None;
-                };
-                let Some(m) = cap.get(0) else {
-                    return None;
-                };
-                let Ok(bh) = m.as_str().parse::<u64>() else {
-                    return None;
-                };
-                Some((bh, filename))
-            })
-            .collect::<Vec<_>>();
-
-        // Sort by block height
-        indexed_files.sort_by_key(|(bh, _)| *bh);
-
-        if indexed_files.is_empty() {
-            panic!("No block files found");
-        }
-
-        info!(
-            "Replaying {} blocks starting at {}",
-            indexed_files.len(),
-            indexed_files[0].0
-        );
-
-        for (bh, filename) in indexed_files {
-            let filepath = dir.join(filename);
-            info!("Replaying block from file";
-                "block_height" => bh,
-                "filepath" => ?filepath
-            );
-            // let block = AssembledAnchorBlock::deserialize_json_from_file(filepath)
-            //     .unwrap_or_else(|e| panic!("Error reading block {block} from file: {e}"));
-            // debug!("Replaying block from {filepath:?}";
-            //     "block_height" => bh,
-            //     "block" => %block
-            // );
-            // TODO: Actually replay block
-        }
-    }
 
     if argv.len() < 4 {
         eprintln!("Usage: {} blockchain network working_dir", argv[0]);

testnet/stacks-node/src/main.rs

@@ -10,9 +10,12 @@ extern crate stacks;
 #[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
 extern crate slog;
 
+use regex::Regex;
 pub use stacks_common::util;
 use stacks_common::util::hash::hex_bytes;
 
+use crate::neon_node::AssembledAnchorBlock;
+
 pub mod monitoring;
 
 pub mod burnchains;
@@ -31,7 +34,8 @@ pub mod syncctl;
 pub mod tenure;
 
 use std::collections::HashMap;
-use std::{env, panic, process};
+use std::path::PathBuf;
+use std::{env, fs, panic, process};
 
 use backtrace::Backtrace;
 use pico_args::Arguments;
@@ -166,10 +170,8 @@ fn cli_get_miner_spend(
                 return 0.0;
             };
             let Ok(active_miners_and_commits) =
-                MinerStats::get_active_miners(&sortdb, Some(burn_block_height)).map_err(|e| {
-                    warn!("Failed to get active miners: {:?}", &e);
-                    e
-                })
+                MinerStats::get_active_miners(&sortdb, Some(burn_block_height))
+                    .inspect_err(|e| warn!("Failed to get active miners: {e:?}"))
             else {
                 return 0.0;
             };
@@ -187,10 +189,7 @@ fn cli_get_miner_spend(
 
             let Ok(unconfirmed_block_commits) = miner_stats
                 .get_unconfirmed_commits(burn_block_height + 1, &active_miners)
-                .map_err(|e| {
-                    warn!("Failed to find unconfirmed block-commits: {}", &e);
-                    e
-                })
+                .inspect_err(|e| warn!("Failed to find unconfirmed block-commits: {e}"))
             else {
                 return 0.0;
             };
@@ -229,10 +228,7 @@ fn cli_get_miner_spend(
                         &commit_outs,
                         at_burnchain_height,
                     )
-                    .map_err(|e| {
-                        warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
-                        e
-                    })
+                    .inspect_err(|e| warn!("Failed to get unconfirmed burn distribution: {e:?}"))
                 else {
                     return 0.0;
                 };
@@ -265,6 +261,82 @@ fn cli_get_miner_spend(
     spend_amount
 }
 
+fn cli_replay_mock_mining(config_path: &str, path: &str) {
+    info!("Loading config at path {config_path}");
+    let config = match ConfigFile::from_path(&config_path) {
+        Ok(config_file) => Config::from_config_file(config_file, true).unwrap(),
+        Err(e) => {
+            warn!("Invalid config file: {e}");
+            process::exit(1);
+        }
+    };
+
+    // Validate directory path
+    let dir = PathBuf::from(path);
+    let dir = fs::canonicalize(dir).unwrap_or_else(|e| panic!("{path} is not a valid path: {e}"));
+
+    if !dir.is_dir() {
+        panic!("{path} is not a valid directory");
+    }
+
+    // Read entries in directory
+    let dir_entries = dir
+        .read_dir()
+        .unwrap_or_else(|e| panic!("Failed to read {path}: {e}"))
+        .filter_map(|e| e.ok());
+
+    // Get filenames, filtering out anything that isn't a regular file
+    let filenames = dir_entries.filter_map(|e| match e.file_type() {
+        Ok(t) if t.is_file() => e.file_name().into_string().ok(),
+        _ => None,
+    });
+
+    // Get vec of (block_height, filename), to prepare for sorting
+    //
+    // NOTE: Trusting the filename is not ideal. We could sort on data read from the file,
+    // but that requires reading all files
+    let re = Regex::new(r"^([0-9]+\.json)$").unwrap();
+    let mut indexed_files = filenames
+        .filter_map(|filename| {
+            // Use regex to extract block number from filename
+            let Some(cap) = re.captures(&filename) else {
+                return None;
+            };
+            let Some(m) = cap.get(0) else {
+                return None;
+            };
+            let Ok(bh) = m.as_str().parse::<u64>() else {
+                return None;
+            };
+            Some((bh, filename))
+        })
+        .collect::<Vec<_>>();
+
+    // Sort by block height
+    indexed_files.sort_by_key(|(bh, _)| *bh);
+
+    if indexed_files.is_empty() {
+        panic!("No block files found");
+    }
+
+    info!(
+        "Replaying {} blocks starting at {}",
+        indexed_files.len(),
+        indexed_files[0].0
+    );
+
+    for (bh, filename) in indexed_files {
+        let filepath = dir.join(filename);
+        let block = AssembledAnchorBlock::deserialize_from_file(&filepath)
+            .unwrap_or_else(|e| panic!("Error reading block {bh} from file: {e}"));
+        debug!("Replaying block from {filepath:?}";
+            "block_height" => bh,
+            "block" => ?block
+        );
+        // TODO: Actually replay block
+    }
+}
+
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
         error!("Process abort due to thread panic: {}", panic_info);
@@ -412,6 +484,13 @@ fn main() {
             println!("Will spend {}", spend_amount);
             process::exit(0);
         }
+        "replay-mock-mining" => {
+            let path: String = args.value_from_str("--path").unwrap();
+            let config_path: String = args.value_from_str("--config").unwrap();
+            args.finish();
+            cli_replay_mock_mining(&config_path, &path);
+            process::exit(0);
+        }
         _ => {
             print_help();
             return;
@@ -502,6 +581,11 @@ key-for-seed\tOutput the associated secret key for a burnchain signer created wi
 \t\tCan be passed a config file for the seed via the `--config <file>` option *or* by supplying the hex seed on
 \t\tthe command line directly.
 
+replay-mock-mining\tReplay mock mined blocks from <dir>
+\t\tArguments:
+\t\t  --path: path to directory of mock mined blocks
+\t\t  --config: path to the config file
+
 help\t\tDisplay this help.
 
 OPTIONAL ARGUMENTS:

testnet/stacks-node/src/neon_node.rs

@@ -239,7 +239,7 @@ pub(crate) enum MinerThreadResult {
 /// Fully-assembled Stacks anchored, block as well as some extra metadata pertaining to how it was
 /// linked to the burnchain and what view(s) the miner had of the burnchain before and after
 /// completing the block.
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AssembledAnchorBlock {
     /// Consensus hash of the parent Stacks block
     parent_consensus_hash: ConsensusHash,
@@ -3603,22 +3603,17 @@ impl RelayerThread {
             }
         }
 
-        let mut miner_thread_state =
-            match self.create_block_miner(registered_key, last_burn_block, issue_timestamp_ms) {
-                Some(state) => state,
-                None => {
-                    return false;
-                }
-            };
+        let Some(mut miner_thread_state) =
+            self.create_block_miner(registered_key, last_burn_block, issue_timestamp_ms)
+        else {
+            return false;
+        };
 
         if let Ok(miner_handle) = thread::Builder::new()
             .name(format!("miner-block-{}", self.local_peer.data_url))
             .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
             .spawn(move || miner_thread_state.run_tenure())
-            .map_err(|e| {
-                error!("Relayer: Failed to start tenure thread: {:?}", &e);
-                e
-            })
+            .inspect_err(|e| error!("Relayer: Failed to start tenure thread: {e:?}"))
         {
             self.miner_thread = Some(miner_handle);
         }