Enhance client-client snapshot download to accept existing dir as target

The directory still needs to be empty.

Author: Alenar

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

@@ -135,6 +135,8 @@ impl CardanoDbDownloadCommand {
         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(
             db_dir,
             cardano_db.size,
@@ -144,13 +146,6 @@ impl CardanoDbDownloadCommand {
                 .report_step(step_number, &CardanoDbUtils::check_disk_space_error(e)?)?;
         }
 
-        std::fs::create_dir_all(db_dir).with_context(|| {
-            format!(
-                "Download: could not create target directory '{}'.",
-                db_dir.display()
-            )
-        })?;
-
         Ok(())
     }
 

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

@@ -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::UnpackDirectoryAlreadyExists(PathBuf::new());
+        let error = CardanoDbUnpackerError::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::UnpackDirectoryAlreadyExists(_))
+                Some(CardanoDbUnpackerError::UnpackDirectoryNotEmpty(_))
             ),
             "Unexpected error: {:?}",
             error

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

@@ -1,8 +1,11 @@
-use human_bytes::human_bytes;
+use std::ops::Not;
 use std::{
-    fs::{create_dir_all, remove_dir},
+    fs,
     path::{Path, PathBuf},
 };
+
+use anyhow::Context;
+use human_bytes::human_bytes;
 use thiserror::Error;
 
 use mithril_client::{common::CompressionAlgorithm, MithrilError, MithrilResult};
@@ -29,37 +32,83 @@ pub enum CardanoDbUnpackerError {
         archive_size: f64,
     },
 
-    /// The directory where the files from cardano db are expanded already exists.
-    /// An error is raised because it lets the user a chance to preserve a
-    /// previous work.
-    #[error("Unpack directory '{0}' already exists, please move or delete it.")]
-    UnpackDirectoryAlreadyExists(PathBuf),
+    /// The directory where the files from cardano db are expanded is not empty.
+    /// An error is raised to let the user handle what it wants to do with those
+    /// files.
+    #[error("Unpack directory '{0}' is not empty, please clean up it's content.")]
+    UnpackDirectoryNotEmpty(PathBuf),
 
     /// Cannot write in the given directory.
     #[error("Unpack directory '{0}' is not writable, please check own or parents' permissions and ownership.")]
     UnpackDirectoryIsNotWritable(PathBuf, #[source] MithrilError),
 }
 
 impl CardanoDbUnpacker {
+    /// 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())
+            })?;
+        }
+
+        Ok(())
+    }
+
     /// Check all prerequisites are met before starting to download and unpack
     /// big cardano db archive.
     pub fn check_prerequisites(
         pathdir: &Path,
         size: u64,
         compression_algorithm: CompressionAlgorithm,
     ) -> MithrilResult<()> {
-        if pathdir.exists() {
-            return Err(
-                CardanoDbUnpackerError::UnpackDirectoryAlreadyExists(pathdir.to_owned()).into(),
-            );
+        Self::check_path_is_dir_and_writable(pathdir)?;
+        Self::check_dir_writable(pathdir)?;
+        Self::check_disk_space(pathdir, size, compression_algorithm)
+    }
+
+    fn check_path_is_dir_and_writable(pathdir: &Path) -> MithrilResult<()> {
+        if pathdir.is_dir().not() {
+            anyhow::bail!("Given path is not a directory: {}", pathdir.display());
+        }
+
+        if fs::read_dir(pathdir)
+            .with_context(|| {
+                format!(
+                    "Could not list directory `{}` to check if it's empty",
+                    pathdir.display()
+                )
+            })?
+            .next()
+            .is_some()
+        {
+            return Err(CardanoDbUnpackerError::UnpackDirectoryNotEmpty(pathdir.to_owned()).into());
         }
-        create_dir_all(pathdir).map_err(|e| {
+
+        Ok(())
+    }
+
+    fn check_dir_writable(pathdir: &Path) -> MithrilResult<()> {
+        // 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())
+        })?;
+
+        // Delete the temporary file
+        fs::remove_file(temp_file_path).map_err(|e| {
             CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(pathdir.to_owned(), e.into())
         })?;
-        let free_space = fs2::available_space(pathdir)? as f64;
-        // `remove_dir` doesn't remove intermediate directories that could have been created by `create_dir_all`
-        remove_dir(pathdir)?;
 
+        Ok(())
+    }
+
+    fn check_disk_space(
+        pathdir: &Path,
+        size: u64,
+        compression_algorithm: CompressionAlgorithm,
+    ) -> 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 {
                 left_space: free_space,
@@ -68,79 +117,90 @@ impl CardanoDbUnpacker {
             }
             .into());
         }
