856f865cf98d
autosave.rs
//! Background autosave and crash recovery.
use crate::common;
use std::sync::Arc;
use common::*;
use photocraft_color::{ColorMode, SampleType};
use photocraft_doc::{DocId, Document};
use photocraft_format::*;
#[test]
fn autosave_then_recover() {
let dir = temp_dir("recovery");
let doc = Arc::new(rich_doc(ColorMode::Rgb, SampleType::U16));
let saver = Autosaver::new(&dir, "doc-1");
saver.request(doc.clone(), 7, Some("/work/a.pcraft".into()), SaveOptions::default());
let r = saver.flush().expect("a save ran");
let stats = r.unwrap();
assert!(stats.tiles_written > 0);
let entries = list_recovery(&dir);
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].info.revision, 7);
assert_eq!(entries[0].info.original_path.as_deref(), Some("/work/a.pcraft"));
assert_eq!(entries[0].info.document_name, "Rich");
assert_eq!(recover(&entries[0]).unwrap(), *doc);
discard_recovery(&dir, &entries[0]).unwrap();
assert!(list_recovery(&dir).is_empty());
std::fs::remove_dir_all(dir).unwrap();
}
/// A recovered document opened from a multi-frame GIF comes back at its original path with its
/// frame count, so File › Save still goes through Save As rather than writing one frame over
/// the animation (#5733).
#[test]
fn recovery_keeps_the_source_image_count() {
let dir = temp_dir("recovery-source-images");
let mut doc = rich_doc(ColorMode::Rgb, SampleType::U8);
doc.file_encoding.source_images = Some(4);
let saver = Autosaver::new(&dir, "gif-1");
saver.request(Arc::new(doc), 1, Some("/work/anim.gif".into()), SaveOptions::default());
saver.flush().expect("a save ran").unwrap();
let entries = list_recovery(&dir);
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].info.original_path.as_deref(), Some("/work/anim.gif"));
assert_eq!(recover(&entries[0]).unwrap().file_encoding.source_images, Some(4));
std::fs::remove_dir_all(dir).unwrap();
}
/// A queued snapshot can fail later; callers must observe and retry that revision.
#[test]
fn background_save_outcomes_report_failure_then_recovery() {
let root = temp_dir("retry-failed-write");
let blocked = root.join("recovery");
std::fs::write(&blocked, b"not a directory").unwrap();
// Not dropped on a failure: dropping joins the worker, which waits for a write in progress,
// so a stuck write would hold the test past its own bound until nextest kills it.
let saver = std::mem::ManuallyDrop::new(Autosaver::new(&blocked, "doc"));
let doc = Arc::new(rich_doc(ColorMode::Rgb, SampleType::U8));
saver.request_checked(doc.clone(), 7, None, SaveOptions::default()).unwrap();
// The bound only turns a worker that never reports into a failure instead of a hang. A real
// write flushes every tile to disk and took over 30 s on a busy Windows CI runner (normally
// 2-3 s), so it is generous, and still under the 10 minutes after which nextest's `ci`
// profile kills a test.
const PATIENCE: std::time::Duration = std::time::Duration::from_secs(5 * 60);
let receive = |saver: &Autosaver| {
let deadline = std::time::Instant::now() + PATIENCE;
while std::time::Instant::now() < deadline {
if let Some(outcome) = saver.take_completed().into_iter().next() {
return outcome;
}
std::thread::sleep(std::time::Duration::from_millis(10));
}
panic!("autosave worker did not report its completed write within {PATIENCE:?}");
};
let (revision, result) = receive(&saver);
assert_eq!(revision, 7);
assert!(result.is_err(), "the recovery location is not a directory");
std::fs::remove_file(&blocked).unwrap();
std::fs::create_dir(&blocked).unwrap();
saver.request_checked(doc.clone(), 7, None, SaveOptions::default()).unwrap();
let (revision, result) = receive(&saver);
assert_eq!(revision, 7);
result.unwrap();
assert_eq!(list_recovery(&blocked).len(), 1);
assert_eq!(recover(&list_recovery(&blocked)[0]).unwrap(), *doc);
drop(std::mem::ManuallyDrop::into_inner(saver));
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn repeated_autosaves_are_incremental_and_coalesced() {
let dir = temp_dir("coalesce");
let saver = Autosaver::new(&dir, "k");
let mut doc = rich_doc(ColorMode::Rgb, SampleType::U8);
for i in 0..5 {
let id = doc.layers[1].id;
doc.layer_mut(id).unwrap().surface_mut().unwrap().write_pixel(i, 0, &[1.0, 0.0, 0.0, 1.0]);
saver.request(Arc::new(doc.clone()), i as u64, None, SaveOptions::default());
}
saver.flush().unwrap().unwrap();
let e = list_recovery(&dir);
assert_eq!(e[0].info.revision, 4, "newest snapshot wins");
assert_eq!(recover(&e[0]).unwrap(), doc);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn discard_removes_everything() {
let dir = temp_dir("discard");
let saver = Autosaver::new(&dir, "x y/z");
saver.request(Arc::new(rich_doc(ColorMode::Grayscale, SampleType::U8)), 1, None, SaveOptions::default());
let path = saver.bundle_path();
assert!(path.file_name().unwrap().to_string_lossy().starts_with("x_y_z"));
saver.discard().unwrap();
assert!(list_recovery(&dir).is_empty());
assert!(!path.exists());
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn list_ignores_junk() {
let dir = temp_dir("junk");
std::fs::write(dir.join("bogus.json"), b"{}").unwrap();
std::fs::write(dir.join("other.txt"), b"x").unwrap();
assert!(list_recovery(&dir).is_empty());
assert!(list_recovery(&dir.join("missing")).is_empty());
std::fs::remove_dir_all(dir).unwrap();
}
/// `doc` as document `id` with pixel (x, 0) of its paint layer set, so versions are told apart.
fn edit(mut doc: Document, id: u64, x: i32) -> Document {
doc.id = DocId(id);
let layer = doc.layers[1].id;
doc.layer_mut(layer).unwrap().surface_mut().unwrap().write_pixel(x, 0, &[1.0, 0.0, 0.0, 1.0]);
doc
}
fn version(id: u64, x: i32, mode: ColorMode) -> Document {
edit(rich_doc(mode, SampleType::U8), id, x)
}
/// Save one snapshot under `key` and wait for it.
fn save_once(dir: &std::path::Path, key: &str, doc: Document) {
let saver = Autosaver::new(dir, key);
saver.request(Arc::new(doc), 1, None, SaveOptions::default());
saver.flush().unwrap().unwrap();
}
/// The recovered documents by entry key, ids cleared (they're reassigned on open).
fn recovered(store: &RecoveryStore) -> std::collections::BTreeMap<String, Document> {
store
.recover()
.into_iter()
.map(|(e, mut doc)| {
doc.id = DocId(0);
(e.info.key, doc)
})
.collect()
}
fn same(mut doc: Document) -> Document {
doc.id = DocId(0);
doc
}
#[test]
fn recovered_entries_survive_a_second_crash_until_saved_or_closed() {
let dir = temp_dir("second-crash");
let (a, b) = (version(1, 3, ColorMode::Rgb), version(2, 5, ColorMode::Grayscale));
// Launch 1 autosaves two unsaved documents, then crashes (dropping waits for the writes).
{
let mut launch = RecoveryStore::new(&dir);
launch.autosave(&Arc::new(a.clone()), 4, None);
launch.autosave(&Arc::new(b.clone()), 6, Some("/work/b.pcraft".into()));
}
assert_eq!(list_recovery(&dir).len(), 2);
// Launch 2 recovers both and crashes before its first autosave: nothing may be lost.
let keys: Vec<String> = {
let mut launch = RecoveryStore::new(&dir);
let docs = recovered(&launch);
assert_eq!(docs.len(), 2);
assert_eq!(list_recovery(&dir).len(), 2, "recovering must not delete the entries");
for (i, key) in docs.keys().enumerate() {
launch.adopt(10 + i as u64, key);
}
docs.into_keys().collect()
};
// Launch 3 still has both, pixels intact; one is edited and autosaved, the other closed.
let edited = edit(a.clone(), 20, 9);
{
let mut launch = RecoveryStore::new(&dir);
let docs = recovered(&launch);
assert_eq!(docs.values().cloned().collect::<Vec<_>>(), vec![same(a.clone()), same(b.clone())]);
launch.adopt(20, &keys[0]);
launch.adopt(21, &keys[1]);
launch.autosave(&Arc::new(edited.clone()), 9, None);
launch.discard(21).unwrap();
assert_eq!(list_recovery(&dir).len(), 1, "closing removes the adopted entry");
}
// The autosave replaced the adopted entry in place: no duplicate, newest content.
let entries = list_recovery(&dir);
assert_eq!(entries.len(), 1);
assert_eq!((entries[0].info.key.as_str(), entries[0].info.revision), (keys[0].as_str(), 9));
// Launch 4 recovers it once more and saves it: the entry goes.
let mut launch = RecoveryStore::new(&dir);
assert_eq!(recovered(&launch).into_values().collect::<Vec<_>>(), vec![same(edited)]);
launch.adopt(30, &keys[0]);
launch.discard(30).unwrap();
assert!(list_recovery(&dir).is_empty());
drop(launch);
std::fs::remove_dir_all(dir).unwrap();
}
/// #3438: a session about to end without asking (its window's graphics device was lost) writes
/// everything queued before it returns, so the next launch recovers it.
#[test]
fn flush_writes_every_queued_autosave_before_returning() {
let dir = temp_dir("flush");
let (a, b) = (version(1, 3, ColorMode::Rgb), version(2, 5, ColorMode::Grayscale));
let mut store = RecoveryStore::new(&dir);
store.autosave_checked(&Arc::new(a.clone()), 4, None).unwrap();
store.autosave_checked(&Arc::new(b.clone()), 6, Some("/work/b.pcraft".into())).unwrap();
let mut done = store.flush();
done.sort_by_key(|(id, ..)| *id);
assert_eq!(done, vec![(1, 4, Ok(())), (2, 6, Ok(()))]);
// On disk while the store is still alive, not only once it is dropped.
let docs = recovered(&RecoveryStore::new(&dir));
assert_eq!(docs.len(), 2);
assert!(docs.values().any(|d| *d == same(a.clone())) && docs.values().any(|d| *d == same(b.clone())));
// A later autosave (trying a failed write again) starts a new worker on the same entry.
let newer = version(1, 4, ColorMode::Rgb);
store.autosave_checked(&Arc::new(newer.clone()), 5, None).unwrap();
assert_eq!(store.flush(), vec![(1, 5, Ok(()))]);
let docs = recovered(&RecoveryStore::new(&dir));
assert_eq!(docs.len(), 2, "the same entry, not a new one");
assert!(docs.values().any(|d| *d == same(newer.clone())) && !docs.values().any(|d| *d == same(a.clone())));
drop(store);
std::fs::remove_dir_all(dir).unwrap();
}
/// #6464 review: a document saved or closed after a flush (the app stayed open because a recovery
/// write failed) still has its entry removed, so it doesn't come back at the next launch.
#[test]
fn discard_after_flush_removes_the_entry() {
let dir = temp_dir("discard-after-flush");
let mut store = RecoveryStore::new(&dir);
store.autosave_checked(&Arc::new(version(1, 3, ColorMode::Rgb)), 4, None).unwrap();
assert_eq!(store.flush(), vec![(1, 4, Ok(()))]);
assert_eq!(list_recovery(&dir).len(), 1);
store.discard(1).unwrap();
assert!(list_recovery(&dir).is_empty(), "the flushed document's entry is gone");
// And after a retry wrote the entry again through a new worker.
store.autosave_checked(&Arc::new(version(2, 5, ColorMode::Rgb)), 6, None).unwrap();
store.flush();
store.autosave_checked(&Arc::new(version(2, 6, ColorMode::Rgb)), 7, None).unwrap();
store.flush();
assert_eq!(list_recovery(&dir).len(), 1, "one entry per document");
store.discard(2).unwrap();
assert!(list_recovery(&dir).is_empty());
drop(store);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn new_documents_never_overwrite_surviving_entries() {
let dir = temp_dir("collision");
// An earlier launch (including builds that keyed entries by bare document id) left `doc-1`.
let old = version(1, 3, ColorMode::Rgb);
save_once(&dir, "doc-1", old.clone());
// A store from another launch left an entry for its own document 1 too.
let other = version(1, 6, ColorMode::Grayscale);
RecoveryStore::new(&dir).autosave(&Arc::new(other.clone()), 2, None);
assert_eq!(list_recovery(&dir).len(), 2);
// This launch adopts `doc-1` for its document 5, and its own new document 1 autosaves.
let fresh = version(1, 8, ColorMode::Rgb);
{
let mut launch = RecoveryStore::new(&dir);
launch.adopt(5, "doc-1");
launch.autosave(&Arc::new(fresh.clone()), 3, None);
}
let docs = recovered(&RecoveryStore::new(&dir));
assert_eq!(docs.len(), 3, "the new document got an entry of its own");
assert_eq!(docs.get("doc-1"), Some(&same(old)), "the adopted entry is untouched");
assert!(docs.values().any(|d| *d == same(other.clone())));
assert!(docs.values().any(|d| *d == same(fresh.clone())));
// Closing the new document removes only its own entry.
let mut launch = RecoveryStore::new(&dir);
launch.adopt(5, "doc-1");
launch.autosave(&Arc::new(fresh), 3, None);
launch.discard(1).unwrap();
assert_eq!(list_recovery(&dir).len(), 3);
launch.discard(5).unwrap();
assert_eq!(list_recovery(&dir).len(), 2);
drop(launch);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn sidecars_cannot_point_at_other_bundles() {
let dir = temp_dir("sidecar-key");
let inner = dir.join("Recovery");
save_once(&dir, "outside", rich_doc(ColorMode::Rgb, SampleType::U8));
save_once(&inner, "k", rich_doc(ColorMode::Rgb, SampleType::U8));
let info = std::fs::read_to_string(inner.join("k.json")).unwrap();
// A copied sidecar (its name isn't its key) and one whose key leaves the directory.
std::fs::write(inner.join("copy.json"), &info).unwrap();
std::fs::write(inner.join("escape.json"), info.replace("\"k\"", "\"../outside\"")).unwrap();
let entries = list_recovery(&inner);
assert_eq!(entries.iter().map(|e| e.info.key.as_str()).collect::<Vec<_>>(), ["k"]);
std::fs::remove_dir_all(dir).unwrap();
}
/// Once the manifest is committed the save has succeeded: an unreferenced object that cannot be
/// removed (here a folder squatting on a tile name, like a locked or vanished file) must not turn
/// the directory save (autosave's path) into a reported failure.
#[test]
fn failed_cleanup_after_commit_does_not_fail_the_save() {
let dir = temp_dir("cleanup-best-effort").join("doc.pcraft");
std::fs::create_dir_all(&dir).unwrap();
let doc = rich_doc(ColorMode::Rgb, SampleType::U8);
let mut w = PcraftWriter::new();
w.save_dir(&doc, &dir, &SaveOptions::default()).unwrap();
let stuck = dir.join("tiles").join("0000000000000000000000000000000000000000000000000000000000000000.zst");
std::fs::create_dir_all(stuck.join("inner")).unwrap();
let stats = w.save_dir(&doc, &dir, &SaveOptions::default()).expect("the committed save reports success");
assert_eq!(stats.objects_removed, 0, "nothing was actually removed");
assert_eq!(load_path(&dir).unwrap(), doc);
std::fs::remove_dir_all(dir.parent().unwrap()).unwrap();
}
/// #9034: while a document's autosave replaces its entry, a listing (another launch's recovery
/// prompt, or the launch's own check after closing a second document) sees that entry exactly
/// once. On Windows the sidecar used to be replaced through `ReplaceFileW`, which moves the old
/// sidecar to a backup name before moving the new one in: a listing in between found the bundle
/// without a sidecar and listed it a second time (or, the other way round, not at all).
#[test]
fn a_listing_during_an_autosave_sees_the_entry_exactly_once() {
let dir = temp_dir("listing-during-autosave");
let doc = Document::new("Busy", photocraft_doc::Size { width: 4, height: 4 }, ColorMode::Rgb, SampleType::U8);
save_once(&dir, "busy", doc.clone());
let done = Arc::new(std::sync::atomic::AtomicBool::new(false));
let writer = {
let (dir, done) = (dir.clone(), done.clone());
std::thread::spawn(move || {
// Sets `done` however the thread ends, so a failing writer stops the listing loop
// and `join` reports its panic instead of the test hanging.
struct SetOnDrop(Arc<std::sync::atomic::AtomicBool>);
impl Drop for SetOnDrop {
fn drop(&mut self) {
self.0.store(true, std::sync::atomic::Ordering::SeqCst);
}
}
let _done = SetOnDrop(done);
let saver = Autosaver::new(&dir, "busy");
for revision in 2..=200 {
saver.request(Arc::new(doc.clone()), revision, None, SaveOptions::default());
// Wait for this write, so every revision replaces the sidecar once.
let completed = loop {
let completed = saver.take_completed();
if !completed.is_empty() {
break completed;
}
std::thread::yield_now();
};
assert!(completed.iter().all(|(_, result)| result.is_ok()), "revision {revision}: {completed:?}");
}
saver.flush()
})
};
let mut listings = 0u32;
while !done.load(std::sync::atomic::Ordering::SeqCst) {
let entries = list_recovery(&dir);
let keys: Vec<&str> = entries.iter().map(|e| e.info.key.as_str()).collect();
assert_eq!(keys, ["busy"], "listing {listings} during an autosave: {entries:?}");
listings += 1;
}
assert!(writer.join().unwrap().is_some_and(|r| r.is_ok()));
assert!(listings > 0);
std::fs::remove_dir_all(dir).unwrap();
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.