Refactor snapshot download command

- Split `execute` function
- Use `mithril-client` types instead of `mithril-common` types

Author: Damien LACHAUME / PALO-IT

mithril-client-cli/src/commands/snapshot/download.rs

@@ -10,7 +10,9 @@ use std::{
     sync::Arc,
 };
 
-use mithril_client::{ClientBuilder, MessageBuilder};
+use mithril_client::{
+    common::ProtocolMessage, Client, ClientBuilder, MessageBuilder, MithrilCertificate, Snapshot,
+};
 use mithril_client_cli::{
     configuration::ConfigParameters,
     utils::{
@@ -90,24 +92,86 @@ impl SnapshotDownloadCommand {
             .await?
             .with_context(|| format!("Can not get the snapshot for digest: '{}'", self.digest))?;
 
-        progress_printer.report_step(1, "Checking local disk info…")?;
-        if let Err(e) = SnapshotUnpacker::check_prerequisites(
+        SnapshotDownloadCommand::check_local_disk_info(
+            1,
+            &progress_printer,
+            &db_dir,
+            &snapshot_message,
+        )?;
+
+        let certificate = SnapshotDownloadCommand::fetching_certificate_and_verifying_chain(
+            2,
+            &progress_printer,
+            &client,
+            &snapshot_message,
+        )
+        .await?;
+
+        SnapshotDownloadCommand::downloading_and_unpacking_snapshot(
+            3,
+            &progress_printer,
+            &client,
+            &snapshot_message,
             &db_dir,
+        )
+        .await?;
+
+        let message = SnapshotDownloadCommand::computing_snapshot_digest(
+            4,
+            &progress_printer,
+            &certificate,
+            &db_dir,
+        )
+        .await?;
+
+        SnapshotDownloadCommand::verifying_snapshot_signature(
+            5,
+            &progress_printer,
+            &certificate,
+            &message,
+            &snapshot_message,
+        )
+        .await?;
+
+        SnapshotDownloadCommand::log_download_information(&db_dir, &snapshot_message, self.json)?;
+
+        Ok(())
+    }
+
+    fn check_local_disk_info(
+        step_number: u16,
+        progress_printer: &ProgressPrinter,
+        db_dir: &PathBuf,
+        snapshot_message: &Snapshot,
+    ) -> StdResult<()> {
+        progress_printer.report_step(step_number, "Checking local disk info…")?;
+        if let Err(e) = SnapshotUnpacker::check_prerequisites(
+            db_dir,
             snapshot_message.size,
             snapshot_message.compression_algorithm.unwrap_or_default(),
         ) {
-            progress_printer.report_step(1, &SnapshotUtils::check_disk_space_error(e)?)?;
+            progress_printer
+                .report_step(step_number, &SnapshotUtils::check_disk_space_error(e)?)?;
         }
 
-        std::fs::create_dir_all(&db_dir).with_context(|| {
+        std::fs::create_dir_all(db_dir).with_context(|| {
             format!(
                 "Download: could not create target directory '{}'.",
                 db_dir.display()
             )
         })?;
 
+        Ok(())
+    }
+
+    async fn fetching_certificate_and_verifying_chain(
+        step_number: u16,
+        progress_printer: &ProgressPrinter,
+        client: &Client,
+        snapshot_message: &Snapshot,
+    ) -> StdResult<MithrilCertificate> {
         progress_printer.report_step(
-            2,
+            step_number,
             "Fetching the certificate and verifying the certificate chain…",
         )?;
         let certificate = client
@@ -117,25 +181,35 @@ impl SnapshotDownloadCommand {
             .with_context(|| {
                 format!(
                     "Can not verify the certificate chain from certificate_hash: '{}'",
-                    &snapshot_message.certificate_hash
+                    snapshot_message.certificate_hash
                 )
             })?;
 
-        progress_printer.report_step(3, "Downloading and unpacking the snapshot…")?;
+        Ok(certificate)
+    }
+
+    async fn downloading_and_unpacking_snapshot(
+        step_number: u16,
+        progress_printer: &ProgressPrinter,
+        client: &Client,
+        snapshot_message: &Snapshot,
+        db_dir: &Path,
+    ) -> StdResult<()> {
+        progress_printer.report_step(step_number, "Downloading and unpacking the snapshot…")?;
         client
             .snapshot()
-            .download_unpack(&snapshot_message, &db_dir)
+            .download_unpack(snapshot_message, db_dir)
             .await
             .with_context(|| {
                 format!(
                     "Snapshot Service can not download and verify the snapshot for digest: '{}'",
-                    self.digest
+                    snapshot_message.digest
                 )
             })?;
 
         // The snapshot download does not fail if the statistic call fails.
         // It would be nice to implement tests to verify the behavior of `add_statistics`
-        if let Err(e) = client.snapshot().add_statistics(&snapshot_message).await {
+        if let Err(e) = client.snapshot().add_statistics(snapshot_message).await {
             warn!("Could not POST snapshot download statistics: {e:?}");
         }
 
@@ -147,21 +221,40 @@ impl SnapshotDownloadCommand {
             );
         };
 
-        progress_printer.report_step(4, "Computing the snapshot digest…")?;
+        Ok(())
+    }
+
+    async fn computing_snapshot_digest(
+        step_number: u16,
+        progress_printer: &ProgressPrinter,
+        certificate: &MithrilCertificate,
+        db_dir: &Path,
+    ) -> StdResult<ProtocolMessage> {
+        progress_printer.report_step(step_number, "Computing the snapshot digest…")?;
         let message = SnapshotUtils::wait_spinner(
-            &progress_printer,
-            MessageBuilder::new().compute_snapshot_message(&certificate, &db_dir),
+            progress_printer,
+            MessageBuilder::new().compute_snapshot_message(certificate, db_dir),
         )
         .await
         .with_context(|| {
             format!(
                 "Can not compute the snapshot message from the directory: '{:?}'",
-                &db_dir
+                db_dir
             )
         })?;
 
-        progress_printer.report_step(5, "Verifying the snapshot signature…")?;
-        if !certificate.match_message(&message) {
+        Ok(message)
+    }
+
+    async fn verifying_snapshot_signature(
+        step_number: u16,
+        progress_printer: &ProgressPrinter,
+        certificate: &MithrilCertificate,
+        message: &ProtocolMessage,
+        snapshot_message: &Snapshot,
+    ) -> StdResult<()> {
+        progress_printer.report_step(step_number, "Verifying the snapshot signature…")?;
+        if !certificate.match_message(message) {
             debug!("Digest verification failed, removing unpacked files & directory.");
 
             return Err(anyhow!(
@@ -170,14 +263,22 @@ impl SnapshotDownloadCommand {
             ));
         }
 
+        Ok(())
+    }
+
+    fn log_download_information(
+        db_dir: &Path,
+        snapshot_message: &Snapshot,
+        json_output: bool,
+    ) -> StdResult<()> {
         let canonicalized_filepath = &db_dir.canonicalize().with_context(|| {
             format!(
                 "Could not get canonicalized filepath of '{}'",
                 db_dir.display()
             )
         })?;
 
-        if self.json {
+        if json_output {
             println!(
                 r#"{{"timestamp": "{}", "db_directory": "{}"}}"#,
                 Utc::now().to_rfc3339(),
@@ -186,18 +287,19 @@ impl SnapshotDownloadCommand {
         } else {
             println!(
                 r###"Snapshot '{}' has been unpacked and successfully checked against Mithril multi-signature contained in the certificate.
-                
-Files in the directory '{}' can be used to run a Cardano node with version >= {}.
-
-If you are using Cardano Docker image, you can restore a Cardano Node with:
-
-docker run -v cardano-node-ipc:/ipc -v cardano-node-data:/data --mount type=bind,source="{}",target=/data/db/ -e NETWORK={} inputoutput/cardano-node:8.1.2
-
-"###,
-                &self.digest,
+                    
+    Files in the directory '{}' can be used to run a Cardano node with version >= {}.
+    
+    If you are using Cardano Docker image, you can restore a Cardano Node with:
+    
+    docker run -v cardano-node-ipc:/ipc -v cardano-node-data:/data --mount type=bind,source="{}",target=/data/db/ -e NETWORK={} inputoutput/cardano-node:8.1.2
+    
+    "###,
+                snapshot_message.digest,
                 db_dir.display(),
                 snapshot_message
                     .cardano_node_version
+                    .clone()
                     .unwrap_or("latest".to_string()),
                 canonicalized_filepath.display(),
                 snapshot_message.beacon.network,

mithril-client-cli/src/commands/snapshot/list.rs

@@ -1,12 +1,12 @@
 use clap::Parser;
 use cli_table::{format::Justify, print_stdout, Cell, Table};
 use config::{builder::DefaultState, ConfigBuilder};
-use mithril_common::test_utils::fake_keys;
 use slog_scope::logger;
 use std::{collections::HashMap, sync::Arc};
 
 use mithril_client::ClientBuilder;
-use mithril_client_cli::{common::StdResult, configuration::ConfigParameters};
+use mithril_client_cli::configuration::ConfigParameters;
+use mithril_common::{test_utils::fake_keys, StdResult};
 
 /// Clap command to list existing snapshots
 #[derive(Parser, Debug, Clone)]

mithril-client-cli/src/lib.rs

@@ -1,16 +1,2 @@
 pub mod configuration;
 pub mod utils;
-
-/// `mithril-common` re-exports
-pub mod common {
-    pub use mithril_common::{
-        certificate_chain::CertificateVerifier,
-        crypto_helper::{ProtocolGenesisVerificationKey, ProtocolGenesisVerifier},
-        entities::{Beacon, CompressionAlgorithm, Epoch},
-        messages::{
-            MithrilStakeDistributionListMessage, SnapshotListItemMessage, SnapshotListMessage,
-            SnapshotMessage,
-        },
-        StdError, StdResult,
-    };
-}

mithril-client-cli/src/main.rs

@@ -13,7 +13,7 @@ use std::io::Write;
 use std::sync::Arc;
 use std::{fs::File, path::PathBuf};
 
-use mithril_client_cli::common::StdResult;
+use mithril_common::StdResult;
 
 use commands::{
     mithril_stake_distribution::MithrilStakeDistributionCommands, snapshot::SnapshotCommands,