refactor: add timing info to pause logs

Signed-off-by: William Hankins <[email protected]>

Author: whankinsiv

modules/mithril_snapshot_fetcher/src/mithril_snapshot_fetcher.rs

@@ -335,14 +335,11 @@ impl MithrilSnapshotFetcher {
 
                         // Check pause constraint
                         if pause_constraint.should_pause(&block_info) {
-                            let description = pause_constraint.get_description();
-                            let next_pause_constraint = pause_constraint.get_next();
-                            let next_description = next_pause_constraint.get_description();
-                            if prompt_pause(description, next_description).await {
+                            if prompt_pause(pause_constraint.get_description()).await {
                                 info!("Continuing without further pauses...");
                                 pause_constraint = PauseType::NoPause;
                             } else {
-                                pause_constraint = next_pause_constraint;
+                                pause_constraint.next();
                             }
                         }
 
@@ -433,9 +430,9 @@ impl MithrilSnapshotFetcher {
 }
 
 /// Async helper to prompt user for pause behavior
-async fn prompt_pause(description: String, next_description: String) -> bool {
+async fn prompt_pause(description: String) -> bool {
     info!(
-        "Paused at {description}. Press [Enter] to step to {next_description}, or [c + Enter] to continue without pauses."
+        "Paused at {description}. Press [Enter] to step to to the next, or [c + Enter] to continue without pauses."
     );
     tokio::task::spawn_blocking(|| {
         use std::io::{self, BufRead};

modules/mithril_snapshot_fetcher/src/pause.rs

@@ -1,12 +1,20 @@
+use std::time::Instant;
+
 use acropolis_common::BlockInfo;
 use config::Config;
 use tracing::{error, info};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum PauseType {
     NoPause,
-    Epoch(u64),
-    Block(u64),
+    Epoch {
+        number: u64,
+        start_time: std::time::Instant,
+    },
+    Block {
+        number: u64,
+        start_time: std::time::Instant,
+    },
 }
 
 impl PauseType {
@@ -26,15 +34,22 @@ impl PauseType {
 
         let pause_type = parts[0].trim();
         let value = parts[1].trim().parse::<u64>().ok()?;
+        let start_time = Instant::now();
 
         match pause_type {
             "epoch" => {
                 info!("Pausing enabled at epoch {value}");
-                Some(PauseType::Epoch(value))
+                Some(PauseType::Epoch {
+                    number: value,
+                    start_time,
+                })
             }
             "block" => {
                 info!("Pausing enabled at block {value}");
-                Some(PauseType::Block(value))
+                Some(PauseType::Block {
+                    number: value,
+                    start_time,
+                })
             }
             _ => {
                 error!(
@@ -48,29 +63,34 @@ impl PauseType {
 
     pub fn should_pause(&self, block_info: &BlockInfo) -> bool {
         match self {
-            PauseType::Epoch(target_epoch) => {
-                if block_info.new_epoch {
-                    return block_info.epoch == *target_epoch;
-                }
-                false
-            }
-            PauseType::Block(target_block) => block_info.number == *target_block,
+            PauseType::Epoch { number, .. } => block_info.new_epoch && block_info.epoch == *number,
+            PauseType::Block { number, .. } => block_info.number == *number,
             PauseType::NoPause => false,
         }
     }
 
-    pub fn get_next(&self) -> Self {
+    pub fn next(&mut self) {
         match self {
-            PauseType::Epoch(target_epoch) => PauseType::Epoch(target_epoch + 1),
-            PauseType::Block(target_block) => PauseType::Block(target_block + 1),
-            PauseType::NoPause => PauseType::NoPause,
+            PauseType::Epoch { number, start_time } => {
+                *number += 1;
+                *start_time = Instant::now();
+            }
+            PauseType::Block { number, start_time } => {
+                *number += 1;
+                *start_time = Instant::now();
+            }
+            PauseType::NoPause => {}
         }
     }
 
     pub fn get_description(&self) -> String {
         match self {
-            PauseType::Epoch(target_epoch) => format!("Epoch {target_epoch}"),
-            PauseType::Block(target_block) => format!("Block {target_block}"),
+            PauseType::Epoch { number, start_time } => {
+                format!("Epoch {number} (started {:?} ago)", start_time.elapsed())
+            }
+            PauseType::Block { number, start_time } => {
+                format!("Block {number} (started {:?} ago)", start_time.elapsed())
+            }
             PauseType::NoPause => "No pause".to_string(),
         }
     }
@@ -85,14 +105,20 @@ mod tests {
     fn test_pause_type_from_config_epoch() {
         let config = Config::builder().set_override("pause", "epoch:100").unwrap().build().unwrap();
         let pause_type = PauseType::from_config(&config, DEFAULT_PAUSE);
-        assert_eq!(pause_type, Some(PauseType::Epoch(100)));
+        match pause_type {
+            Some(PauseType::Epoch { number, .. }) => assert_eq!(number, 100),
+            _ => panic!("Expected Some(PauseType::Epoch {{ number: 100, .. }})"),
+        }
     }
 
     #[test]
     fn test_pause_type_from_config_block() {
         let config = Config::builder().set_override("pause", "block:100").unwrap().build().unwrap();
         let pause_type = PauseType::from_config(&config, DEFAULT_PAUSE);
-        assert_eq!(pause_type, Some(PauseType::Block(100)));
+        match pause_type {
+            Some(PauseType::Block { number, .. }) => assert_eq!(number, 100),
+            _ => panic!("Expected Some(PauseType::Block {{ number: 100, .. }})"),
+        }
     }
 
     #[test]