VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Export for Screens: a cancel while the archive is made returns no archive
dotCooCoo2731ffacdd86
diff --git a/crates/engine/src/cmd/fileio/screens.rs b/crates/engine/src/cmd/fileio/screens.rsindex 62e1519b3..a1d2ae90c 100644--- a/crates/engine/src/cmd/fileio/screens.rs+++ b/crates/engine/src/cmd/fileio/screens.rs@@ -818,14 +818,18 @@ fn encode_and_write(export: ScreenExport, writer: &mut dyn FnMut(&str, &[u8]) ->files += 1;}}+ // A cancel that came while the last file was encoded returns no files.+ vectorcraft_doc::cancel::check()?;let names: Vec<&str> = out.kept.iter().map(|(n, _)| n.as_str()).collect();if o.zip {- let zip = super::zip::deflate(&out.kept, super::zip::FIXED_TIME).map_err(|e| bad(C, e))?;+ let zip = super::zip::deflate(&out.kept, super::zip::FIXED_TIME, vectorcraft_doc::cancel::is_cancelled);+ // A cancel that came while the files were deflated returns and writes no archive.+ vectorcraft_doc::cancel::check()?;+ let zip = zip.map_err(|e| bad(C, e))?;let zip_name = safe_file_name(&format!("{}{}.zip", naming.prefix, naming.filename));return match folder {Some(dir) => {let path = format!("{dir}/{zip_name}");- vectorcraft_doc::cancel::check()?;writer(&path, &zip)?;Ok(json!({ "path": path, "bytes": zip.len(), "files": names, "warnings": warnings }))}diff --git a/crates/engine/src/cmd/fileio/tests_screens.rs b/crates/engine/src/cmd/fileio/tests_screens.rsindex fc66edb27..78c8a147b 100644--- a/crates/engine/src/cmd/fileio/tests_screens.rs+++ b/crates/engine/src/cmd/fileio/tests_screens.rs@@ -662,7 +662,7 @@ fn zip_archives_deflate_what_gets_smaller() {.collect();let text = "<rect x=\"5\" y=\"5\" width=\"20\" height=\"20\"/>\n".repeat(100).into_bytes();let files = [("art.svg", text.clone()), ("sub/ünï.png", noise.clone()), ("empty", vec![])];- let zip = super::zip::deflate(&files, super::zip::FIXED_TIME).unwrap();+ let zip = super::zip::deflate(&files, super::zip::FIXED_TIME, || false).unwrap();assert_eq!(methods(&zip), [8, 0, 0], "the text deflated, the noise and the empty file stored");assert!(zip.windows(noise.len()).any(|w| w == noise.as_slice()), "a stored file's bytes are in the archive as they are");assert!(zip.len() < super::zip::store(&files).unwrap().len());@@ -671,7 +671,60 @@ fn zip_archives_deflate_what_gets_smaller() {for ((n, b), (m, c)) in files.iter().zip(&back) {assert_eq!((*n, b), (m.as_str(), c));}- assert_eq!(super::zip::deflate(&files, super::zip::FIXED_TIME).unwrap(), zip, "the same files, the same archive");+ assert_eq!(super::zip::deflate(&files, super::zip::FIXED_TIME, || false).unwrap(), zip, "the same files, the same archive");+}++/// `deflate` asks `stop` before each chunk of a file and drops the archive when it answers true.+#[test]+fn zip_deflating_stops_between_chunks() {+ let big = vec![7u8; 3 * super::zip::DEFLATE_CHUNK];+ let files = [("a.bin", big.clone()), ("b.bin", big)];+ let asked = std::cell::Cell::new(0);+ let all = super::zip::deflate(&files, super::zip::FIXED_TIME, || {+ asked.set(asked.get() + 1);+ false+ });+ assert!(all.is_ok());+ assert_eq!(asked.get(), 6, "once per chunk of each file");+ asked.set(0);+ let r = super::zip::deflate(&files, super::zip::FIXED_TIME, || {+ asked.set(asked.get() + 1);+ asked.get() == 2+ });+ assert!(r.is_err(), "stopped");+ assert_eq!(asked.get(), 2, "nothing more is deflated after the stop");+}++/// A cancel that comes after the last file was encoded (here: during the last step, a row that+/// repeats the one before it and writes nothing) returns no files and no archive, as it writes no+/// archive into a folder.+#[cfg(not(target_arch = "wasm32"))]+#[test]+fn a_cancel_after_the_last_file_returns_nothing() {+ let mut s = session(1);+ let dir = std::env::temp_dir().join(format!("vc-screens-cancel-last-{}", std::process::id()));+ let folder = dir.to_string_lossy().replace(std::path::MAIN_SEPARATOR, "/");+ let rows = json!([{"format": "svg"}, {"format": "svg"}]);+ for p in [json!({ "formats": rows }), json!({ "formats": rows, "zip": true }), json!({ "formats": rows, "zip": true, "folder": folder })] {+ let prepared = s.prepare_screen_export("document.exportForScreens", &p).unwrap();+ let token = vectorcraft_doc::cancel::CancelToken::new();+ let on_last = token.clone();+ let sink: vectorcraft_doc::cancel::ProgressSink = std::rc::Rc::new(move |done, total, _| {+ if done + 1 == total {+ on_last.cancel();+ }+ });+ let mut written = vec![];+ let r = vectorcraft_doc::cancel::scope(&token, Some(sink), || {+ prepared.write(&mut |path: &str, _: &[u8]| {+ written.push(path.to_string());+ Ok(())+ })+ });+ assert!(matches!(r, Err(crate::EngineError::Cancelled)), "{p}: {r:?}");+ assert_eq!(written, Vec::<String>::new(), "{p}");+ }+ let _ = std::fs::remove_dir_all(dir);}#[test]diff --git a/crates/engine/src/cmd/fileio/zip.rs b/crates/engine/src/cmd/fileio/zip.rsindex d3dcd7ea4..bed66a18c 100644--- a/crates/engine/src/cmd/fileio/zip.rs+++ b/crates/engine/src/cmd/fileio/zip.rs@@ -17,6 +17,8 @@ pub const FIXED_TIME: (u16, u16) = (0, DOS_DATE);const UTF8_NAMES: u16 = 1 << 11;/// Version needed to extract: 2.0.const VERSION: u16 = 20;+/// How many bytes of a file [`deflate`] compresses between two calls of its `stop`: 1 MiB.+pub const DEFLATE_CHUNK: usize = 1 << 20;/// The archive of `files` (`(name, bytes)`; `/` separates folders in a name), stored without/// compression. Fails past the limits of a ZIP without its 64-bit extension (65535 files, 4 GB).@@ -74,8 +76,9 @@ pub fn store<N: AsRef<str>, B: AsRef<[u8]>>(files: &[(N, B)]) -> Result<Vec<u8>,/// The archive of `files` (`(name, bytes)`; `/` separates folders in a name), each deflated, or/// stored when deflating doesn't make it smaller, every entry dated `(time, date)` (MS-DOS format).-/// Fails past the same limits as [`store`].-pub fn deflate<N: AsRef<str>, B: AsRef<[u8]>>(files: &[(N, B)], (time, date): (u16, u16)) -> Result<Vec<u8>, String> {+/// Fails past the same limits as [`store`]. `stop` is asked before each [`DEFLATE_CHUNK`] bytes are+/// deflated; when it answers true, the archive is dropped and an error returned.+pub fn deflate<N: AsRef<str>, B: AsRef<[u8]>>(files: &[(N, B)], (time, date): (u16, u16), stop: impl Fn() -> bool) -> Result<Vec<u8>, String> {let too_big = || "too much to zip: at most 65535 files and 4 GB".to_string();let (mut out, mut central) = (Vec::new(), Vec::new());for (name, bytes) in files {@@ -83,7 +86,12 @@ pub fn deflate<N: AsRef<str>, B: AsRef<[u8]>>(files: &[(N, B)], (time, date): (ulet mut crc = Crc::new();crc.update(bytes);let mut enc = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());- enc.write_all(bytes).map_err(|e| e.to_string())?;+ for chunk in bytes.chunks(DEFLATE_CHUNK) {+ if stop() {+ return Err("stopped before the archive was finished".into());+ }+ enc.write_all(chunk).map_err(|e| e.to_string())?;+ }let deflated = enc.finish().map_err(|e| e.to_string())?;let (method, data): (u16, &[u8]) = if deflated.len() < bytes.len() { (8, &deflated) } else { (0, bytes) };let offset = u32::try_from(out.len()).map_err(|_| too_big())?;diff --git a/crates/engine/src/cmd/package.rs b/crates/engine/src/cmd/package.rsindex e946dd2bb..b04fb4857 100644--- a/crates/engine/src/cmd/package.rs+++ b/crates/engine/src/cmd/package.rs@@ -551,7 +551,7 @@ fn dos_time() -> (u16, u16) {/// A zip archive of `files` ((path with `/` separators, bytes)), each deflated, or stored when/// that isn't smaller, every entry dated now.pub(crate) fn zip(files: &[(String, &[u8])]) -> Result<Vec<u8>> {- super::fileio::zip::deflate(files, dos_time()).map_err(|_| bad(C, "too large for a zip archive: package to a folder"))+ super::fileio::zip::deflate(files, dos_time(), || false).map_err(|_| bad(C, "too large for a zip archive: package to a folder"))}#[cfg(test)]