diff --git a/crates/engine/src/file_cmds.rs b/crates/engine/src/file_cmds.rs index d676892..836b1ce 100644 --- a/crates/engine/src/file_cmds.rs +++ b/crates/engine/src/file_cmds.rs @@ -95,7 +95,9 @@ fn new_graph(session: &mut Session, parameters: &J) -> Result { crate::folder_path::require_graph_folder(folder)?; let base = crate::folder_path::name(&base)?; - let name = target.map_or_else(|| base.to_owned(), |package| crate::folder_path::unique(package, folder, base)); + let mut new_package = None; + let destination = target.unwrap_or_else(|| new_package.insert(Package::new("Untitled package"))); + let name = crate::folder_path::unique(destination, folder, base); let mut graph = if kind == materialcraft_core::GraphKind::Function { let mut graph = materialcraft_core::Graph::new(&name); @@ -112,8 +114,8 @@ fn new_graph(session: &mut Session, parameters: &J) -> Result { // Validate the graph before changing the active package if let Some(document) = target_document { session.activate_document(document)?; - } else if in_new_package || !session.has_package() { - session.open_package(Package::new("Untitled package"), None)?; + } else if let Some(package) = new_package { + session.open_package(package, None)?; } session.edit("New graph", |session| { diff --git a/crates/engine/tests/it/open_documents.rs b/crates/engine/tests/it/open_documents.rs index e6ed353..8343823 100644 --- a/crates/engine/tests/it/open_documents.rs +++ b/crates/engine/tests/it/open_documents.rs @@ -205,3 +205,27 @@ fn a_refused_graph_leaves_the_active_package_unchanged() { assert_eq!(session.document_id, destination); assert_eq!(session.graph().unwrap().name, "New graph"); } + +#[test] +fn a_new_package_resolves_reserved_graph_names() { + for new_package in [true, false] { + let mut session = Session::new(Package::new("Existing")); + let original = session.document_id; + if !new_package { + execute(&mut session, "package.close", &json!({})).unwrap(); + assert!(session.open_packages().is_empty()); + } + + let mut parameters = json!({"template": "empty", "name": "Resources"}); + if new_package { + parameters["newPackage"] = json!(true); + } + let reply = execute(&mut session, "file.new", ¶meters).unwrap(); + + assert_eq!(reply["name"], "Resources_1", "newPackage: {new_package}"); + assert_eq!(session.graph().unwrap().name, "Resources_1"); + assert!(session.pkg.folder_paths().contains("Resources")); + assert_ne!(session.document_id, original); + assert_eq!(session.open_packages().len(), if new_package { 2 } else { 1 }); + } +} diff --git a/crates/ui-egui/src/autosave_versions.rs b/crates/ui-egui/src/autosave_versions.rs index 9c0c4c5..54f20a3 100644 --- a/crates/ui-egui/src/autosave_versions.rs +++ b/crates/ui-egui/src/autosave_versions.rs @@ -1,6 +1,9 @@ //! Write numbered recovery copies and retain the newest copies for each document -use std::io::{self, ErrorKind}; +use std::collections::BTreeSet; +use std::ffi::OsString; +use std::fs::{File, OpenOptions}; +use std::io::{self, ErrorKind, Read, Seek, SeekFrom}; use std::path::{Path, PathBuf}; use craft_atomic::{NewFilePermissions, WriteOptions}; @@ -9,7 +12,7 @@ use materialcraft_engine::formats::project::ProjectFiles; use sha2::{Digest, Sha256}; const EXTENSION: &str = ".mcraft"; -const MAX_WRITE_ATTEMPTS: usize = 8; +const LOCK_FILE: &str = ".recovery.lock"; /// Saved documents share history by normalized path; untitled documents use workspace-local IDs pub(crate) fn folder(root: &Path, path: Option<&str>, workspace: u64, document: u64) -> PathBuf { @@ -20,17 +23,25 @@ pub(crate) fn folder(root: &Path, path: Option<&str>, workspace: u64, document: root.join(key) } -fn copies(folder: &Path) -> io::Result> { +fn copies(folder: &Path) -> io::Result>> { Ok(std::fs::read_dir(folder)?.filter_map(|entry| { - let entry = entry.ok()?; + let entry = match entry { + Ok(entry) => entry, + Err(error) => return Some(Err(error)), + }; + let filename = entry.file_name(); let number = filename.to_str()?.strip_suffix(EXTENSION)?.parse().ok()?; - entry.file_type().ok()?.is_file().then_some((number, entry)) + match entry.file_type() { + Ok(kind) if kind.is_file() => Some(Ok((number, filename))), + Ok(_) => None, + Err(error) => Some(Err(error)), + } })) } fn next_path(folder: &Path) -> io::Result { - let mut version = copies(folder)?.map(|(number, _)| number).max().unwrap_or(0); + let mut version = copies(folder)?.try_fold(0, |latest, copy| copy.map(|(number, _)| latest.max(number)))?; loop { version = version.checked_add(1).ok_or_else(|| io::Error::other("autosave versions exhausted"))?; let path = folder.join(format!("{version}{EXTENSION}")); @@ -44,39 +55,135 @@ fn next_path(folder: &Path) -> io::Result { } } -fn prune(folder: &Path, keep: u32) -> io::Result<()> { - let mut copies: Vec<_> = copies(folder)?.collect(); - copies.sort_unstable_by_key(|(number, _)| *number); - let surplus = copies.len().saturating_sub(keep.max(1) as usize); +fn has_recovery_footer(path: &Path) -> io::Result { + // The recovery writer emits uncommented ZIP32 and ZIP64 end records + const ZIP_FOOTER_BYTES: usize = 22; + const ZIP64_FOOTER_BYTES: usize = 56; + const ZIP64_LOCATOR_BYTES: usize = 20; + let mut footer = [0; ZIP_FOOTER_BYTES]; + let mut file = File::open(path)?; + if file.metadata()?.len() < ZIP_FOOTER_BYTES as u64 { + return Ok(false); + } - for (_, entry) in copies.into_iter().take(surplus) { - match std::fs::remove_file(entry.path()) { - Err(error) if error.kind() == ErrorKind::NotFound => {} - result => result?, + let footer_offset = file.seek(SeekFrom::End(-(ZIP_FOOTER_BYTES as i64)))?; + file.read_exact(&mut footer)?; + if !footer.starts_with(b"PK\x05\x06") || !footer.ends_with(&[0, 0]) { + return Ok(false); + } + + let directory_size = u64::from(u32::from_le_bytes(footer[12..16].try_into().unwrap_or_default())); + let directory_offset = u64::from(u32::from_le_bytes(footer[16..20].try_into().unwrap_or_default())); + if directory_matches(&mut file, directory_offset, directory_size, footer_offset)? { + return Ok(true); + } + + let Some(zip64_offset) = footer_offset.checked_sub((ZIP64_FOOTER_BYTES + ZIP64_LOCATOR_BYTES) as u64) else { + return Ok(false); + }; + + let mut zip64_footer = [0; ZIP64_FOOTER_BYTES]; + let mut locator = [0; ZIP64_LOCATOR_BYTES]; + file.seek(SeekFrom::Start(zip64_offset))?; + file.read_exact(&mut zip64_footer)?; + file.read_exact(&mut locator)?; + if !zip64_footer.starts_with(b"PK\x06\x06") || !locator.starts_with(b"PK\x06\x07") || locator[8..16] != zip64_offset.to_le_bytes() { + return Ok(false); + } + + let directory_size = u64::from_le_bytes(zip64_footer[40..48].try_into().unwrap_or_default()); + let directory_offset = u64::from_le_bytes(zip64_footer[48..56].try_into().unwrap_or_default()); + directory_matches(&mut file, directory_offset, directory_size, zip64_offset) +} + +fn directory_matches(file: &mut File, offset: u64, size: u64, end: u64) -> io::Result { + // A nested ZIP in a torn copy can have a footer without pointing at the outer directory + let mut signature = [0; 4]; + if size < signature.len() as u64 || offset.checked_add(size) != Some(end) { + return Ok(false); + } + + file.seek(SeekFrom::Start(offset))?; + file.read_exact(&mut signature)?; + Ok(&signature == b"PK\x01\x02") +} + +fn prune(folder: &Path, keep: u32, mut remove: impl FnMut(&Path) -> io::Result<()>) -> io::Result<()> { + let keep = keep.clamp(1, crate::state::Prefs::MAX_AUTOSAVE_VERSIONS) as usize; + let mut newest = BTreeSet::new(); + + // Retain only the newest candidates before deleting anything + for copy in copies(folder)? { + let copy = copy?; + if newest.len() == keep && newest.first().is_some_and(|oldest| © < oldest) { + continue; + } + + if has_recovery_footer(&folder.join(©.1))? { + newest.insert(copy); + if newest.len() > keep { + newest.pop_first(); + } } } - Ok(()) + + if newest.len() < keep { + return Ok(()); + } + + let Some(oldest) = newest.into_iter().next() else { + return Ok(()); + }; + + // A second scan lets even an oversized folder be pruned with bounded storage + let mut first_error = None; + for copy in copies(folder)? { + let result = copy.and_then(|copy| { + if copy < oldest { + let path = folder.join(copy.1); + if has_recovery_footer(&path)? { + return remove(&path); + } + } + + Ok(()) + }); + if let Err(error) = result + && error.kind() != ErrorKind::NotFound + { + first_error.get_or_insert(error); + } + } + + first_error.map_or(Ok(()), Err) } pub(crate) fn save(folder: &Path, package: &Package, keep: u32) -> io::Result<()> { - std::fs::create_dir_all(folder)?; let files = ProjectFiles::build(package, "autosave.mcraft", true).map_err(io::Error::other)?; - let options = WriteOptions::default().with_new_file_permissions(NewFilePermissions::Private); + save_with(folder, keep, |file| files.write_zip(file).map(|_| ()).map_err(io::Error::other)) +} - for _ in 0..MAX_WRITE_ATTEMPTS { - let path = next_path(folder)?; - match options.write_new_with(&path, |file| files.write_zip(file).map(|_| ()).map_err(io::Error::other)) { - Ok(()) => return prune(folder, keep), - Err(error) if error.kind() == ErrorKind::AlreadyExists => continue, - Err(error) => return Err(error), - } - } - Err(io::Error::other("autosave version could not be reserved")) +fn save_with(folder: &Path, keep: u32, write: impl FnOnce(&mut File) -> io::Result<()>) -> io::Result<()> { + std::fs::create_dir_all(folder)?; + + // Keep the lock file in place so concurrent processes lock the same file + let lock = OpenOptions::new().read(true).write(true).create(true).truncate(false).open(folder.join(LOCK_FILE))?; + lock.lock()?; + + let path = next_path(folder)?; + + // Publish by rename so the numbered file is never visible during copying + let options = WriteOptions::default().with_new_file_permissions(NewFilePermissions::Private); + options.atomic_write_with(&path, write)?; + prune(folder, keep, |path| std::fs::remove_file(path)) } #[cfg(test)] mod tests { use super::*; + use std::io::Write; + use std::process::Command; + use std::time::{Duration, Instant}; #[test] fn retention_keeps_distinct_packages_and_ignores_directories() { @@ -138,12 +245,121 @@ mod tests { }); let mut names = Vec::new(); - for (_, entry) in copies(folder).unwrap() { - let archive = std::fs::read(entry.path()).unwrap(); + for copy in copies(folder).unwrap() { + let (_, filename) = copy.unwrap(); + let archive = std::fs::read(folder.join(filename)).unwrap(); names.push(materialcraft_engine::formats::project::read(&archive, "autosave.mcraft").unwrap().pkg.graphs[0].name.clone()); } names.sort_unstable(); assert_eq!(names, ["Graph 0", "Graph 1", "Graph 2", "Graph 3"]); } + + #[test] + fn a_truncated_legacy_copy_does_not_displace_a_complete_version() { + let root = tempfile::tempdir().unwrap(); + let package = Package::new("Wood"); + save(root.path(), &package, 2).unwrap(); + let first = root.path().join("1.mcraft"); + let archive = std::fs::read(&first).unwrap(); + let incomplete = root.path().join("2.mcraft"); + std::fs::write(&incomplete, &archive[..archive.len() / 2]).unwrap(); + let embedded = root.path().join("3.mcraft"); + std::fs::write(&embedded, [&archive[..archive.len() / 2], &archive].concat()).unwrap(); + + save(root.path(), &package, 2).unwrap(); + + assert_eq!(std::fs::read(first).unwrap(), archive); + assert!(incomplete.is_file()); + assert!(embedded.is_file()); + let latest = std::fs::read(root.path().join("4.mcraft")).unwrap(); + assert!(materialcraft_engine::formats::project::read(&latest, "autosave.mcraft").is_ok()); + } + + #[test] + fn zip64_end_records_are_accepted() { + let root = tempfile::tempdir().unwrap(); + let path = root.path().join("1.mcraft"); + let mut writer = zip::ZipWriter::new(File::create(&path).unwrap()); + writer.set_zip64_comment(Some("")); + writer.start_file("package.sbs", zip::write::SimpleFileOptions::default()).unwrap(); + writer.finish().unwrap(); + + assert!(has_recovery_footer(&path).unwrap()); + } + + #[test] + fn pruning_continues_after_a_deletion_error() { + let root = tempfile::tempdir().unwrap(); + let package = Package::new("Wood"); + for _ in 0..4 { + save(root.path(), &package, 4).unwrap(); + } + + let error = prune(root.path(), 1, |path| { + if path.ends_with("1.mcraft") { + return Err(io::Error::new(ErrorKind::PermissionDenied, "injected deletion denial")); + } + + std::fs::remove_file(path) + }) + .unwrap_err(); + + assert_eq!(error.kind(), ErrorKind::PermissionDenied); + assert!(root.path().join("1.mcraft").is_file()); + assert!(!root.path().join("2.mcraft").exists()); + assert!(!root.path().join("3.mcraft").exists()); + assert!(root.path().join("4.mcraft").is_file()); + } + + #[test] + fn overlapping_processes_keep_one_complete_copy_when_a_write_fails() { + const CHILD_FOLDER: &str = "MATERIALCRAFT_AUTOSAVE_TEST_CHILD_FOLDER"; + const LOCK_CHECKED: &str = "lock-checked"; + const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(5); + if let Some(folder) = std::env::var_os(CHILD_FOLDER) { + let folder = PathBuf::from(folder); + let lock = OpenOptions::new().read(true).write(true).open(folder.join(LOCK_FILE)).unwrap(); + assert!(matches!(lock.try_lock(), Err(std::fs::TryLockError::WouldBlock))); + std::fs::write(folder.join(LOCK_CHECKED), []).unwrap(); + save(&folder, &Package::new("New"), 1).unwrap(); + return; + } + + let root = tempfile::tempdir().unwrap(); + let folder = root.path(); + save(folder, &Package::new("Original"), 1).unwrap(); + let first = folder.join("1.mcraft"); + let second = folder.join("2.mcraft"); + let mut child = None; + + let result = save_with(folder, 1, |file| { + file.write_all(b"partial archive")?; + let process = child.insert( + Command::new(std::env::current_exe()?) + .args(["--exact", "autosave_versions::tests::overlapping_processes_keep_one_complete_copy_when_a_write_fails"]) + .env(CHILD_FOLDER, folder) + .spawn()?, + ); + let deadline = Instant::now() + HANDSHAKE_TIMEOUT; + while !folder.join(LOCK_CHECKED).exists() { + if process.try_wait()?.is_some() || Instant::now() >= deadline { + return Err(io::Error::other("overlapping writer did not confirm lock contention")); + } + + std::thread::sleep(Duration::from_millis(5)); + } + + assert!(first.is_file()); + assert!(!second.exists()); + Err(io::Error::new(ErrorKind::WriteZero, "injected interrupted write")) + }); + + let child_status = child.unwrap().wait().unwrap(); + assert_eq!(result.unwrap_err().kind(), ErrorKind::WriteZero); + assert!(child_status.success()); + assert!(!first.exists()); + let archive = std::fs::read(second).unwrap(); + assert_eq!(materialcraft_engine::formats::project::read(&archive, "autosave.mcraft").unwrap().pkg.name, "New"); + } } diff --git a/crates/ui-egui/src/cook.rs b/crates/ui-egui/src/cook.rs index 852a3fd..edea431 100644 --- a/crates/ui-egui/src/cook.rs +++ b/crates/ui-egui/src/cook.rs @@ -65,6 +65,8 @@ pub struct Cooker { pub suspended: bool, /// Tools ▸ Cancel rendering stopped the running cook: it does not start again until the next edit stopped_by_user: bool, + /// The retained preview cannot supply parameter values at this epoch + cancelled_preview_epoch: Option, } impl Cooker { @@ -81,6 +83,10 @@ impl Cooker { } } +pub(crate) fn preview_ready(app: &MaterialCraftApp) -> bool { + !app.session.dirty && !app.cooker.busy() && app.cooker.cancelled_preview_epoch != Some(app.session.cook_epoch) +} + /// Tools ▸ Cancel rendering: stop the running cook; the next edit cooks again pub fn cancel(app: &mut MaterialCraftApp) { if !app.cooker.busy() { @@ -89,6 +95,7 @@ pub fn cancel(app: &mut MaterialCraftApp) { app.cooker.stop(); app.cooker.stopped_by_user = true; + app.cooker.cancelled_preview_epoch = Some(app.session.cook_epoch); app.session.dirty = false; } @@ -124,8 +131,9 @@ pub fn drive(app: &mut MaterialCraftApp, ctx: &egui::Context) { } } Ok(c) => { - if !app.cooker.suspended && !app.session.dirty && app.cooker.epoch == app.session.cook_epoch { + if !app.cooker.suspended && !app.session.dirty && app.cooker.epoch == app.session.cook_epoch && c.graph == app.session.graph { app.session.accept_preview(c); + app.cooker.cancelled_preview_epoch = None; } } Err(msg) if !app.cooker.suspended && !app.session.dirty && app.cooker.epoch == app.session.cook_epoch => report_failure(app, msg), diff --git a/crates/ui-egui/src/cook_cancellation.test.rs b/crates/ui-egui/src/cook_cancellation.test.rs index 906c5ed..736655c 100644 --- a/crates/ui-egui/src/cook_cancellation.test.rs +++ b/crates/ui-egui/src/cook_cancellation.test.rs @@ -68,3 +68,51 @@ fn cancelling_without_a_worker_keeps_pending_work() { assert!(app.session.dirty); } + +#[test] +fn cancelled_preview_is_unavailable_for_parameter_capture_until_recooked() { + use materialcraft_engine::core::{FunctionGraph, NodeId, Value}; + use serde_json::json; + + let mut app = MaterialCraftApp::headless(materialcraft_engine::new_session(), crate::UiState::default()); + app.session.preview_size = Some(64); + let owner = NodeId(app.run("graph.node.add", json!({"def": "blur"})).unwrap()["id"].as_u64().unwrap()); + let set_intensity = |app: &mut MaterialCraftApp, value| { + let function = FunctionGraph::constant(Value::Float(value)); + app.run("graph.node.function", json!({"id": owner, "param": "intensity", "function": function})).unwrap(); + }; + let intensity = |app: &MaterialCraftApp| app.session.cooked.nodes[&owner].parameters["intensity"].clone(); + let ctx = egui::Context::default(); + set_intensity(&mut app, 0.2); + app.session.cook(); + assert!(preview_ready(&app)); + assert_eq!(intensity(&app), Value::Float(0.2)); + + set_intensity(&mut app, 0.8); + let (sender, receiver) = mpsc::channel(); + app.cooker.rx = Some(receiver); + app.cooker.epoch = app.session.cook_epoch; + app.session.dirty = false; + cancel(&mut app); + drop(sender); + drive(&mut app, &ctx); + + assert_eq!(intensity(&app), Value::Float(0.2)); + assert!(!app.session.dirty && !app.cooker.busy()); + assert!(!preview_ready(&app), "the retained value must not be offered for capture"); + + drive(&mut app, &ctx); + assert!(!app.cooker.busy()); + app.session.dirty = true; + drive(&mut app, &ctx); + for _ in 0..2000 { + if !app.cooker.busy() { + break; + } + std::thread::sleep(std::time::Duration::from_millis(5)); + drive(&mut app, &ctx); + } + + assert!(preview_ready(&app)); + assert_eq!(intensity(&app), Value::Float(0.8)); +} diff --git a/crates/ui-egui/src/material_craft_app.rs b/crates/ui-egui/src/material_craft_app.rs index 28bba14..5c83ab6 100644 --- a/crates/ui-egui/src/material_craft_app.rs +++ b/crates/ui-egui/src/material_craft_app.rs @@ -186,7 +186,10 @@ impl MaterialCraftApp { self.session.default_view3d = default_view; } - let preview_size = if self.ui.prefs.preview_size == 0 { None } else { Some(self.ui.prefs.preview_size.clamp(64, 8192)) }; + let preview_size = match self.ui.committed_prefs().preview_size { + 0 => None, + size => Some(size.clamp(64, 8192)), + }; if self.session.preview_size != preview_size { let _ = materialcraft_engine::execute(&mut self.session, "view.previewSize", &serde_json::json!({"size": preview_size.unwrap_or(0)})); } diff --git a/crates/ui-egui/src/property/parameter_control.rs b/crates/ui-egui/src/property/parameter_control.rs index a31ddc4..2efbb65 100644 --- a/crates/ui-egui/src/property/parameter_control.rs +++ b/crates/ui-egui/src/property/parameter_control.rs @@ -25,7 +25,7 @@ pub(super) fn show( .filter(|identifier| app.session.graph().is_ok_and(|graph| graph.exposed.iter().any(|input| input.id == *identifier))) .or_else(|| base.is_none().then(|| node.bindings.get(&descriptor.id).map(String::as_str)).flatten()); let driven = function.is_some() || bound.is_some(); - let evaluated = (!app.session.dirty && !app.cooker.busy()) + let evaluated = crate::cook::preview_ready(app) .then(|| app.session.cooked.nodes.get(&node.id)) .flatten() .filter(|result| result.error.is_none()) diff --git a/crates/ui-egui/tests/it/preferences_window.rs b/crates/ui-egui/tests/it/preferences_window.rs index 2510f34..9636281 100644 --- a/crates/ui-egui/tests/it/preferences_window.rs +++ b/crates/ui-egui/tests/it/preferences_window.rs @@ -86,6 +86,30 @@ fn draft_limits_preserve_recents_and_undo_until_applied() { assert_eq!(harness.state().ui.recent, ["third.sbs"]); } +#[test] +fn draft_preview_size_reaches_the_session_only_on_apply_or_ok() { + let mut harness = harness(); + let initial = harness.state().session.preview_size; + open(&mut harness); + harness.state_mut().ui.prefs.preview_size = 64; + harness.run_steps(2); + + assert_eq!(harness.state().session.preview_size, initial); + click(&mut harness, Role::Button, "Cancel"); + assert_eq!(harness.state().session.preview_size, initial); + + open(&mut harness); + harness.state_mut().ui.prefs.preview_size = 1; + click(&mut harness, Role::Button, "Apply"); + assert_eq!(harness.state().session.preview_size, Some(64)); + + harness.state_mut().ui.prefs.preview_size = 0; + harness.run_steps(2); + assert_eq!(harness.state().session.preview_size, Some(64)); + click(&mut harness, Role::Button, "OK"); + assert_eq!(harness.state().session.preview_size, None); +} + #[test] fn a_shortcut_is_captured_refused_when_taken_and_adds_its_node_over_the_graph() { let mut harness = harness();