Merge pull request #39 from georgepisaltu/remove-block

Add `remove-block` subcommand

Author: georgepisaltu

src/main.rs

@@ -11,7 +11,7 @@ use log::error;
 
 use subcommands::{
     archive, check, execution_results_summary, extract_slice, latest_block_summary,
-    purge_signatures, trie_compact, unsparse, Error,
+    purge_signatures, remove_block, trie_compact, unsparse, Error,
 };
 
 const LOGGING: &str = "logging";
@@ -23,6 +23,7 @@ enum DisplayOrder {
     ExtractSlice,
     LatestBlock,
     PurgeSignatures,
+    RemoveBlock,
     TrieCompact,
     Unsparse,
 }
@@ -44,6 +45,7 @@ fn cli() -> Command<'static> {
         .subcommand(purge_signatures::command(
             DisplayOrder::PurgeSignatures as usize,
         ))
+        .subcommand(remove_block::command(DisplayOrder::RemoveBlock as usize))
         .subcommand(trie_compact::command(DisplayOrder::TrieCompact as usize))
         .subcommand(unsparse::command(DisplayOrder::Unsparse as usize))
         .arg(
@@ -92,6 +94,7 @@ fn main() {
             latest_block_summary::run(matches).map_err(Error::from)
         }
         purge_signatures::COMMAND_NAME => purge_signatures::run(matches).map_err(Error::from),
+        remove_block::COMMAND_NAME => remove_block::run(matches).map_err(Error::from),
         trie_compact::COMMAND_NAME => trie_compact::run(matches).map_err(Error::from),
         unsparse::COMMAND_NAME => unsparse::run(matches).map_err(Error::from),
         _ => unreachable!("{} should be handled above", subcommand_name),

src/subcommands.rs

@@ -4,6 +4,7 @@ pub mod execution_results_summary;
 pub mod extract_slice;
 pub mod latest_block_summary;
 pub mod purge_signatures;
+pub mod remove_block;
 pub mod trie_compact;
 pub mod unsparse;
 
@@ -15,6 +16,7 @@ use execution_results_summary::Error as ExecutionResultsSummaryError;
 use extract_slice::Error as ExtractSliceError;
 use latest_block_summary::Error as LatestBlockSummaryError;
 use purge_signatures::Error as PurgeSignaturesError;
+use remove_block::Error as RemoveBlockError;
 use trie_compact::Error as TrieCompactError;
 use unsparse::Error as UnsparseError;
 
@@ -34,6 +36,8 @@ pub enum Error {
     LatestBlockSummary(#[from] LatestBlockSummaryError),
     #[error("Purge signatures failed: {0}")]
     PurgeSignatures(#[from] PurgeSignaturesError),
+    #[error("Remove block failed: {0}")]
+    RemoveBlock(#[from] RemoveBlockError),
     #[error("Trie compact failed: {0}")]
     TrieCompact(#[from] TrieCompactError),
     #[error("Unsparse failed: {0}")]

src/subcommands/remove_block.rs

@@ -0,0 +1,88 @@
+mod remove;
+#[cfg(test)]
+mod tests;
+
+use std::path::Path;
+
+use bincode::Error as BincodeError;
+use casper_hashing::Digest;
+use casper_node::types::{BlockHash, DeployHash};
+use clap::{Arg, ArgMatches, Command};
+use lmdb::Error as LmdbError;
+use thiserror::Error as ThisError;
+
+pub const COMMAND_NAME: &str = "remove-block";
+const BLOCK_HASH: &str = "block-hash";
+const DB_PATH: &str = "db-path";
+
+/// Errors encountered when operating on the storage database.
+#[derive(Debug, ThisError)]
+pub enum Error {
+    /// Parsing error on entry in the block body database.
+    #[error("Error parsing block body for block with hash {0}: {1}")]
+    BodyParsing(BlockHash, BincodeError),
+    /// Database operation error.
+    #[error("Error operating the database: {0}")]
+    Database(#[from] LmdbError),
+    /// Parsing error on entry in the deploy metadata database.
+    #[error("Error parsing execution results for block with hash {0} at deploy {1}: {2}")]
+    ExecutionResultsParsing(BlockHash, DeployHash, BincodeError),
+    /// Parsing error on entry in the block header database.
+    #[error("Error parsing block header with hash {0}: {1}")]
+    HeaderParsing(BlockHash, BincodeError),
+    /// Missing entry in the deploy metadata database.
+    #[error("Deploy with hash {0} not present in the database")]
+    MissingDeploy(DeployHash),
+    /// Missing entry in the block header database.
+    #[error("Block header for block hash {0} not present in the database")]
+    MissingHeader(BlockHash),
+    /// Serialization error on entry in the deploy metadata database.
+    #[error("Error serializing execution results for deploy {0}: {1}")]
+    Serialization(DeployHash, BincodeError),
+}
+
+enum DisplayOrder {
+    DbPath,
+    BlockHash,
+}
+
+pub fn command(display_order: usize) -> Command<'static> {
+    Command::new(COMMAND_NAME)
+        .display_order(display_order)
+        .about(
+            "Removes the block header, body and execution results for a given \
+            block hash from a storage database.",
+        )
+        .arg(
+            Arg::new(DB_PATH)
+                .display_order(DisplayOrder::DbPath as usize)
+                .required(true)
+                .short('d')
+                .long(DB_PATH)
+                .takes_value(true)
+                .value_name("DB_PATH")
+                .help("Path of the directory with the `storage.lmdb` file."),
+        )
+        .arg(
+            Arg::new(BLOCK_HASH)
+                .display_order(DisplayOrder::BlockHash as usize)
+                .short('b')
+                .long(BLOCK_HASH)
+                .takes_value(true)
+                .value_name("BLOCK_HASH")
+                .help("Hash of the block to be removed."),
+        )
+}
+
+pub fn run(matches: &ArgMatches) -> Result<(), Error> {
+    let path = Path::new(matches.value_of(DB_PATH).expect("should have db-path arg"));
+    let block_hash: BlockHash = matches
+        .value_of(BLOCK_HASH)
+        .map(|block_hash_str| {
+            Digest::from_hex(block_hash_str)
+                .expect("should parse block hash to hex format")
+                .into()
+        })
+        .expect("should have block-hash arg");
+    remove::remove_block(path, block_hash)
+}

src/subcommands/remove_block/remove.rs

@@ -0,0 +1,89 @@
+use std::path::Path;
+
+use casper_node::types::{BlockHash, BlockHeader, DeployMetadata};
+use lmdb::{Error as LmdbError, Transaction, WriteFlags};
+use log::warn;
+
+use crate::{
+    common::db::{
+        self, BlockBodyDatabase, BlockHeaderDatabase, Database, DeployMetadataDatabase,
+        STORAGE_FILE_NAME,
+    },
+    subcommands::execution_results_summary::block_body::BlockBody,
+};
+
+use super::Error;
+
+pub(crate) fn remove_block<P: AsRef<Path>>(db_path: P, block_hash: BlockHash) -> Result<(), Error> {
+    let storage_path = db_path.as_ref().join(STORAGE_FILE_NAME);
+    let env = db::db_env(storage_path)?;
+
+    let mut txn = env.begin_rw_txn()?;
+    let header_db = unsafe { txn.open_db(Some(BlockHeaderDatabase::db_name()))? };
+    let body_db = unsafe { txn.open_db(Some(BlockBodyDatabase::db_name()))? };
+    let deploy_metadata_db = unsafe { txn.open_db(Some(DeployMetadataDatabase::db_name()))? };
+
+    let header: BlockHeader = match txn.get(header_db, &block_hash) {
+        Ok(raw_header) => bincode::deserialize(raw_header)
+            .map_err(|bincode_err| Error::HeaderParsing(block_hash, bincode_err))?,
+        Err(LmdbError::NotFound) => {
+            return Err(Error::MissingHeader(block_hash));
+        }
+        Err(lmdb_err) => {
+            return Err(lmdb_err.into());
+        }
+    };
+
+    let maybe_body: Option<BlockBody> = match txn.get(body_db, header.body_hash()) {
+        Ok(raw_body) => Some(
+            bincode::deserialize(raw_body)
+                .map_err(|bincode_err| Error::BodyParsing(block_hash, bincode_err))?,
+        ),
+        Err(LmdbError::NotFound) => {
+            warn!(
+                "No block body found for block header with hash {}",
+                block_hash
+            );
+            None
+        }
+        Err(lmdb_err) => {
+            return Err(lmdb_err.into());
+        }
+    };
+
+    if let Some(body) = maybe_body {
+        // Go through all the deploys in this block and get the execution
+        // result of each one.
+        for deploy_hash in body.deploy_hashes() {
+            // Get this deploy's metadata.
+            let mut metadata: DeployMetadata = match txn.get(deploy_metadata_db, deploy_hash) {
+                Ok(raw_metadata) => bincode::deserialize(raw_metadata).map_err(|bincode_err| {
+                    Error::ExecutionResultsParsing(block_hash, *deploy_hash, bincode_err)
+                })?,
+                Err(LmdbError::NotFound) => return Err(Error::MissingDeploy(*deploy_hash)),
+                Err(lmdb_error) => return Err(lmdb_error.into()),
+            };
+            // Extract the execution result of this deploy for the current block.
+            if let Some(_execution_result) = metadata.execution_results.remove(&block_hash) {
+                if metadata.execution_results.is_empty() {
+                    txn.del(deploy_metadata_db, deploy_hash, None)?;
+                } else {
+                    let encoded_metadata = bincode::serialize(&metadata)
+                        .map_err(|bincode_err| Error::Serialization(*deploy_hash, bincode_err))?;
+                    txn.put(
+                        deploy_metadata_db,
+                        deploy_hash,
+                        &encoded_metadata,
+                        WriteFlags::default(),
+                    )?;
+                }
+            }
+        }
+
+        txn.del(body_db, header.body_hash(), None)?;
+    }
+
+    txn.del(header_db, &block_hash, None)?;
+    txn.commit()?;
+    Ok(())
+}