Initial rollback implementation

bin/cli/src/commands/mod.rs

@@ -1,3 +1,5 @@
 mod prune;
+mod rollback;
 
 pub(crate) use prune::*;
+pub(crate) use rollback::*;

bin/cli/src/commands/rollback.rs

@@ -0,0 +1,3 @@
+pub(crate) async fn rollback(_num_block: u32) -> anyhow::Result<()> {
+    Ok(())
+}

bin/cli/src/main.rs

@@ -33,7 +33,7 @@ enum Commands {
         db_path: PathBuf,
         /// The number of blocks to rollback
         #[arg(long)]
-        blocks: u64,
+        blocks: u32,
     },
 }
 
@@ -50,7 +50,7 @@ async fn main() -> anyhow::Result<()> {
             commands::prune(db_path.clone(), *distance).await?;
         }
         Commands::Rollback { db_path, blocks } => {
-            println!("Rolling back stuff: {:?}, blocks: {}", db_path, blocks);
+            commands::rollback(*blocks).await?;
         }
     }
 

crates/storage-ops/src/lib.rs

@@ -1,3 +1,5 @@
 pub mod pruning;
+pub mod rollback;
+
 #[cfg(test)]
 mod tests;

crates/storage-ops/src/rollback/mod.rs

@@ -0,0 +1,12 @@
+pub mod service;
+
+pub struct Rollback {}
+
+impl Rollback {
+    /// Rollback the provided number of blocks
+    pub fn execute(&self, _num_blocks: u32) -> anyhow::Result<()> {
+        // Do something
+
+        Ok(())
+    }
+}

crates/storage-ops/src/rollback/service.rs

@@ -0,0 +1,35 @@
+use tokio::select;
+use tokio::sync::mpsc::Receiver;
+use tokio_util::sync::CancellationToken;
+use tracing::{error, info};
+
+use super::Rollback;
+
+pub struct RollbackService {
+    rollback: Rollback,
+    receiver: Receiver<u32>,
+}
+
+impl RollbackService {
+    pub fn new(rollback: Rollback, receiver: Receiver<u32>) -> Self {
+        Self { rollback, receiver }
+    }
+
+    /// Run service to rollback when instructed to
+    pub async fn run(mut self, cancellation_token: CancellationToken) {
+        loop {
+            select! {
+                biased;
+                _ = cancellation_token.cancelled() => {
+                    return;
+                },
+                Some(num_blocks) = self.receiver.recv() => {
+                    info!("Received signal to rollback {num_blocks} blocks");
+                    if let Err(e) = self.rollback.execute(num_blocks) {
+                        error!("Could not rollback blocks: {:?}", e);
+                    }
+                }
+            }
+        }
+    }
+}