1 files changed, 103 insertions, 74 deletions

diff --git a/src/archive.rs b/src/archive.rs
index b62c3bd..268bb47 100644
--- a/src/archive.rs
+++ b/src/archive.rs
@@ -1,8 +1,6 @@
 use actix_web::http::ContentEncoding;
-use bytes::Bytes;
 use libflate::gzip::Encoder;
 use serde::Deserialize;
-use std::io;
 use std::path::Path;
 use strum_macros::{Display, EnumIter, EnumString};
 use tar::Builder;
@@ -10,123 +8,154 @@ use tar::Builder;
 use crate::errors::ContextualError;
 
 /// Available compression methods
-#[derive(Deserialize, Clone, EnumIter, EnumString, Display)]
+#[derive(Deserialize, Clone, Copy, EnumIter, EnumString, Display)]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
 pub enum CompressionMethod {
-    /// TAR GZ
+    /// Gzipped tarball
     TarGz,
+
+    /// Regular tarball
+    Tar,
 }
 
 impl CompressionMethod {
-    pub fn extension(&self) -> String {
-        match &self {
+    pub fn extension(self) -> String {
+        match self {
             CompressionMethod::TarGz => "tar.gz",
+            CompressionMethod::Tar => "tar",
         }
         .to_string()
     }
 
-    pub fn content_type(&self) -> String {
-        match &self {
+    pub fn content_type(self) -> String {
+        match self {
             CompressionMethod::TarGz => "application/gzip",
+            CompressionMethod::Tar => "application/tar",
         }
         .to_string()
     }
 
-    pub fn content_encoding(&self) -> ContentEncoding {
-        match &self {
+    pub fn content_encoding(self) -> ContentEncoding {
+        match self {
             CompressionMethod::TarGz => ContentEncoding::Gzip,
+            CompressionMethod::Tar => ContentEncoding::Identity,
         }
     }
-    /// Creates an archive of a folder, using the algorithm the user chose from the web interface
-    /// This method returns the archive as a stream of bytes
-    pub fn create_archive<T: AsRef<Path>>(
-        &self,
+
+    /// Make an archive out of the given directory, and write the output to the given writer.
+    ///
+    /// Recursively includes all files and subdirectories.
+    ///
+    /// If `skip_symlinks` is `true`, symlinks fill not be followed and will just be ignored.
+    pub fn create_archive<T, W>(
+        self,
         dir: T,
         skip_symlinks: bool,
-    ) -> Result<(String, Bytes), ContextualError> {
+        out: W,
+    ) -> Result<(), ContextualError>
+    where
+        T: AsRef<Path>,
+        W: std::io::Write,
+    {
+        let dir = dir.as_ref();
         match self {
-            CompressionMethod::TarGz => tgz_compress(dir, skip_symlinks),
+            CompressionMethod::TarGz => tar_gz(dir, skip_symlinks, out),
+            CompressionMethod::Tar => tar_dir(dir, skip_symlinks, out),
         }
     }
 }
 
-/// Compresses a given folder in .tar.gz format, and returns the result as a stream of bytes
-fn tgz_compress<T: AsRef<Path>>(
-    dir: T,
-    skip_symlinks: bool,
-) -> Result<(String, Bytes), ContextualError> {
-    if let Some(inner_folder) = dir.as_ref().file_name() {
-        if let Some(directory) = inner_folder.to_str() {
-            let dst_filename = format!("{}.tar", directory);
-            let dst_tgz_filename = format!("{}.gz", dst_filename);
-            let mut tgz_data = Bytes::new();
-
-            let tar_data =
-                tar(dir.as_ref(), directory.to_string(), skip_symlinks).map_err(|e| {
-                    ContextualError::ArchiveCreationError("tarball".to_string(), Box::new(e))
-                })?;
-
-            let gz_data = gzip(&tar_data).map_err(|e| {
-                ContextualError::ArchiveCreationError("GZIP archive".to_string(), Box::new(e))
-            })?;
-
-            tgz_data.extend_from_slice(&gz_data);
-
-            Ok((dst_tgz_filename, tgz_data))
-        } else {
-            // https://doc.rust-lang.org/std/ffi/struct.OsStr.html#method.to_str
-            Err(ContextualError::InvalidPathError(
-                "Directory name contains invalid UTF-8 characters".to_string(),
-            ))
-        }
-    } else {
-        // https://doc.rust-lang.org/std/path/struct.Path.html#method.file_name
-        Err(ContextualError::InvalidPathError(
-            "Directory name terminates in \"..\"".to_string(),
-        ))
-    }
+/// Write a gzipped tarball of `dir` in `out`.
+fn tar_gz<W>(dir: &Path, skip_symlinks: bool, out: W) -> Result<(), ContextualError>
+where
+    W: std::io::Write,
+{
+    let mut out = Encoder::new(out).map_err(|e| ContextualError::IOError("GZIP".to_string(), e))?;
+
+    tar_dir(dir, skip_symlinks, &mut out)?;
+
+    out.finish()
+        .into_result()
+        .map_err(|e| ContextualError::IOError("GZIP finish".to_string(), e))?;
+
+    Ok(())
 }
 
-/// Creates a TAR archive of a folder, and returns it as a stream of bytes
-fn tar<T: AsRef<Path>>(
-    src_dir: T,
+/// Write a tarball of `dir` in `out`.
+///
+/// The target directory will be saved as a top-level directory in the archive.
+///
+/// For example, consider this directory structure:
+///
+/// ```
+/// a
+/// └── b
+///     └── c
+///         ├── e
+///         ├── f
+///         └── g
+/// ```
+///
+/// Making a tarball out of `"a/b/c"` will result in this archive content:
+///
+/// ```
+/// c
+/// ├── e
+/// ├── f
+/// └── g
+/// ```
+fn tar_dir<W>(dir: &Path, skip_symlinks: bool, out: W) -> Result<(), ContextualError>
+where
+    W: std::io::Write,
+{
+    let inner_folder = dir.file_name().ok_or_else(|| {
+        ContextualError::InvalidPathError("Directory name terminates in \"..\"".to_string())
+    })?;
+
+    let directory = inner_folder.to_str().ok_or_else(|| {
+        ContextualError::InvalidPathError(
+            "Directory name contains invalid UTF-8 characters".to_string(),
+        )
+    })?;
+
+    tar(dir, directory.to_string(), skip_symlinks, out)
+        .map_err(|e| ContextualError::ArchiveCreationError("tarball".to_string(), Box::new(e)))
+}
+
+/// Writes a tarball of `dir` in `out`.
+///
+/// The content of `src_dir` will be saved in the archive as a folder named `inner_folder`.
+fn tar<W>(
+    src_dir: &Path,
     inner_folder: String,
     skip_symlinks: bool,
-) -> Result<Vec<u8>, ContextualError> {
-    let mut tar_builder = Builder::new(Vec::new());
+    out: W,
+) -> Result<(), ContextualError>
+where
+    W: std::io::Write,
+{
+    let mut tar_builder = Builder::new(out);
 
     tar_builder.follow_symlinks(!skip_symlinks);
+
     // Recursively adds the content of src_dir into the archive stream
     tar_builder
-        .append_dir_all(inner_folder, src_dir.as_ref())
+        .append_dir_all(inner_folder, src_dir)
         .map_err(|e| {
             ContextualError::IOError(
                 format!(
                     "Failed to append the content of {} to the TAR archive",
-                    src_dir.as_ref().to_str().unwrap_or("file")
+                    src_dir.to_str().unwrap_or("file")
                 ),
                 e,
             )
         })?;
 
-    let tar_content = tar_builder.into_inner().map_err(|e| {
+    // Finish the archive
+    tar_builder.into_inner().map_err(|e| {
         ContextualError::IOError("Failed to finish writing the TAR archive".to_string(), e)
     })?;
 
-    Ok(tar_content)
-}
-
-/// Compresses a stream of bytes using the GZIP algorithm, and returns the resulting stream
-fn gzip(mut data: &[u8]) -> Result<Vec<u8>, ContextualError> {
-    let mut encoder = Encoder::new(Vec::new())
-        .map_err(|e| ContextualError::IOError("Failed to create GZIP encoder".to_string(), e))?;
-    io::copy(&mut data, &mut encoder)
-        .map_err(|e| ContextualError::IOError("Failed to write GZIP data".to_string(), e))?;
-    let data = encoder
-        .finish()
-        .into_result()
-        .map_err(|e| ContextualError::IOError("Failed to write GZIP trailer".to_string(), e))?;
-
-    Ok(data)
+    Ok(())
 }