Rename CardanoDbUnpacker to CardanoDbDownloadChecker

As the responsability of the download has been shifted to the client
api, the 'unpacked' does not handle the download anymore but only the
checks.

Author: Alenar

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

@@ -14,7 +14,7 @@ use crate::{
     commands::client_builder,
     configuration::ConfigParameters,
     utils::{
-        CardanoDbUnpacker, CardanoDbUtils, ExpanderUtils, IndicatifFeedbackReceiver,
+        CardanoDbDownloadChecker, CardanoDbUtils, ExpanderUtils, IndicatifFeedbackReceiver,
         ProgressOutputType, ProgressPrinter,
     },
 };
@@ -131,13 +131,13 @@ impl CardanoDbDownloadCommand {
     fn check_local_disk_info(
         step_number: u16,
         progress_printer: &ProgressPrinter,
-        db_dir: &PathBuf,
+        db_dir: &Path,
         cardano_db: &Snapshot,
     ) -> MithrilResult<()> {
         progress_printer.report_step(step_number, "Checking local disk info…")?;
 
-        CardanoDbUnpacker::ensure_dir_exist(db_dir)?;
-        if let Err(e) = CardanoDbUnpacker::check_prerequisites(
+        CardanoDbDownloadChecker::ensure_dir_exist(db_dir)?;
+        if let Err(e) = CardanoDbDownloadChecker::check_prerequisites(
             db_dir,
             cardano_db.size,
             cardano_db.compression_algorithm.unwrap_or_default(),

mithril-client-cli/src/utils/cardano_db.rs

@@ -3,7 +3,7 @@ use futures::Future;
 use indicatif::{MultiProgress, ProgressBar};
 use std::time::Duration;
 
-use super::CardanoDbUnpackerError;
+use super::CardanoDbDownloadCheckerError;
 use mithril_client::{MithrilError, MithrilResult};
 
 /// Utility functions for to the CardanoDb commands
@@ -12,11 +12,11 @@ pub struct CardanoDbUtils;
 impl CardanoDbUtils {
     /// Handle the error return by `check_prerequisites`
     pub fn check_disk_space_error(error: MithrilError) -> MithrilResult<String> {
-        if let Some(CardanoDbUnpackerError::NotEnoughSpace {
+        if let Some(CardanoDbDownloadCheckerError::NotEnoughSpace {
             left_space: _,
             pathdir: _,
             archive_size: _,
-        }) = error.downcast_ref::<CardanoDbUnpackerError>()
+        }) = error.downcast_ref::<CardanoDbDownloadCheckerError>()
         {
             Ok(format!("Warning: {}", error))
         } else {
@@ -51,7 +51,7 @@ mod test {
 
     #[test]
     fn check_disk_space_error_should_return_warning_message_if_error_is_not_enough_space() {
-        let not_enough_space_error = CardanoDbUnpackerError::NotEnoughSpace {
+        let not_enough_space_error = CardanoDbDownloadCheckerError::NotEnoughSpace {
             left_space: 1_f64,
             pathdir: PathBuf::new(),
             archive_size: 2_f64,
@@ -66,15 +66,15 @@ mod test {
 
     #[test]
     fn check_disk_space_error_should_return_error_if_error_is_not_error_not_enough_space() {
-        let error = CardanoDbUnpackerError::UnpackDirectoryNotEmpty(PathBuf::new());
+        let error = CardanoDbDownloadCheckerError::UnpackDirectoryNotEmpty(PathBuf::new());
 
         let error = CardanoDbUtils::check_disk_space_error(anyhow!(error))
             .expect_err("check_disk_space_error should fail");
 
         assert!(
             matches!(
-                error.downcast_ref::<CardanoDbUnpackerError>(),
-                Some(CardanoDbUnpackerError::UnpackDirectoryNotEmpty(_))
+                error.downcast_ref::<CardanoDbDownloadCheckerError>(),
+                Some(CardanoDbDownloadCheckerError::UnpackDirectoryNotEmpty(_))
             ),
             "Unexpected error: {:?}",
             error

mithril-client-cli/src/utils/unpacker.rs renamed to mithril-client-cli/src/utils/cardano_db_download_checker.rs

@@ -10,13 +10,12 @@ use thiserror::Error;
 
 use mithril_client::{common::CompressionAlgorithm, MithrilError, MithrilResult};
 
-/// Check and unpack a downloaded archive in a given directory.
-#[derive(Default)]
-pub struct CardanoDbUnpacker;
+/// Checks to apply before downloading a Cardano Db archive to a given directory.
+pub struct CardanoDbDownloadChecker;
 
-/// Errors tied with the CardanoDbUnpacker.
+/// Errors tied with the [CardanoDbDownloadChecker].
 #[derive(Debug, Error)]
-pub enum CardanoDbUnpackerError {
+pub enum CardanoDbDownloadCheckerError {
     /// Not enough space on the disk. There should be at least the ratio given for the
     /// used algorithm (see [CompressionAlgorithm::free_space_snapshot_ratio]) times
     /// the size of the archive to download to ensure it could be unpacked safely.
@@ -43,12 +42,15 @@ pub enum CardanoDbUnpackerError {
     UnpackDirectoryIsNotWritable(PathBuf, #[source] MithrilError),
 }
 
-impl CardanoDbUnpacker {
+impl CardanoDbDownloadChecker {
     /// Ensure that the given path exist, create it otherwise
     pub fn ensure_dir_exist(pathdir: &Path) -> MithrilResult<()> {
         if !pathdir.exists() {
             fs::create_dir_all(pathdir).map_err(|e| {
-                CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(pathdir.to_owned(), e.into())
+                CardanoDbDownloadCheckerError::UnpackDirectoryIsNotWritable(
+                    pathdir.to_owned(),
+                    e.into(),
+                )
             })?;
         }
 
@@ -82,7 +84,9 @@ impl CardanoDbUnpacker {
             .next()
             .is_some()
         {
-            return Err(CardanoDbUnpackerError::UnpackDirectoryNotEmpty(pathdir.to_owned()).into());
+            return Err(
+                CardanoDbDownloadCheckerError::UnpackDirectoryNotEmpty(pathdir.to_owned()).into(),
+            );
         }
 
         Ok(())
@@ -92,12 +96,18 @@ impl CardanoDbUnpacker {
         // Check if the directory is writable by creating a temporary file
         let temp_file_path = pathdir.join("temp_file");
         fs::File::create(&temp_file_path).map_err(|e| {
-            CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(pathdir.to_owned(), e.into())
+            CardanoDbDownloadCheckerError::UnpackDirectoryIsNotWritable(
+                pathdir.to_owned(),
+                e.into(),
+            )
         })?;
 
         // Delete the temporary file
         fs::remove_file(temp_file_path).map_err(|e| {
-            CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(pathdir.to_owned(), e.into())
+            CardanoDbDownloadCheckerError::UnpackDirectoryIsNotWritable(
+                pathdir.to_owned(),
+                e.into(),
+            )
         })?;
 
         Ok(())
@@ -110,7 +120,7 @@ impl CardanoDbUnpacker {
     ) -> MithrilResult<()> {
         let free_space = fs2::available_space(pathdir)? as f64;
         if free_space < compression_algorithm.free_space_snapshot_ratio() * size as f64 {
-            return Err(CardanoDbUnpackerError::NotEnoughSpace {
+            return Err(CardanoDbDownloadCheckerError::NotEnoughSpace {
                 left_space: free_space,
                 pathdir: pathdir.to_owned(),
                 archive_size: size as f64,
@@ -136,7 +146,8 @@ mod test {
         let pathdir =
             create_temporary_empty_directory("directory_does_not_exist").join("target_directory");
 
-        CardanoDbUnpacker::ensure_dir_exist(&pathdir).expect("ensure_dir_exist should not fail");
+        CardanoDbDownloadChecker::ensure_dir_exist(&pathdir)
+            .expect("ensure_dir_exist should not fail");
 
         assert!(pathdir.exists());
     }
@@ -147,19 +158,27 @@ mod test {
             create_temporary_empty_directory("fail_if_pathdir_is_file").join("target_directory");
         fs::File::create(&pathdir).unwrap();
 
-        CardanoDbUnpacker::ensure_dir_exist(&pathdir).unwrap();
-        CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
-            .expect_err("check_prerequisites should fail");
+        CardanoDbDownloadChecker::ensure_dir_exist(&pathdir).unwrap();
+        CardanoDbDownloadChecker::check_prerequisites(
+            &pathdir,
+            12,
+            CompressionAlgorithm::default(),
+        )
+        .expect_err("check_prerequisites should fail");
     }
 
     #[test]
     fn return_ok_if_unpack_directory_does_not_exist() {
         let pathdir =
             create_temporary_empty_directory("directory_does_not_exist").join("target_directory");
 
-        CardanoDbUnpacker::ensure_dir_exist(&pathdir).unwrap();
-        CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
-            .expect("check_prerequisites should not fail");
+        CardanoDbDownloadChecker::ensure_dir_exist(&pathdir).unwrap();
+        CardanoDbDownloadChecker::check_prerequisites(
+            &pathdir,
+            12,
+            CompressionAlgorithm::default(),
+        )
+        .expect("check_prerequisites should not fail");
     }
 
     #[test]
@@ -168,9 +187,13 @@ mod test {
             create_temporary_empty_directory("existing_directory").join("target_directory");
         fs::create_dir_all(&pathdir).unwrap();
 
-        CardanoDbUnpacker::ensure_dir_exist(&pathdir).unwrap();
-        CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
-            .expect("check_prerequisites should not fail");
+        CardanoDbDownloadChecker::ensure_dir_exist(&pathdir).unwrap();
+        CardanoDbDownloadChecker::check_prerequisites(
+            &pathdir,
+            12,
+            CompressionAlgorithm::default(),
+        )
+        .expect("check_prerequisites should not fail");
     }
 
     #[test]
@@ -179,15 +202,18 @@ mod test {
         fs::create_dir_all(&pathdir).unwrap();
         fs::File::create(pathdir.join("file.txt")).unwrap();
 
-        CardanoDbUnpacker::ensure_dir_exist(&pathdir).unwrap();
-        let error =
-            CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
-                .expect_err("check_prerequisites should fail");
+        CardanoDbDownloadChecker::ensure_dir_exist(&pathdir).unwrap();
+        let error = CardanoDbDownloadChecker::check_prerequisites(
+            &pathdir,
+            12,
+            CompressionAlgorithm::default(),
+        )
+        .expect_err("check_prerequisites should fail");
 
         assert!(
             matches!(
-                error.downcast_ref::<CardanoDbUnpackerError>(),
-                Some(CardanoDbUnpackerError::UnpackDirectoryNotEmpty(_))
+                error.downcast_ref::<CardanoDbDownloadCheckerError>(),
+                Some(CardanoDbDownloadCheckerError::UnpackDirectoryNotEmpty(_))
             ),
             "Unexpected error: {:?}",
             error
@@ -200,8 +226,8 @@ mod test {
             create_temporary_empty_directory("enough_available_space").join("target_directory");
         let archive_size = u64::MAX;
 
-        CardanoDbUnpacker::ensure_dir_exist(&pathdir).unwrap();
-        let error = CardanoDbUnpacker::check_prerequisites(
+        CardanoDbDownloadChecker::ensure_dir_exist(&pathdir).unwrap();
+        let error = CardanoDbDownloadChecker::check_prerequisites(
             &pathdir,
             archive_size,
             CompressionAlgorithm::default(),
@@ -210,8 +236,8 @@ mod test {
 
         assert!(
             matches!(
-                error.downcast_ref::<CardanoDbUnpackerError>(),
-                Some(CardanoDbUnpackerError::NotEnoughSpace {
+                error.downcast_ref::<CardanoDbDownloadCheckerError>(),
+                Some(CardanoDbDownloadCheckerError::NotEnoughSpace {
                     left_space: _,
                     pathdir: _,
                     archive_size: _
@@ -240,13 +266,16 @@ mod test {
             let targetdir = pathdir.join("target_directory");
             make_readonly(&pathdir);
 
-            let error = CardanoDbUnpacker::ensure_dir_exist(&targetdir)
+            let error = CardanoDbDownloadChecker::ensure_dir_exist(&targetdir)
                 .expect_err("ensure_dir_exist should fail");
 
             assert!(
                 matches!(
-                    error.downcast_ref::<CardanoDbUnpackerError>(),
-                    Some(CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(_, _))
+                    error.downcast_ref::<CardanoDbDownloadCheckerError>(),
+                    Some(CardanoDbDownloadCheckerError::UnpackDirectoryIsNotWritable(
+                        _,
+                        _
+                    ))
                 ),
                 "Unexpected error: {:?}",
                 error
@@ -262,7 +291,7 @@ mod test {
             fs::create_dir(&pathdir).unwrap();
             make_readonly(&pathdir);
 
-            let error = CardanoDbUnpacker::check_prerequisites(
+            let error = CardanoDbDownloadChecker::check_prerequisites(
                 &pathdir,
                 12,
                 CompressionAlgorithm::default(),
@@ -271,8 +300,11 @@ mod test {
 
             assert!(
                 matches!(
-                    error.downcast_ref::<CardanoDbUnpackerError>(),
-                    Some(CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(_, _))
+                    error.downcast_ref::<CardanoDbDownloadCheckerError>(),
+                    Some(CardanoDbDownloadCheckerError::UnpackDirectoryIsNotWritable(
+                        _,
+                        _
+                    ))
                 ),
                 "Unexpected error: {:?}",
                 error

mithril-client-cli/src/utils/mod.rs

@@ -2,13 +2,13 @@
 //! This module contains tools needed for the commands layer.
 
 mod cardano_db;
+mod cardano_db_download_checker;
 mod expander;
 mod feedback_receiver;
 mod progress_reporter;
-mod unpacker;
 
 pub use cardano_db::*;
+pub use cardano_db_download_checker::*;
 pub use expander::*;
 pub use feedback_receiver::*;
 pub use progress_reporter::*;
-pub use unpacker::*;