Switch from async-tar to uh sync tar uh

Signed-off-by: itowlson <[email protected]>

Author: itowlson

Cargo.lock

@@ -7,14 +7,14 @@ edition = { workspace = true }
 [dependencies]
 anyhow = { workspace = true }
 async-compression = { version = "0.4", features = ["gzip", "tokio"] }
-async-tar = "0.5"
 base64 = { workspace = true }
 chrono = { workspace = true }
 # Fork with updated auth to support ACR login
 # Ref https://github.com/camallo/dkregistry-rs/pull/263
 dirs = { workspace = true }
 dkregistry = { git = "https://github.com/fermyon/dkregistry-rs", rev = "161cf2b66996ed97c7abaf046e38244484814de3" }
 docker_credential = "1"
+flate2 = { workspace = true }
 futures-util = { workspace = true }
 itertools = { workspace = true }
 oci-distribution = { git = "https://github.com/fermyon/oci-distribution", rev = "7b291a39f74d1a3c9499d934a56cae6580fc8e37" }
@@ -25,6 +25,7 @@ spin-common = { path = "../common" }
 spin-compose = { path = "../compose" }
 spin-loader = { path = "../loader" }
 spin-locked-app = { path = "../locked-app" }
+tar = "0.4"
 tempfile = { workspace = true }
 tokio = { workspace = true, features = ["fs"] }
 tokio-util = { version = "0.7", features = ["compat"] }

crates/oci/Cargo.toml

@@ -1,61 +1,59 @@
 //! Utilities related to distributing Spin apps via OCI registries
 
 use anyhow::{Context, Result};
-use async_compression::tokio::bufread::GzipDecoder;
-use async_compression::tokio::write::GzipEncoder;
-use async_tar::Archive;
+use flate2::read::GzDecoder;
+use flate2::write::GzEncoder;
 use spin_common::ui::quoted_path;
 use std::path::{Path, PathBuf};
+use tar::Archive;
 
 /// Create a compressed archive of source, returning its path in working_dir
 pub async fn archive(source: &Path, working_dir: &Path) -> Result<PathBuf> {
-    // Create tar archive file
-    let tar_gz_path = working_dir
-        .join(source.file_name().unwrap())
-        .with_extension("tar.gz");
-    let tar_gz = tokio::fs::File::create(tar_gz_path.as_path())
-        .await
-        .context(format!(
+    let source = source.to_owned();
+    let working_dir = working_dir.to_owned();
+
+    tokio::task::spawn_blocking(move || {
+        // Create tar archive file
+        let tar_gz_path = working_dir
+            .join(source.file_name().unwrap())
+            .with_extension("tar.gz");
+        let tar_gz = std::fs::File::create(tar_gz_path.as_path()).context(format!(
             "Unable to create tar archive for source {}",
-            quoted_path(source)
+            quoted_path(&source)
         ))?;
 
-    // Create encoder
-    // TODO: use zstd? May be more performant
-    let tar_gz_enc = GzipEncoder::new(tar_gz);
-
-    // Build tar archive
-    let mut tar_builder = async_tar::Builder::new(
-        tokio_util::compat::TokioAsyncWriteCompatExt::compat_write(tar_gz_enc),
-    );
-    tar_builder
-        .append_dir_all(".", source)
-        .await
-        .context(format!(
+        // Create encoder
+        // TODO: use zstd? May be more performant
+        let tar_gz_enc = GzEncoder::new(tar_gz, flate2::Compression::default());
+
+        // Build tar archive
+        let mut tar_builder = tar::Builder::new(tar_gz_enc);
+        tar_builder.append_dir_all(".", &source).context(format!(
             "Unable to create tar archive for source {}",
-            quoted_path(source)
+            quoted_path(&source)
         ))?;
-    // Finish writing the archive
-    tar_builder.finish().await?;
-    // Shutdown the encoder
-    use tokio::io::AsyncWriteExt;
-    tar_builder
-        .into_inner()
-        .await?
-        .into_inner()
-        .shutdown()
-        .await?;
-    Ok(tar_gz_path)
+
+        // Finish writing the archive and shut down the encoder.
+        let inner_enc = tar_builder.into_inner()?;
+        inner_enc.finish()?;
+
+        Ok(tar_gz_path)
+    })
+    .await?
 }
 
 /// Unpack a compressed archive existing at source into dest
 pub async fn unarchive(source: &Path, dest: &Path) -> Result<()> {
-    let decoder = GzipDecoder::new(tokio::io::BufReader::new(
-        tokio::fs::File::open(source).await?,
-    ));
-    let archive = Archive::new(tokio_util::compat::TokioAsyncReadCompatExt::compat(decoder));
-    if let Err(e) = archive.unpack(dest).await {
-        return Err(e.into());
-    };
-    Ok(())
+    let source = source.to_owned();
+    let dest = dest.to_owned();
+
+    tokio::task::spawn_blocking(move || {
+        let decoder = GzDecoder::new(std::fs::File::open(&source)?);
+        let mut archive = Archive::new(decoder);
+        if let Err(e) = archive.unpack(&dest) {
+            return Err(e.into());
+        };
+        Ok(())
+    })
+    .await?
 }