Auto: Protect recovery copies and honor committed UI state

Apply preview size only after confirmation, and keep canceled preview
values out of parameter capture. Resolve reserved graph names in fresh
packages. Publish recovery archives atomically under a folder lock and
prune complete copies with bounded memory.
This commit is contained in:
chasse20 committed 2026-11-18 20:00:54 +00:00
1 parent 25ed4f7e2d
commit dea0b0f6e2
8 files changed
+359 -34

No files matched your search

+5 -3
View File
@@ -95,7 +95,9 @@ fn new_graph(session: &mut Session, parameters: &J) -> Result<J> {
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<J> {
// 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| {
+24
View File
@@ -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", &parameters).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 });
}
}
+244 -28
View File
@@ -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<impl Iterator<Item = (u64, std::fs::DirEntry)>> {
fn copies(folder: &Path) -> io::Result<impl Iterator<Item = io::Result<(u64, OsString)>>> {
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<PathBuf> {
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<PathBuf> {
}
}
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<bool> {
// 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<bool> {
// 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| &copy < oldest) {
continue;
}
if has_recovery_footer(&folder.join(&copy.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");
}
}
+9 -1
View File
@@ -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<u64>,
}
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),
@@ -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));
}
+4 -1
View File
@@ -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)}));
}
@@ -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())
@@ -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();