-
         Ok(())
     }
 }
 
 #[cfg(test)]
 mod test {
-    use super::*;
     use mithril_common::test_utils::TempDir;
 
+    use super::*;
+
     fn create_temporary_empty_directory(name: &str) -> PathBuf {
-        TempDir::create("client-cli", name)
+        TempDir::create("client-cli-unpacker", name)
     }
 
     #[test]
-    fn should_return_ok() {
-        let pathdir = create_temporary_empty_directory("return_ok").join("target_directory");
+    fn create_directory_if_it_doesnt_exist() {
+        let pathdir =
+            create_temporary_empty_directory("directory_does_not_exist").join("target_directory");
 
-        CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
-            .expect("check_prerequisites should not fail");
+        CardanoDbUnpacker::ensure_dir_exist(&pathdir).expect("ensure_dir_exist should not fail");
+
+        assert!(pathdir.exists());
     }
 
     #[test]
-    fn should_return_error_if_unpack_directory_already_exists() {
-        let pathdir = create_temporary_empty_directory("existing_directory");
+    fn return_error_if_path_is_a_file() {
+        let pathdir =
+            create_temporary_empty_directory("fail_if_pathdir_is_file").join("target_directory");
+        fs::File::create(&pathdir).unwrap();
 
-        let error =
-            CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
-                .expect_err("check_prerequisites should fail");
+        CardanoDbUnpacker::ensure_dir_exist(&pathdir).unwrap();
+        CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
+            .expect_err("check_prerequisites should fail");
+    }
 
-        assert!(
-            matches!(
-                error.downcast_ref::<CardanoDbUnpackerError>(),
-                Some(CardanoDbUnpackerError::UnpackDirectoryAlreadyExists(_))
-            ),
-            "Unexpected error: {:?}",
-            error
-        );
+    #[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");
     }
 
-    // This test is not run on Windows because `set_readonly` is not working on Windows 7+
-    // https://doc.rust-lang.org/std/fs/struct.Permissions.html#method.set_readonly
-    #[cfg(not(target_os = "windows"))]
     #[test]
-    fn should_return_error_if_directory_could_not_be_created() {
-        let pathdir = create_temporary_empty_directory("read_only_directory");
+    fn return_ok_if_unpack_directory_exist_and_empty() {
+        let pathdir =
+            create_temporary_empty_directory("existing_directory").join("target_directory");
+        fs::create_dir_all(&pathdir).unwrap();
 
-        let mut perms = std::fs::metadata(&pathdir).unwrap().permissions();
-        perms.set_readonly(true);
-        std::fs::set_permissions(&pathdir, perms).unwrap();
+        CardanoDbUnpacker::ensure_dir_exist(&pathdir).unwrap();
+        CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
+            .expect("check_prerequisites should not fail");
+    }
 
-        let targetdir = pathdir.join("target_directory");
+    #[test]
+    fn return_error_if_unpack_directory_exists_and_not_empty() {
+        let pathdir = create_temporary_empty_directory("existing_directory_not_empty");
+        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(&targetdir, 12, CompressionAlgorithm::default())
+            CardanoDbUnpacker::check_prerequisites(&pathdir, 12, CompressionAlgorithm::default())
                 .expect_err("check_prerequisites should fail");
 
         assert!(
             matches!(
                 error.downcast_ref::<CardanoDbUnpackerError>(),
-                Some(CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(_, _))
+                Some(CardanoDbUnpackerError::UnpackDirectoryNotEmpty(_))
             ),
             "Unexpected error: {:?}",
             error
         );
     }
 
     #[test]
-    fn should_return_error_if_not_enough_available_space() {
+    fn return_error_if_not_enough_available_space() {
         let pathdir =
             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(
             &pathdir,
             archive_size,
@@ -161,4 +221,62 @@ mod test {
             error
         );
     }
+
+    // Those test are not on Windows because `set_readonly` is ignored for directories on Windows 7+
+    // https://doc.rust-lang.org/std/fs/struct.Permissions.html#method.set_readonly
+    #[cfg(not(target_os = "windows"))]
+    mod unix_only {
+        use super::*;
+
+        fn make_readonly(path: &Path) {
+            let mut perms = fs::metadata(path).unwrap().permissions();
+            perms.set_readonly(true);
+            fs::set_permissions(path, perms).unwrap();
+        }
+
+        #[test]
+        fn return_error_if_directory_could_not_be_created() {
+            let pathdir = create_temporary_empty_directory("read_only_directory");
+            let targetdir = pathdir.join("target_directory");
+            make_readonly(&pathdir);
+
+            let error = CardanoDbUnpacker::ensure_dir_exist(&targetdir)
+                .expect_err("ensure_dir_exist should fail");
+
+            assert!(
+                matches!(
+                    error.downcast_ref::<CardanoDbUnpackerError>(),
+                    Some(CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(_, _))
+                ),
+                "Unexpected error: {:?}",
+                error
+            );
+        }
+
+        // This test is not run on Windows because `set_readonly` is ignored for directory on Windows 7+
+        // https://doc.rust-lang.org/std/fs/struct.Permissions.html#method.set_readonly
+        #[test]
+        fn return_error_if_existing_directory_is_not_writable() {
+            let pathdir =
+                create_temporary_empty_directory("existing_directory_not_writable").join("db");
+            fs::create_dir(&pathdir).unwrap();
+            make_readonly(&pathdir);
+
+            let error = CardanoDbUnpacker::check_prerequisites(
+                &pathdir,
+                12,
+                CompressionAlgorithm::default(),
+            )
+            .expect_err("check_prerequisites should fail");
+
+            assert!(
+                matches!(
+                    error.downcast_ref::<CardanoDbUnpackerError>(),
+                    Some(CardanoDbUnpackerError::UnpackDirectoryIsNotWritable(_, _))
+                ),
+                "Unexpected error: {:?}",
+                error
+            );
+        }
+    }
 }