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 chrono::Utc;
+use anyhow::Context;
+use chrono::{DateTime, 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,
@@ -127,7 +148,10 @@ impl CardanoDbVerifyCommand {
         match message {
             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 +200,86 @@ impl CardanoDbVerifyCommand {
         }
         Ok(())
     }
+
+    fn print_immutables_verification_error(lists: &ImmutableFilesLists, json_output: bool) {
+        let utc_now = Utc::now();
+        let json_file_path = write_json_file_error(utc_now, lists);
+        let error_message = "Verifying immutables files has failed";
+        if json_output {
+            let json = serde_json::json!({
+                "timestamp": utc_now.to_rfc3339(),
+                "verify_error" : {
+                    "message": error_message,
+                    "immutables_verification_error_file": json_file_path,
+                    "immutables_dir": lists.immutables_dir,
+                    "missing_files_count": lists.missing.len(),
+                    "tampered_files_count": lists.tampered.len()
+                }
+            });
+
+            println!("{json}");
+        } else {
+            println!("{error_message}");
+            println!(
+                "See the lists of all missing and tampered files in {}",
+                json_file_path.display()
+            );
+            if !lists.missing.is_empty() {
+                println!("Number of missing immutable files: {}", lists.missing.len());
+            }
+            if !lists.tampered.is_empty() {
+                println!(
+                    "Number of tampered immutable files: {:?}",
+                    lists.tampered.len()
+                );
+            }
+        }
+    }
+}
+
+fn write_json_file_error(date: DateTime<Utc>, lists: &ImmutableFilesLists) -> PathBuf {
+    let file_path = PathBuf::from(format!(
+        "immutables_verification_error-{}.json",
+        date.timestamp()
+    ));
+    std::fs::write(
+        &file_path,
+        serde_json::to_string_pretty(&serde_json::json!({
+        "timestamp": date.to_rfc3339(),
+        "immutables_dir": lists.immutables_dir,
+        "missing-files": lists.missing,
+        "tampered-files": lists.tampered,
+        }))
+        .unwrap(),
+    )
+    .expect("Could not write immutables verification error to file");
+    file_path
+}
+
+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 {