Fixed zstd compression

Author: Heliozoa

Cargo.lock

@@ -15,7 +15,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.30.0"
+version = "0.32.0"
 authors = [
     "University of Helsinki <mooc@cs.helsinki.fi>",
     "Daniel Martinez <daniel.x.martinez@helsinki.fi>",

Cargo.toml

@@ -241,34 +241,38 @@ pub enum Compression {
 
 impl Compression {
     pub fn compress(self, path: &Path) -> Result<Vec<u8>, TmcError> {
-        let buf = Cursor::new(Vec::new());
         let buf = match self {
             Self::Tar => {
+                let buf = Cursor::new(Vec::new());
                 let mut builder = tar::Builder::new(buf);
                 builder
                     .append_dir_all(".", path)
                     .map_err(TmcError::TarWrite)?;
-                builder.into_inner().map_err(TmcError::TarWrite)?
+                builder
+                    .into_inner()
+                    .map_err(TmcError::TarWrite)?
+                    .into_inner()
             }
             Self::Zip => {
+                let buf = Cursor::new(Vec::new());
                 let mut writer = zip::ZipWriter::new(buf);
                 let path_str = path
                     .to_str()
                     .ok_or_else(|| TmcError::InvalidUtf8(path.to_path_buf()))?;
                 writer.add_directory(path_str, Default::default())?;
-                writer.finish()?
+                writer.finish()?.into_inner()
             }
             Self::TarZstd => {
-                let mut builder = tar::Builder::new(buf);
+                let tar_buf = vec![];
+                let mut builder = tar::Builder::new(tar_buf);
                 builder
                     .append_dir_all(".", path)
                     .map_err(TmcError::TarWrite)?;
-                let buf = builder.into_inner().map_err(TmcError::TarWrite)?;
-                let encoder = zstd::Encoder::new(buf, 0).map_err(TmcError::ZstdWrite)?;
-                encoder.finish().map_err(TmcError::ZstdWrite)?
+                let tar_buf = builder.into_inner().map_err(TmcError::TarWrite)?;
+                zstd::stream::encode_all(tar_buf.as_slice(), 0).map_err(TmcError::ZstdWrite)?
             }
         };
-        Ok(buf.into_inner())
+        Ok(buf)
     }
 }
 

crates/tmc-langs-framework/src/archive.rs

@@ -1,14 +1,13 @@
 //! Contains types that abstract over the various archive formats.
 
 use std::{
-    io::{self, Cursor, Seek, Write},
+    io::{Cursor, Seek, Write},
     path::Path,
 };
 use tar::Builder;
 use tmc_langs_framework::{Compression, TmcError};
 use tmc_langs_util::file_util;
 use zip::{write::FileOptions, ZipWriter};
-use zstd::Encoder;
 
 pub enum ArchiveBuilder<W: Write + Seek> {
     Tar(Builder<W>),
@@ -65,11 +64,11 @@ impl<W: Write + Seek> ArchiveBuilder<W> {
     pub fn finish(self) -> Result<W, TmcError> {
         let res = match self {
             Self::Tar(builder) => builder.into_inner().map_err(TmcError::TarWrite)?,
-            Self::TarZstd(writer, builder) => {
-                let mut tar_data = builder.into_inner().map_err(TmcError::TarWrite)?;
-                let mut encoder = Encoder::new(writer, 0).map_err(TmcError::ZstdWrite)?;
-                io::copy(&mut tar_data, &mut encoder).map_err(TmcError::ZstdWrite)?;
-                encoder.finish().map_err(TmcError::ZstdWrite)?
+            Self::TarZstd(mut writer, builder) => {
+                let tar_data = builder.into_inner().map_err(TmcError::TarWrite)?;
+                zstd::stream::copy_encode(tar_data.get_ref().as_slice(), &mut writer, 0)
+                    .map_err(TmcError::ZstdWrite)?;
+                writer
             }
             Self::Zip(mut builder) => builder.finish()?,
         };