Add configurable archive size limit

Heliozoa · Heliozoa · commit 327514805aaf · 2025-09-19T15:16:14.000+03:00
diff --git a/crates/bindings/tmc-langs-node/src/lib.rs b/crates/bindings/tmc-langs-node/src/lib.rs
@@ -612,7 +612,7 @@ fn paste(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let locale = locale.map(|l| Language::from_639_3(&l).expect("Invalid locale"));
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.paste(exercise_id, &submission_path, paste_message, locale)?)
+        Ok(client.paste(exercise_id, &submission_path, paste_message, locale, 500)?)
     });
     convert_res(&mut cx, res)
 }
@@ -636,6 +636,7 @@ fn request_code_review(mut cx: FunctionContext) -> JsResult<JsValue> {
             &submission_path,
             message_for_reviewer,
             Some(locale),
+            500,
         )?)
     });
     convert_res(&mut cx, res)
@@ -654,7 +655,7 @@ fn reset_exercise(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let res = with_client(client_name, client_version, |client| {
         if save_old_state {
-            client.submit(exercise_id, &exercise_path, None)?;
+            client.submit(exercise_id, &exercise_path, 500, None)?;
         }
         tmc_langs::reset(client, exercise_id, &exercise_path)
     });
@@ -701,7 +702,7 @@ fn submit(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let locale = locale.map(|l| Language::from_639_3(&l).expect("Invalid locale"));
     let temp = with_client(client_name, client_version, |client| {
-        let new_submission = client.submit(exercise_id, &submission_path, locale)?;
+        let new_submission = client.submit(exercise_id, &submission_path, 500, locale)?;
         if dont_block {
             Ok(Temp::NewSubmission(new_submission))
         } else {
diff --git a/crates/tmc-langs-cli/src/lib.rs b/crates/tmc-langs-cli/src/lib.rs
@@ -25,7 +25,7 @@ use std::{
 };
 use tmc_langs::{
     CommandError, Compression, Credentials, DownloadOrUpdateTmcCourseExercisesResult,
-    DownloadResult, Language, StyleValidationResult, TmcConfig, UpdatedExercise,
+    DownloadResult, Language, StyleValidationResult, TmcConfig, TmcProjectYml, UpdatedExercise,
     file_util::{self, Lock, LockOptions},
     mooc::{MoocClient, MoocClientError},
     tmc::{TestMyCodeClient, TestMyCodeClientError, request::FeedbackAnswer},
@@ -894,9 +894,16 @@ fn run_tmc_inner(
             let mut lock = Lock::dir(&submission_path, LockOptions::Read)?;
             let _guard = lock.lock()?;
 
+            let tmc_project_yml = TmcProjectYml::load_or_default(&submission_path)?;
             let locale = locale.map(|l| l.0);
             let new_submission = client
-                .paste(exercise_id, &submission_path, paste_message, locale)
+                .paste(
+                    exercise_id,
+                    &submission_path,
+                    paste_message,
+                    locale,
+                    tmc_project_yml.get_submission_size_limit_mb(),
+                )
                 .context("Failed to get paste with comment")?;
             CliOutput::finished_with_data("sent paste", DataKind::NewSubmission(new_submission))
         }
@@ -910,12 +917,14 @@ fn run_tmc_inner(
             let mut lock = Lock::dir(&submission_path, LockOptions::Read)?;
             let _guard = lock.lock()?;
 
+            let tmc_project_yml = TmcProjectYml::load_or_default(&submission_path)?;
             let new_submission = client
                 .request_code_review(
                     exercise_id,
                     &submission_path,
                     message_for_reviewer,
                     Some(locale),
+                    tmc_project_yml.get_submission_size_limit_mb(),
                 )
                 .context("Failed to request code review")?;
             CliOutput::finished_with_data(
@@ -934,7 +943,13 @@ fn run_tmc_inner(
 
             if save_old_state {
                 // submit current state
-                client.submit(exercise_id, &exercise_path, None)?;
+                let tmc_project_yml = TmcProjectYml::load_or_default(&exercise_path)?;
+                client.submit(
+                    exercise_id,
+                    &exercise_path,
+                    tmc_project_yml.get_submission_size_limit_mb(),
+                    None,
+                )?;
             }
             tmc_langs::reset(client, exercise_id, &exercise_path)?;
             CliOutput::finished("reset exercise")
@@ -987,8 +1002,14 @@ fn run_tmc_inner(
             let _guard = lock.lock()?;
 
             let locale = locale.map(|l| l.0);
+            let tmc_project_yml = TmcProjectYml::load_or_default(&submission_path)?;
             let new_submission = client
-                .submit(exercise_id, &submission_path, locale)
+                .submit(
+                    exercise_id,
+                    &submission_path,
+                    tmc_project_yml.get_submission_size_limit_mb(),
+                    locale,
+                )
                 .context("Failed to submit")?;
 
             if dont_block {
diff --git a/crates/tmc-langs-framework/src/archive.rs b/crates/tmc-langs-framework/src/archive.rs
@@ -293,7 +293,12 @@ pub enum Compression {
 }
 
 impl Compression {
-    pub fn compress(self, path: &Path, hash: bool) -> Result<(Vec<u8>, Option<Hash>), TmcError> {
+    pub fn compress(
+        self,
+        path: &Path,
+        hash: bool,
+        size_limit_mb: u32,
+    ) -> Result<(Vec<u8>, Option<Hash>), TmcError> {
         let mut hasher = if hash { Some(Hasher::new()) } else { None };
         let buf = match self {
             Self::Tar => {
@@ -365,8 +370,22 @@ impl Compression {
             }
         };
         let hash = hasher.map(|h| h.finalize());
+        Self::enforce_archive_size_limit(&buf, size_limit_mb)?;
         Ok((buf, hash))
     }
+
+    pub fn enforce_archive_size_limit(data: &[u8], size_limit_mb: u32) -> Result<(), TmcError> {
+        if let Ok(data_len_b) = u64::try_from(data.len()) {
+            let size_limit_b = u64::from(size_limit_mb) * 1000 * 1000;
+            if data_len_b <= size_limit_b {
+                return Ok(());
+            }
+        }
+        Err(TmcError::ArchiveSizeLimitExceeded {
+            limit: size_limit_mb,
+            actual: data.len(),
+        })
+    }
 }
 
 fn walk_dir_for_compression(
diff --git a/crates/tmc-langs-framework/src/error.rs b/crates/tmc-langs-framework/src/error.rs
@@ -29,6 +29,10 @@ pub enum TmcError {
     ZstdRead(#[source] std::io::Error),
     #[error("Failed to write zstd archive")]
     ZstdWrite(#[source] std::io::Error),
+    #[error(
+        "Archive size limit exceeded when compressing proejct (limit: {limit} MB, archive: {actual} MB)"
+    )]
+    ArchiveSizeLimitExceeded { limit: u32, actual: usize },
 
     #[error("Path {0} is not valid UTF-8")]
     InvalidUtf8(PathBuf),
diff --git a/crates/tmc-langs-framework/src/tmc_project_yml.rs b/crates/tmc-langs-framework/src/tmc_project_yml.rs
@@ -14,6 +14,8 @@ use tmc_langs_util::{
     file_util::{self, Lock, LockOptions},
 };
 
+const DEFAULT_SUBMISSION_SIZE_LIMIT_MB: u32 = 500;
+
 /// Extra data from a `.tmcproject.yml` file.
 #[derive(Debug, Serialize, Deserialize, Default, Clone)]
 #[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
@@ -60,6 +62,11 @@ pub struct TmcProjectYml {
     #[serde(default)]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub sandbox_image: Option<String>,
+
+    /// Overrides the default archive size limit (500 Mb).
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub submission_size_limit_mb: Option<u32>,
 }
 
 impl TmcProjectYml {
@@ -120,6 +127,9 @@ impl TmcProjectYml {
             minimum_python_version: old.minimum_python_version.or(with.minimum_python_version),
             sandbox_image: old.sandbox_image.or(with.sandbox_image),
             no_tests: old.no_tests.or(with.no_tests),
+            submission_size_limit_mb: old
+                .submission_size_limit_mb
+                .or(with.submission_size_limit_mb),
         };
         *self = new;
     }
@@ -132,6 +142,11 @@ impl TmcProjectYml {
         serde_yaml::to_writer(guard.get_file_mut(), &self)?;
         Ok(())
     }
+
+    pub fn get_submission_size_limit_mb(&self) -> u32 {
+        self.submission_size_limit_mb
+            .unwrap_or(DEFAULT_SUBMISSION_SIZE_LIMIT_MB)
+    }
 }
 
 /// Python version from TmcProjectYml.
@@ -300,6 +315,24 @@ mod test {
         assert_eq!(no_tests.points, &["1", "notests"]);
     }
 
+    #[test]
+    fn deserialize_submission_size_limit_mb() {
+        init();
+
+        let submission_size_limit_mb = r#"submission_size_limit_mb: 100
+"#;
+
+        let cfg: TmcProjectYml = deserialize::yaml_from_str(submission_size_limit_mb).unwrap();
+        let submission_size_limit_mb = cfg.submission_size_limit_mb.unwrap();
+        assert_eq!(submission_size_limit_mb, 100);
+        let submission_size_limit_mb = cfg.get_submission_size_limit_mb();
+        assert_eq!(submission_size_limit_mb, 100);
+
+        let cfg: TmcProjectYml = deserialize::yaml_from_str("").unwrap();
+        let submission_size_limit_mb = cfg.get_submission_size_limit_mb();
+        assert_eq!(submission_size_limit_mb, DEFAULT_SUBMISSION_SIZE_LIMIT_MB);
+    }
+
     #[test]
     fn deserialize_python_ver() {
         init();
diff --git a/crates/tmc-langs-plugins/src/compression.rs b/crates/tmc-langs-plugins/src/compression.rs
@@ -19,6 +19,7 @@ pub fn compress_student_files(
     compression: Compression,
     deterministic: bool,
     hash: bool,
+    size_limit_mb: u32,
 ) -> 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);
@@ -59,7 +60,9 @@ pub fn compress_student_files(
     }
     let hash = hasher.map(|h| h.finalize());
     let cursor = writer.finish()?;
-    Ok((cursor.into_inner(), hash))
+    let data = cursor.into_inner();
+    Compression::enforce_archive_size_limit(&data, size_limit_mb)?;
+    Ok((data, hash))
 }
 
 // ensures the / separator is used
@@ -195,7 +198,7 @@ mod test {
         fs::{self, *},
     };
     use tempfile::tempdir;
-    use tmc_langs_framework::EverythingIsStudentFilePolicy;
+    use tmc_langs_framework::{EverythingIsStudentFilePolicy, TmcProjectYml};
 
     fn init() {
         use log::*;
@@ -228,12 +231,14 @@ mod test {
         File::create(missing_file_path).unwrap();
 
         let path = temp.path().join("exercise-name");
+        let tmcprojectyml = TmcProjectYml::load_or_default(&path).unwrap();
         let (zipped, _hash) = compress_student_files(
             &EverythingIsStudentFilePolicy::new(&path).unwrap(),
             &path,
             Compression::Zip,
             true,
             false,
+            tmcprojectyml.get_submission_size_limit_mb(),
         )
         .unwrap();
         let mut archive = ZipArchive::new(Cursor::new(zipped)).unwrap();
diff --git a/crates/tmc-langs-plugins/src/lib.rs b/crates/tmc-langs-plugins/src/lib.rs
@@ -54,9 +54,10 @@ pub fn compress_project(
     deterministic: bool,
     naive: bool,
     hash: bool,
+    size_limit_mb: u32,
 ) -> Result<(Vec<u8>, Option<Hash>), PluginError> {
     let (compressed, hash) = if naive {
-        compression.compress(path, hash)?
+        compression.compress(path, hash, size_limit_mb)?
     } else {
         let policy = get_student_file_policy(path)?;
         compression::compress_student_files(
@@ -65,9 +66,9 @@ pub fn compress_project(
             compression,
             deterministic,
             hash,
+            size_limit_mb,
         )?
     };
-
     Ok((compressed, hash))
 }
 
diff --git a/crates/tmc-langs/src/lib.rs b/crates/tmc-langs/src/lib.rs
@@ -150,7 +150,13 @@ pub fn download_old_submission(
 
     if save_old_state {
         // submit old exercise
-        client.submit(exercise_id, output_path, None)?;
+        let tmc_project_yml = TmcProjectYml::load_or_default(output_path)?;
+        client.submit(
+            exercise_id,
+            output_path,
+            tmc_project_yml.get_submission_size_limit_mb(),
+            None,
+        )?;
         log::debug!("finished submission");
     }
 
@@ -185,8 +191,14 @@ pub fn submit_exercise(
     let exercise_path =
         ProjectsConfig::get_tmc_exercise_download_target(projects_dir, course_slug, exercise_slug);
 
+    let tmc_project_yml = TmcProjectYml::load_or_default(&exercise_path)?;
     client
-        .submit(exercise.id, exercise_path.as_path(), locale)
+        .submit(
+            exercise.id,
+            exercise_path.as_path(),
+            tmc_project_yml.get_submission_size_limit_mb(),
+            locale,
+        )
         .map_err(Into::into)
 }
 
@@ -207,8 +219,15 @@ pub fn paste_exercise(
     let exercise_path =
         ProjectsConfig::get_tmc_exercise_download_target(projects_dir, course_slug, exercise_slug);
 
+    let tmc_project_yml = TmcProjectYml::load_or_default(&exercise_path)?;
     client
-        .paste(exercise.id, exercise_path.as_path(), paste_message, locale)
+        .paste(
+            exercise.id,
+            exercise_path.as_path(),
+            paste_message,
+            locale,
+            tmc_project_yml.get_submission_size_limit_mb(),
+        )
         .map_err(Into::into)
 }
 
@@ -846,8 +865,15 @@ pub fn compress_project_to(
         compression
     );
 
-    let (data, _hash) =
-        tmc_langs_plugins::compress_project(source, compression, deterministic, naive, false)?;
+    let tmc_project_yml = TmcProjectYml::load_or_default(source)?;
+    let (data, _hash) = tmc_langs_plugins::compress_project(
+        source,
+        compression,
+        deterministic,
+        naive,
+        false,
+        tmc_project_yml.get_submission_size_limit_mb(),
+    )?;
     file_util::write_to_file(data, target)?;
     Ok(())
 }
@@ -868,8 +894,15 @@ pub fn compress_project_to_with_hash(
         compression
     );
 
-    let (data, hash) =
-        tmc_langs_plugins::compress_project(source, compression, deterministic, naive, true)?;
+    let tmc_project_yml = TmcProjectYml::load_or_default(source)?;
+    let (data, hash) = tmc_langs_plugins::compress_project(
+        source,
+        compression,
+        deterministic,
+        naive,
+        true,
+        tmc_project_yml.get_submission_size_limit_mb(),
+    )?;
     let hash = hash.expect("set hash to true");
     file_util::write_to_file(data, target)?;
     Ok(hash.to_string())
diff --git a/crates/tmc-testmycode-client/src/client.rs b/crates/tmc-testmycode-client/src/client.rs
diff --git a/docs/tmcproject.md b/docs/tmcproject.md
