feature(client-cli): display missing and/or tampered immutables when

verify command fail

Author: turmelclem

mithril-client-cli/src/commands/cardano_db/verify.rs

@@ -4,10 +4,13 @@ use std::{
     sync::Arc,
 };
 
-use anyhow::{Context, anyhow};
+use anyhow::Context;
 use chrono::Utc;
 use clap::Parser;
-use mithril_client::{ComputeCardanoDatabaseMessageError, MithrilResult};
+use mithril_client::{
+    CardanoDatabaseSnapshot, ComputeCardanoDatabaseMessageError, ImmutableFilesLists,
+    MithrilResult, cardano_database_client::ImmutableFileRange, common::ImmutableFileNumber,
+};
 
 use crate::{
     CommandContext,
@@ -38,6 +41,18 @@ pub struct CardanoDbVerifyCommand {
     /// Genesis verification key to check the certificate chain.
     #[clap(long, env = "GENESIS_VERIFICATION_KEY")]
     genesis_verification_key: Option<String>,
+
+    /// The first immutable file number to verify.
+    ///
+    /// If not set, the verify process will start from the first immutable file.
+    #[clap(long)]
+    start: Option<ImmutableFileNumber>,
+
+    /// The last immutable file number to verify.
+    ///
+    /// If not set, the verify will continue until the last certified immutable file.
+    #[clap(long)]
+    end: Option<ImmutableFileNumber>,
 }
 
 impl CardanoDbVerifyCommand {
@@ -94,6 +109,14 @@ impl CardanoDbVerifyCommand {
             .await?
             .with_context(|| format!("Can not get the cardano db for hash: '{}'", self.digest))?;
 
+        let immutable_file_range = shared_steps::immutable_file_range(self.start, self.end);
+
+        print_immutables_range_to_verify(
+            &cardano_db_message,
+            &immutable_file_range,
+            context.is_json_output_enabled(),
+        )?;
+
         let certificate = shared_steps::fetch_certificate_and_verifying_chain(
             1,
             &progress_printer,
@@ -102,8 +125,6 @@ impl CardanoDbVerifyCommand {
         )
         .await?;
 
-        let immutable_file_range = shared_steps::immutable_file_range(None, None);
-
         let verified_digests = shared_steps::download_and_verify_digests(
             2,
             &progress_printer,
@@ -128,6 +149,10 @@ impl CardanoDbVerifyCommand {
             Err(e) => match e.downcast_ref::<ComputeCardanoDatabaseMessageError>() {
                 Some(ComputeCardanoDatabaseMessageError::ImmutableFilesVerification(lists)) => {
                     // let missing_files = lists.missing;
+                    Self::print_immutables_verification_error(
+                        lists,
+                        context.is_json_output_enabled(),
+                    );
                     Ok(())
                 }
                 _ => Err(e),
@@ -176,6 +201,78 @@ impl CardanoDbVerifyCommand {
         }
         Ok(())
     }
+
+    fn print_immutables_verification_error(lists: &ImmutableFilesLists, json_output: bool) {
+        fn get_first_10_files_path(files: &[String], immutables_dir: &Path) -> String {
+            files
+                .iter()
+                .take(10)
+                .map(|file| immutables_dir.join(file).to_string_lossy().to_string())
+                .collect::<Vec<_>>()
+                .join("\n- ")
+        }
+        let missing_files_subset = get_first_10_files_path(&lists.missing, &lists.immutables_dir);
+        let tampered_files_subset = get_first_10_files_path(&lists.tampered, &lists.immutables_dir);
+
+        if json_output {
+            let json = serde_json::json!({
+                "timestamp": Utc::now().to_rfc3339(),
+                "verify_error" : {
+                    "message": "Verifying immutables files has failed",
+                    "immutables_dir": lists.immutables_dir,
+                    "missing_files_count": lists.missing.len(),
+                    "tampered_files_count": lists.tampered.len(),
+                    "missing_files": lists.missing,
+                    "tampered_files": lists.tampered,
+                }
+            });
+            println!("{json}");
+        } else {
+            if !lists.missing.is_empty() {
+                println!("Verifying immutables files has failed:");
+                println!("Number of missing immutable files: {}", lists.missing.len());
+                println!("First 10 missing immutable files paths:");
+                println!("{missing_files_subset}");
+            }
+            if !lists.missing.is_empty() && !lists.tampered.is_empty() {
+                println!();
+            }
+            if !lists.tampered.is_empty() {
+                println!(
+                    "Number of tampered immutable files: {:?}",
+                    lists.tampered.len()
+                );
+                println!("First 10 tampered immutable files paths:");
+                println!("{tampered_files_subset}");
+            }
+        }
+    }
+}
+
+fn print_immutables_range_to_verify(
+    cardano_db_message: &CardanoDatabaseSnapshot,
+    immutable_file_range: &ImmutableFileRange,
+    json_output: bool,
+) -> Result<(), anyhow::Error> {
+    let range_to_verify =
+        immutable_file_range.to_range_inclusive(cardano_db_message.beacon.immutable_file_number)?;
+    if json_output {
+        let json = serde_json::json!({
+            "timestamp": Utc::now().to_rfc3339(),
+            "local_immutable_range_to_verify": {
+                "start": range_to_verify.start(),
+                "end": range_to_verify.end(),
+            },
+        });
+        println!("{json}");
+    } else {
+        eprintln!(
+            "Verifying local immutable files from number {} to {}",
+            range_to_verify.start(),
+            range_to_verify.end()
+        );
+    }
+    Ok(())
 }
 
 impl ConfigSource for CardanoDbVerifyCommand {