temp

Author: Heliozoa

Cargo.lock

@@ -4,8 +4,8 @@ use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use tmc_langs::{
     CombinedCourseData, ConfigValue, DownloadOrUpdateCourseExercisesResult, ExerciseDesc,
-    ExerciseDownload, ExercisePackagingConfiguration, LocalExercise, LocalMoocExercise,
-    LocalTmcExercise, RunResult, StyleValidationResult, TmcConfig, UpdatedExercise, mooc,
+    ExerciseDownload, ExercisePackagingConfiguration, LocalMoocExercise, LocalTmcExercise,
+    RunResult, StyleValidationResult, TmcConfig, UpdatedExercise, mooc,
     notification_reporter::Notification,
     tmc::{
         ClientUpdateData, Token, UpdateResult,

crates/tmc-langs-cli/src/output.rs

@@ -10,6 +10,7 @@ rust-version.workspace = true
 tmc-langs-util.workspace = true
 ts-rs = { workspace = true, features = ["serde-compat"], optional = true }
 
+blake3 = "1.4.0"
 fd-lock = "4.0.0"
 isolang = "2.1.0"
 log = "0.4.14"

crates/tmc-langs-framework/Cargo.toml

@@ -1,11 +1,13 @@
 //! Contains types that abstract over the various archive formats.
 
 use crate::TmcError;
+use blake3::{Hash, Hasher};
 use serde::Deserialize;
 use std::{
     fmt::Display,
     io::{BufReader, Cursor, Read, Seek, Write},
     ops::ControlFlow::{self, Break},
+    os::unix::ffi::OsStrExt,
     path::{Path, PathBuf},
     str::FromStr,
 };
@@ -92,9 +94,9 @@ impl<T: Read + Seek> Archive<T> {
                         return Ok(Entry::Tar(entry));
                     }
                 }
-                Err(TmcError::TarRead(std::io::Error::other(
-                    format!("Could not find {path} in tar"),
-                )))
+                Err(TmcError::TarRead(std::io::Error::other(format!(
+                    "Could not find {path} in tar"
+                ))))
             }
             Self(ArchiveInner::TarZstd(archive)) => {
                 for entry in archive.entries().map_err(TmcError::TarRead)? {
@@ -103,9 +105,9 @@ impl<T: Read + Seek> Archive<T> {
                         return Ok(Entry::TarZstd(entry));
                     }
                 }
-                Err(TmcError::TarRead(std::io::Error::other(
-                    format!("Could not find {path} in tar"),
-                )))
+                Err(TmcError::TarRead(std::io::Error::other(format!(
+                    "Could not find {path} in tar"
+                ))))
             }
             Self(ArchiveInner::Zip(archive)) => {
                 archive.by_name(path).map(Entry::Zip).map_err(Into::into)
@@ -292,17 +294,23 @@ pub enum Compression {
 }
 
 impl Compression {
-    pub fn compress(self, path: &Path) -> Result<Vec<u8>, TmcError> {
+    pub fn compress(self, path: &Path, hash: bool) -> Result<(Vec<u8>, Option<Hash>), TmcError> {
+        let mut hasher = if hash { Some(Hasher::new()) } else { None };
         let buf = match self {
             Self::Tar => {
                 let buf = Cursor::new(Vec::new());
                 let mut builder = tar::Builder::new(buf);
                 walk_dir_for_compression(path, |entry, relative_path| {
                     if entry.path().is_dir() {
+                        hasher.as_mut().map(|h| h.update(relative_path.as_bytes()));
                         builder
                             .append_dir(relative_path, entry.path())
                             .map_err(TmcError::TarWrite)?;
                     } else if entry.path().is_file() {
+                        if let Some(h) = &mut hasher {
+                            let file = file_util::read_file(entry.path())?;
+                            h.update(&file);
+                        }
                         builder
                             .append_path_with_name(entry.path(), relative_path)
                             .map_err(TmcError::TarWrite)?;
@@ -319,10 +327,12 @@ impl Compression {
                 let mut writer = zip::ZipWriter::new(buf);
                 walk_dir_for_compression(path, |entry, relative_path| {
                     if entry.path().is_dir() {
+                        hasher.as_mut().map(|h| h.update(relative_path.as_bytes()));
                         writer.add_directory(relative_path, SimpleFileOptions::default())?;
                     } else if entry.path().is_file() {
-                        writer.start_file(relative_path, SimpleFileOptions::default())?;
                         let contents = file_util::read_file(entry.path())?;
+                        hasher.as_mut().map(|h| h.update(&contents));
+                        writer.start_file(relative_path, SimpleFileOptions::default())?;
                         writer
                             .write_all(&contents)
                             .map_err(|err| TmcError::ZipWrite(path.to_path_buf(), err))?;
@@ -336,10 +346,15 @@ impl Compression {
                 let mut builder = tar::Builder::new(tar_buf);
                 walk_dir_for_compression(path, |entry, relative_path| {
                     if entry.path().is_dir() {
+                        hasher.as_mut().map(|h| h.update(relative_path.as_bytes()));
                         builder
                             .append_dir(relative_path, entry.path())
                             .map_err(TmcError::TarWrite)?;
                     } else if entry.path().is_file() {
+                        if let Some(h) = &mut hasher {
+                            let file = file_util::read_file(entry.path())?;
+                            h.update(&file);
+                        }
                         builder
                             .append_path_with_name(entry.path(), relative_path)
                             .map_err(TmcError::TarWrite)?;
@@ -350,7 +365,8 @@ impl Compression {
                 zstd::stream::encode_all(tar_buf.as_slice(), 0).map_err(TmcError::ZstdWrite)?
             }
         };
-        Ok(buf)
+        let hash = hasher.map(|h| h.finalize());
+        Ok((buf, hash))
     }
 }
 

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

@@ -16,6 +16,7 @@ tmc-langs-notests.workspace = true
 tmc-langs-python3.workspace = true
 tmc-langs-r.workspace = true
 
+blake3 = "1.4.0"
 log = "0.4.14"
 tar = "0.4.38"
 thiserror = "2.0.3"

crates/tmc-langs-plugins/Cargo.toml

@@ -1,6 +1,7 @@
 //! Contains functions for compressing and uncompressing projects.
 
 use crate::archive::ArchiveBuilder;
+use blake3::{Hash, Hasher};
 use std::{
     io::{Cursor, Read, Seek},
     path::{Path, PathBuf},
@@ -17,7 +18,9 @@ pub fn compress_student_files(
     root_directory: &Path,
     compression: Compression,
     deterministic: bool,
-) -> Result<Vec<u8>, TmcError> {
+    hash: bool,
+) -> Result<(Vec<u8>, Option<Hash>), TmcError> {
+    let mut hasher = if hash { Some(Hasher::new()) } else { None };
     let mut writer = ArchiveBuilder::new(Cursor::new(vec![]), compression, deterministic);
 
     for entry in WalkDir::new(root_directory)
@@ -42,14 +45,21 @@ pub fn compress_student_files(
                 })
                 .unwrap_or_else(|| entry.path());
             if entry.path().is_dir() {
-                writer.add_directory(entry.path(), &path_to_zip_compatible_string(path))?;
+                let path_in_archive = path_to_zip_compatible_string(path);
+                hasher
+                    .as_mut()
+                    .map(|h| h.update(path_in_archive.as_bytes()));
+                writer.add_directory(entry.path(), &path_in_archive)?;
             } else {
+                let contents = file_util::read_file(entry.path())?;
+                hasher.as_mut().map(|h| h.update(&contents));
                 writer.add_file(entry.path(), &path_to_zip_compatible_string(path))?;
             }
         }
     }
+    let hash = hasher.map(|h| h.finalize());
     let cursor = writer.finish()?;
-    Ok(cursor.into_inner())
+    Ok((cursor.into_inner(), hash))
 }
 
 // ensures the / separator is used
@@ -218,11 +228,12 @@ mod test {
         File::create(missing_file_path).unwrap();
 
         let path = temp.path().join("exercise-name");
-        let zipped = compress_student_files(
+        let (zipped, _hash) = compress_student_files(
             &EverythingIsStudentFilePolicy::new(&path).unwrap(),
             &path,
             Compression::Zip,
             true,
+            false,
         )
         .unwrap();
         let mut archive = ZipArchive::new(Cursor::new(zipped)).unwrap();

crates/tmc-langs-plugins/src/compression.rs

@@ -6,6 +6,7 @@ pub mod archive;
 pub mod compression;
 mod error;
 
+use blake3::Hash;
 pub use error::PluginError;
 use std::{
     io::{Read, Seek},
@@ -52,15 +53,22 @@ pub fn compress_project(
     compression: Compression,
     deterministic: bool,
     naive: bool,
-) -> Result<Vec<u8>, PluginError> {
-    let compressed = if naive {
-        compression.compress(path)?
+    hash: bool,
+) -> Result<(Vec<u8>, Option<Hash>), PluginError> {
+    let (compressed, hash) = if naive {
+        compression.compress(path, hash)?
     } else {
         let policy = get_student_file_policy(path)?;
-        compression::compress_student_files(policy.as_ref(), path, compression, deterministic)?
+        compression::compress_student_files(
+            policy.as_ref(),
+            path,
+            compression,
+            deterministic,
+            hash,
+        )?
     };
 
-    Ok(compressed)
+    Ok((compressed, hash))
 }
 
 /// Enum containing variants for each language plugin.

crates/tmc-langs-plugins/src/lib.rs

@@ -820,8 +820,8 @@ pub fn compress_project_to(
         compression
     );
 
-    let data = tmc_langs_plugins::compress_project(source, compression, deterministic, naive)?;
-    let hash = blake3::hash(&data);
+    let (data, hash) =
+        tmc_langs_plugins::compress_project(source, compression, deterministic, naive)?;
     file_util::write_to_file(data, target)?;
     Ok(hash.to_string())
 }