feat: convert tarball to tarball_manager

Author: anonrig

crates/registry/src/lib.rs

@@ -7,7 +7,7 @@ use std::path::{Path, PathBuf};
 use async_recursion::async_recursion;
 use futures_util::future::join_all;
 use pacquet_package_json::{DependencyGroup, PackageJson};
-use pacquet_tarball::{download_dependency, get_package_store_folder_name};
+use pacquet_tarball::{get_package_store_folder_name, TarballManager};
 
 use crate::{error::RegistryError, http_client::HttpClient};
 
@@ -16,6 +16,7 @@ pub struct RegistryManager {
     node_modules_path: PathBuf,
     store_path: PathBuf,
     package_json: Box<PackageJson>,
+    tarball_manager: Box<TarballManager>,
 }
 
 impl RegistryManager {
@@ -29,6 +30,7 @@ impl RegistryManager {
             node_modules_path: node_modules_path.into(),
             store_path: store_path.into(),
             package_json: Box::new(PackageJson::create_if_needed(&package_json_path.into())?),
+            tarball_manager: Box::new(TarballManager::new()),
         })
     }
 
@@ -51,13 +53,14 @@ impl RegistryManager {
         let package_node_modules_path =
             self.store_path.join(dependency_store_folder_name).join("node_modules");
 
-        download_dependency(
-            name,
-            latest_version.get_tarball_url(),
-            &package_node_modules_path.join(name),
-            &self.node_modules_path.join(name),
-        )
-        .await?;
+        self.tarball_manager
+            .download_dependency(
+                name,
+                latest_version.get_tarball_url(),
+                &package_node_modules_path.join(name),
+                &self.node_modules_path.join(name),
+            )
+            .await?;
 
         if let Some(dependencies) = latest_version.dependencies.as_ref() {
             join_all(
@@ -97,13 +100,14 @@ impl RegistryManager {
 
         // TODO: We shouldn't call this function for multiple same packages.
         // There needs to be some sort of thread safety.
-        download_dependency(
-            name,
-            package_version.get_tarball_url(),
-            &package_node_modules_path.join(name),
-            &symlink_path.join(&package.name),
-        )
-        .await?;
+        self.tarball_manager
+            .download_dependency(
+                name,
+                package_version.get_tarball_url(),
+                &package_node_modules_path.join(name),
+                &symlink_path.join(&package.name),
+            )
+            .await?;
 
         if let Some(dependencies) = package_version.dependencies.as_ref() {
             join_all(

crates/tarball/src/lib.rs

@@ -24,78 +24,94 @@ pub enum TarballError {
     Io(#[from] std::io::Error),
 }
 
-pub fn get_package_store_folder_name(input: &str, version: &str) -> String {
-    format!("{0}@{1}", input.replace('/', "+"), version)
-}
+#[derive(Debug)]
+pub struct TarballManager;
 
-#[instrument]
-pub async fn download_tarball(url: &str, tarball_path: &Path) -> Result<(), TarballError> {
-    let mut stream = reqwest::get(url).await?.bytes_stream();
-    let mut file = File::create(tarball_path)?;
-    event!(Level::DEBUG, "downloading tarball to {}", tarball_path.display());
-
-    while let Some(item) = stream.next().await {
-        let chunk = item.map_err(TarballError::Network)?;
-        file.write_all(&chunk)?;
+impl Default for TarballManager {
+    fn default() -> Self {
+        Self::new()
     }
-
-    Ok(())
 }
 
-#[instrument]
-pub fn extract_tarball(tarball_path: &Path, extract_path: &Path) -> Result<(), TarballError> {
-    let unpack_path = env::temp_dir().join(Uuid::new_v4().to_string());
-    event!(Level::DEBUG, "unpacking tarball to {}", unpack_path.display());
-    let tar_gz = File::open(tarball_path)?;
-    let tar = GzDecoder::new(tar_gz);
-    let mut archive = Archive::new(tar);
-    archive.unpack(&unpack_path)?;
-    fs::remove_file(tarball_path)?;
-    fs::create_dir_all(extract_path)?;
-    // Check if extract_path is empty or not.
-    // This is due by a race condition causing 2 different threads to download and
-    // extract to the same folder. Likely be fixed with mutex locks.
-    // TODO: Remove this when we have some sort of thread safety
-    if extract_path.read_dir()?.next().is_none() {
-        fs::rename(unpack_path.join("package"), extract_path)?;
+impl TarballManager {
+    pub fn new() -> Self {
+        TarballManager {}
     }
-    fs::remove_dir_all(&unpack_path)?;
-    Ok(())
-}
 
-#[instrument]
-pub async fn download_dependency(
-    name: &str,
-    url: &str,
-    save_path: &Path,
-    symlink_to: &Path,
-) -> Result<(), TarballError> {
-    // If name contains `/` such as @fastify/error, we need to make sure that @fastify folder
-    // exists before we symlink to that directory.
-    if name.contains('/') {
-        fs::create_dir_all(symlink_to.parent().unwrap())?;
+    #[instrument]
+    async fn download(&self, url: &str, tarball_path: &Path) -> Result<(), TarballError> {
+        let mut stream = reqwest::get(url).await?.bytes_stream();
+        let mut file = File::create(tarball_path)?;
+        event!(Level::DEBUG, "downloading tarball to {}", tarball_path.display());
+
+        while let Some(item) = stream.next().await {
+            let chunk = item.map_err(TarballError::Network)?;
+            file.write_all(&chunk)?;
+        }
+
+        Ok(())
     }
 
-    // Do not try to install dependency if this version already exists in package.json
-    if save_path.exists() {
-        if !symlink_to.is_symlink() {
-            symlink_dir(&save_path.to_path_buf(), &symlink_to.to_path_buf())?;
+    #[instrument]
+    fn extract(&self, tarball_path: &Path, extract_path: &Path) -> Result<(), TarballError> {
+        let unpack_path = env::temp_dir().join(Uuid::new_v4().to_string());
+        event!(Level::DEBUG, "unpacking tarball to {}", unpack_path.display());
+        let tar_gz = File::open(tarball_path)?;
+        let tar = GzDecoder::new(tar_gz);
+        let mut archive = Archive::new(tar);
+        archive.unpack(&unpack_path)?;
+        fs::remove_file(tarball_path)?;
+        fs::create_dir_all(extract_path)?;
+        // Check if extract_path is empty or not.
+        // This is due by a race condition causing 2 different threads to download and
+        // extract to the same folder. Likely be fixed with mutex locks.
+        // TODO: Remove this when we have some sort of thread safety
+        if extract_path.read_dir()?.next().is_none() {
+            fs::rename(unpack_path.join("package"), extract_path)?;
         }
-        return Ok(());
+        fs::remove_dir_all(&unpack_path)?;
+        Ok(())
     }
 
-    let tarball_path = env::temp_dir().join(Uuid::new_v4().to_string());
-    download_tarball(url, &tarball_path).await?;
+    #[instrument]
+    pub async fn download_dependency(
+        &self,
+        name: &str,
+        url: &str,
+        save_path: &Path,
+        symlink_to: &Path,
+    ) -> Result<(), TarballError> {
+        // If name contains `/` such as @fastify/error, we need to make sure that @fastify folder
+        // exists before we symlink to that directory.
+        if name.contains('/') {
+            fs::create_dir_all(symlink_to.parent().unwrap())?;
+        }
+
+        // Do not try to install dependency if this version already exists in package.json
+        if save_path.exists() {
+            if !symlink_to.is_symlink() {
+                symlink_dir(&save_path.to_path_buf(), &symlink_to.to_path_buf())?;
+            }
+            return Ok(());
+        }
 
-    extract_tarball(&tarball_path, save_path)?;
+        let tarball_path = env::temp_dir().join(Uuid::new_v4().to_string());
+        self.download(url, &tarball_path).await?;
 
-    // TODO: Currently symlink paths are absolute paths.
-    // If you move the root folder to a different path, all symlinks will be broken.
-    if !symlink_to.is_symlink() {
-        symlink_dir(&save_path.to_path_buf(), &symlink_to.to_path_buf())?;
+        self.extract(&tarball_path, save_path)?;
+
+        // TODO: Currently symlink paths are absolute paths.
+        // If you move the root folder to a different path, all symlinks will be broken.
+        if !symlink_to.is_symlink() {
+            symlink_dir(&save_path.to_path_buf(), &symlink_to.to_path_buf())?;
+        }
+
+        Ok(())
     }
+}
 
-    Ok(())
+pub fn get_package_store_folder_name(input: &str, version: &str) -> String {
+    format!("{0}@{1}", input.replace('/', "+"), version)
 }
 
 #[cfg(test)]
@@ -132,14 +148,17 @@ mod tests {
         let save_path = store_path.join("@fastify+error@3.3.0");
         let symlink_path = node_modules_path.join("@fastify/error");
 
-        download_dependency(
-            "@fastify/error",
-            "https://registry.npmjs.org/@fastify/error/-/error-3.3.0.tgz",
-            &save_path.to_path_buf(),
-            &symlink_path.to_path_buf(),
-        )
-        .await
-        .unwrap();
+        let manager = TarballManager::new();
+
+        manager
+            .download_dependency(
+                "@fastify/error",
+                "https://registry.npmjs.org/@fastify/error/-/error-3.3.0.tgz",
+                &save_path.to_path_buf(),
+                &symlink_path.to_path_buf(),
+            )
+            .await
+            .unwrap();
 
         // Validate if we delete the tar.gz file
         assert!(!store_path.join("@fastify+error@3.3.0.tar.gz").exists());