feat(client-cli): implement unpack of Cardano node distribution

Author: dlachaume

Cargo.lock

@@ -31,6 +31,7 @@ chrono = { workspace = true }
 clap = { workspace = true }
 cli-table = "0.5.0"
 config = { workspace = true }
+flate2 = "1.1.1"
 fs2 = "0.4.3"
 futures = "0.3.31"
 human_bytes = { version = "0.4.3", features = ["fast"] }
@@ -48,8 +49,10 @@ slog = { workspace = true, features = [
 slog-async = { workspace = true }
 slog-bunyan = { workspace = true }
 slog-term = { workspace = true }
+tar = "0.4.44"
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+zip = "4.0.0"
 
 [dev-dependencies]
 mithril-common = { path = "../mithril-common", features = ["test_tools"] }

mithril-client-cli/Cargo.toml

@@ -0,0 +1,16 @@
+mod tar_gz_unpacker;
+mod zip_unpacker;
+
+pub use tar_gz_unpacker::*;
+pub use zip_unpacker::*;
+
+use mithril_client::MithrilResult;
+use std::path::Path;
+
+#[cfg_attr(test, mockall::automock)]
+pub trait ArchiveUnpacker {
+    fn unpack(&self, archive_path: &Path, unpack_dir: &Path) -> MithrilResult<()>;
+
+    #[cfg(test)]
+    fn as_any(&self) -> &dyn std::any::Any;
+}

mithril-client-cli/src/commands/tools/archive_unpacker/mod.rs

@@ -0,0 +1,89 @@
+use std::{fs::File, path::Path};
+
+use anyhow::Context;
+use flate2::read::GzDecoder;
+use tar::Archive;
+
+use mithril_client::MithrilResult;
+
+use super::ArchiveUnpacker;
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct TarGzUnpacker;
+
+impl ArchiveUnpacker for TarGzUnpacker {
+    fn unpack(&self, archive_path: &Path, unpack_dir: &Path) -> MithrilResult<()> {
+        let archive = File::open(archive_path)
+            .with_context(|| format!("Could not open archive file '{}'", archive_path.display()))?;
+        let gzip_decoder = GzDecoder::new(archive);
+        let mut file_archive = Archive::new(gzip_decoder);
+        file_archive.unpack(unpack_dir).with_context(|| {
+            format!(
+                "Could not unpack '{}' with 'Gzip' to directory '{}'",
+                archive_path.display(),
+                unpack_dir.display()
+            )
+        })?;
+
+        Ok(())
+    }
+
+    #[cfg(test)]
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs::{self, File};
+
+    use flate2::{write::GzEncoder, Compression};
+    use tar::{Builder, Header};
+
+    use mithril_common::temp_dir_create;
+
+    use super::*;
+
+    #[test]
+    fn unpack_tar_archive_extracts_all_files() {
+        let temp_dir = temp_dir_create!();
+        let archive_path = temp_dir.join("archive.tar.gz");
+
+        {
+            let tar_gz_file = File::create(&archive_path).unwrap();
+            let encoder = GzEncoder::new(tar_gz_file, Compression::default());
+            let mut tar_builder = Builder::new(encoder);
+
+            let content = b"root content";
+            let mut header = Header::new_gnu();
+            header.set_size(content.len() as u64);
+            header.set_cksum();
+            tar_builder
+                .append_data(&mut header, "root.txt", &content[..])
+                .unwrap();
+
+            let content = b"nested content";
+            let mut header = Header::new_gnu();
+            header.set_size(content.len() as u64);
+            header.set_cksum();
+            tar_builder
+                .append_data(&mut header, "nested/dir/nested-file.txt", &content[..])
+                .unwrap();
+
+            tar_builder.finish().unwrap();
+        }
+
+        TarGzUnpacker.unpack(&archive_path, &temp_dir).unwrap();
+
+        let root_file = temp_dir.join("root.txt");
+        assert!(root_file.exists());
+        let root_file_content = fs::read_to_string(&root_file).unwrap();
+        assert_eq!(root_file_content, "root content");
+
+        let nested_file = temp_dir.join("nested/dir/nested-file.txt");
+        assert!(nested_file.exists());
+        let nested_file_content = fs::read_to_string(&nested_file).unwrap();
+        assert_eq!(nested_file_content, "nested content");
+    }
+}