EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Fix #1231: keep autosave completion tied to its originating project (#1330)
Moein Saharkhiz8e59ccdb3a60
diff --git a/crates/engine/src/autosave.rs b/crates/engine/src/autosave.rsindex e1c56ef26..37127ac56 100644--- a/crates/engine/src/autosave.rs+++ b/crates/engine/src/autosave.rs@@ -47,6 +47,11 @@ pub struct AutoSaveState {#[derive(Clone)]pub struct PendingWrite {pub path: PathBuf,+ pub(crate) slot: u32,+ pub(crate) revision: u64,+ /// Originating project identity: the path changes on Save As, the epoch on Open/New.+ pub(crate) project_path: Option<String>,+ pub(crate) project_epoch: u64,handle: std::sync::Arc<std::sync::Mutex<Option<std::thread::JoinHandle<std::io::Result<()>>>>>,}@@ -57,9 +62,16 @@ impl std::fmt::Debug for PendingWrite {}impl PendingWrite {- pub fn spawn(path: PathBuf, work: impl FnOnce() -> std::io::Result<()> + Send + 'static) -> std::io::Result<PendingWrite> {+ pub fn spawn(+ path: PathBuf,+ slot: u32,+ revision: u64,+ project_path: Option<String>,+ project_epoch: u64,+ work: impl FnOnce() -> std::io::Result<()> + Send + 'static,+ ) -> std::io::Result<PendingWrite> {let h = std::thread::Builder::new().name("autosave".into()).spawn(work)?;- Ok(PendingWrite { path, handle: std::sync::Arc::new(std::sync::Mutex::new(Some(h))) })+ Ok(PendingWrite { path, slot, revision, project_path, project_epoch, handle: std::sync::Arc::new(std::sync::Mutex::new(Some(h))) })}pub fn is_finished(&self) -> bool {self.handle.lock().map(|h| h.as_ref().is_none_or(|h| h.is_finished())).unwrap_or(true)diff --git a/crates/engine/src/session_settings.rs b/crates/engine/src/session_settings.rsindex 55c8e4154..ef3e748a6 100644--- a/crates/engine/src/session_settings.rs+++ b/crates/engine/src/session_settings.rs@@ -225,36 +225,50 @@ impl Session {let prefs = self.autosave_prefs();let fail = |e: std::io::Error| EngineError::Other(format!("auto-save failed: {e}"));let plan = autosave::plan_in(self.file_ops(), &prefs, self.path.as_deref(), root.as_deref(), self.autosave.last_slot).map_err(fail)?;+ let path = plan.path.to_string_lossy().into_owned();if self.autosave.background && !cfg!(target_arch = "wasm32") {let project = self.project.clone();let config = self.config.clone();let job = plan.clone();- let pending = autosave::PendingWrite::spawn(plan.path.clone(), move || {- let json = project.to_json_compact();- match &config {- Some(c) => job.write(c.files(), json.as_bytes()),- None => job.write(&crate::config::StdFiles, json.as_bytes()),- }- })- .map_err(fail)?;+ let pending =+ autosave::PendingWrite::spawn(plan.path.clone(), plan.slot, self.revision, self.path.clone(), self.script_ui.project_epoch, move || {+ let json = project.to_json_compact();+ match &config {+ Some(c) => job.write(c.files(), json.as_bytes()),+ None => job.write(&crate::config::StdFiles, json.as_bytes()),+ }+ })+ .map_err(fail)?;self.autosave.pending = Some(pending);} else {let json = self.project.to_json_compact();plan.write(self.file_ops(), json.as_bytes()).map_err(fail)?;+ self.commit_autosave(path.clone(), plan.slot, self.revision);}- let (path, slot) = (plan.path, plan.slot);- let p = path.to_string_lossy().to_string();+ Ok(path)+ }++ /// Advance recovery bookkeeping only for a successfully written snapshot.+ fn commit_autosave(&mut self, path: String, slot: u32, revision: u64) {self.autosave.last_slot = Some(slot);- self.autosave.saved_revision = Some(self.revision);- self.autosave.last_path = Some(p.clone());+ self.autosave.saved_revision = Some(revision);+ self.autosave.last_path = Some(path);self.update_sentinel();- Ok(p)}/// Wait for a background auto-save ([`autosave::AutoSaveState::background`]) to land.pub fn autosave_wait(&mut self) -> Result<()> {match self.autosave.pending.take() {- Some(w) => w.join().map_err(|e| EngineError::Other(format!("auto-save failed: {e}"))),+ Some(w) => {+ w.join().map_err(|e| EngineError::Other(format!("auto-save failed: {e}")))?;+ // Open/New can replace the project before note_project_path collects this+ // write. Save As changes only its path. Never publish the old snapshot as the+ // new project's recovery record, even when that record's final reset fails.+ if w.project_path == self.path && w.project_epoch == self.script_ui.project_epoch {+ self.commit_autosave(w.path.to_string_lossy().into_owned(), w.slot, w.revision);+ }+ Ok(())+ }None => Ok(()),}}@@ -278,7 +292,7 @@ impl Session {return None;}self.autosave.last = Some(now);- if !self.is_dirty() || self.autosave.saved_revision == Some(self.revision) || self.render_job.is_some() {+ if !self.is_dirty() || self.autosave.pending.is_some() || self.autosave.saved_revision == Some(self.revision) || self.render_job.is_some() {return None;}if self.path.is_none() && self.prefs.auto_save.location != "custom" && self.default_autosave_root().is_none() && self.autosave_folder_override.is_none()diff --git a/crates/engine/src/tests_settings.rs b/crates/engine/src/tests_settings.rsindex 65e39b467..58819f55c 100644--- a/crates/engine/src/tests_settings.rs+++ b/crates/engine/src/tests_settings.rs@@ -608,6 +608,216 @@ fn atomic_write_does_not_follow_a_link_at_the_old_temp_name() {let _ = std::fs::remove_dir_all(d);}+struct AutosaveTestStore {+ config: DirConfig,+ fail_next: std::sync::atomic::AtomicBool,+ gate: std::sync::Mutex<Option<(std::sync::mpsc::Sender<()>, std::sync::mpsc::Receiver<()>)>>,+ release_on_prefs: std::sync::Mutex<Option<std::sync::mpsc::Sender<()>>>,+ fail_reset_for: std::sync::Mutex<Option<String>>,+ failed_resets: std::sync::atomic::AtomicUsize,+}++impl ConfigStore for AutosaveTestStore {+ fn read(&self, name: &str) -> Option<String> {+ self.config.read(name)+ }+ fn write(&self, name: &str, data: &str) -> std::io::Result<()> {+ // note_project_path saves preferences after the project/path switch, before joining+ // the pending autosave. Release that writer at this exact transition, without sleeps.+ if name == PREFS_FILE+ && let Some(release) = self.release_on_prefs.lock().unwrap().take()+ {+ release.send(()).unwrap();+ }+ if name == autosave::SENTINEL+ && let Some(path) = self.fail_reset_for.lock().unwrap().as_ref()+ {+ let record: autosave::Sentinel = serde_json::from_str(data).unwrap();+ if record.project.as_ref() == Some(path) && record.autosave.is_none() {+ self.failed_resets.fetch_add(1, std::sync::atomic::Ordering::SeqCst);+ return Err(std::io::Error::other("injected final recovery reset failure"));+ }+ }+ self.config.write(name, data)+ }+ fn remove(&self, name: &str) -> std::io::Result<()> {+ self.config.remove(name)+ }+ fn dir(&self) -> Option<PathBuf> {+ self.config.dir()+ }+ fn files(&self) -> &dyn crate::config::FileOps {+ self+ }+}++impl crate::config::FileOps for AutosaveTestStore {+ fn list(&self, dir: &std::path::Path) -> Vec<(String, std::time::SystemTime)> {+ crate::config::StdFiles.list(dir)+ }+ fn write(&self, path: &std::path::Path, data: &[u8]) -> std::io::Result<()> {+ if let Some((started, release)) = self.gate.lock().unwrap().take() {+ started.send(()).unwrap();+ release.recv().unwrap();+ }+ if self.fail_next.swap(false, std::sync::atomic::Ordering::SeqCst) {+ return Err(std::io::Error::other("injected autosave write failure"));+ }+ crate::config::StdFiles.write(path, data)+ }+ fn remove(&self, path: &std::path::Path) -> std::io::Result<()> {+ crate::config::StdFiles.remove(path)+ }+ fn is_file(&self, path: &std::path::Path) -> bool {+ crate::config::StdFiles.is_file(path)+ }+}++fn background_autosave_session(dir: &std::path::Path) -> (Session, Arc<AutosaveTestStore>) {+ let store = Arc::new(AutosaveTestStore {+ config: DirConfig::new(dir.join("config")),+ fail_next: Default::default(),+ gate: Default::default(),+ release_on_prefs: Default::default(),+ fail_reset_for: Default::default(),+ failed_resets: Default::default(),+ });+ let mut s = session_with_comp();+ s.config = Some(store.clone());+ s.prefs.auto_save.enabled = true;+ s.prefs.auto_save.interval_minutes = 1;+ s.prefs.auto_save.location = "custom".into();+ s.prefs.auto_save.folder = dir.join("saves").to_string_lossy().into_owned();+ s.autosave.background = true;+ s.begin_recovery();+ (s, store)+}++#[test]+fn background_autosave_failure_retries_the_same_revision_and_retains_recovery() {+ let dir = tmp("autosave-retry");+ let (mut s, store) = background_autosave_session(&dir);+ let first = s.autosave_now().unwrap();+ s.autosave_wait().unwrap();+ let committed = s.autosave.saved_revision;+ s.execute("layer.newNull", json!({"name": "work to recover"})).unwrap();+ let revision = s.revision;+ store.fail_next.store(true, std::sync::atomic::Ordering::SeqCst);+ assert!(s.autosave_tick(1000.0).is_none());+ let failed_path = s.autosave_tick(1061.0).unwrap().unwrap();+ assert!(s.autosave_wait().unwrap_err().to_string().contains("injected autosave write failure"));+ assert_eq!(s.autosave.saved_revision, committed);+ assert_eq!(s.autosave.last_slot, Some(1));+ assert_eq!(s.autosave.last_path.as_deref(), Some(first.as_str()));+ let sentinel: autosave::Sentinel = serde_json::from_str(&store.read(autosave::SENTINEL).unwrap()).unwrap();+ assert_eq!(sentinel.autosave.as_deref(), Some(first.as_str()));+ assert!(!std::path::Path::new(&failed_path).is_file());+ let retried = s.autosave_tick(1122.0).expect("retry without another edit").unwrap();+ assert_eq!(retried, failed_path, "failed writes do not rotate the slot");+ s.autosave_wait().unwrap();+ assert_eq!(s.revision, revision);+ assert_eq!(s.autosave.saved_revision, Some(revision));+ assert_eq!(s.autosave.last_slot, Some(2));+ assert!(std::fs::read_to_string(&retried).unwrap().contains("work to recover"));+ let sentinel: autosave::Sentinel = serde_json::from_str(&store.read(autosave::SENTINEL).unwrap()).unwrap();+ assert_eq!(sentinel.autosave.as_deref(), Some(retried.as_str()));+ assert!(s.autosave_tick(1183.0).is_none(), "committed revision needs no duplicate write");+ std::fs::remove_dir_all(dir).unwrap();+}++#[test]+fn background_autosave_commits_only_the_snapshot_that_finished() {+ let dir = tmp("autosave-pending");+ let (mut s, store) = background_autosave_session(&dir);+ let (started, started_rx) = std::sync::mpsc::channel();+ let (release, release_rx) = std::sync::mpsc::channel();+ *store.gate.lock().unwrap() = Some((started, release_rx));+ let revision = s.revision;+ let path = s.autosave_now().unwrap();+ started_rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap();+ assert!(s.autosave_tick(1000.0).is_none());+ let saved = s.autosave.saved_revision;+ let last_path = s.autosave.last_path.clone();+ let sentinel: autosave::Sentinel = serde_json::from_str(&store.read(autosave::SENTINEL).unwrap()).unwrap();+ s.execute("layer.newNull", json!({"name": "edited during save"})).unwrap();+ assert!(s.autosave_tick(1061.0).is_none(), "a pending write must not block the next tick or launch a duplicate");+ release.send(()).unwrap();+ s.autosave_wait().unwrap();+ assert_eq!(saved, None, "an in-flight save is not committed");+ assert_eq!(last_path, None);+ assert_eq!(sentinel.autosave, None);+ assert_eq!(s.autosave.saved_revision, Some(revision), "completion must not mark newer edits as saved");+ assert_eq!(s.autosave.last_path.as_deref(), Some(path.as_str()));+ assert!(!std::fs::read_to_string(&path).unwrap().contains("edited during save"));+ let newer = s.autosave_tick(1122.0).unwrap().unwrap();+ s.autosave_wait().unwrap();+ assert_eq!(s.autosave.saved_revision, Some(s.revision));+ assert!(std::fs::read_to_string(newer).unwrap().contains("edited during save"));+ std::fs::remove_dir_all(dir).unwrap();+}++fn autosave_project_transition_with_failed_reset(command: &str, reopen: bool) {+ let dir = tmp("autosave-project-transition");+ let a = dir.join("A.ecproj").to_string_lossy().into_owned();+ let b = if reopen { a.clone() } else { dir.join("B.ecproj").to_string_lossy().into_owned() };+ let (mut s, store) = background_autosave_session(&dir);+ s.execute("file.saveAs", json!({"path": a})).unwrap();+ if !reopen {+ let mut other = session_with_comp();+ other.execute("layer.newNull", json!({"name": "project B"})).unwrap();+ other.execute("file.saveAs", json!({"path": b})).unwrap();+ }+ let b_bytes = std::fs::read(&b).unwrap();+ s.execute("layer.newNull", json!({"name": "unsaved project A"})).unwrap();+ s.update_sentinel();+ let (started, started_rx) = std::sync::mpsc::channel();+ let (release, release_rx) = std::sync::mpsc::channel();+ *store.gate.lock().unwrap() = Some((started, release_rx));+ let snapshot = s.autosave_now().unwrap();+ started_rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap();+ assert!(!s.autosave.pending.as_ref().unwrap().is_finished());+ let previous_record = store.read(autosave::SENTINEL).unwrap();+ *store.fail_reset_for.lock().unwrap() = Some(b.clone());+ *store.release_on_prefs.lock().unwrap() = Some(release);+ s.execute(command, json!({"path": b})).unwrap();+ assert_eq!(s.path.as_deref(), Some(b.as_str()));+ assert_eq!(store.failed_resets.load(std::sync::atomic::Ordering::SeqCst), 1, "the final recovery reset really failed");+ assert_eq!(+ store.read(autosave::SENTINEL).as_deref(),+ Some(previous_record.as_str()),+ "completion must not publish A's snapshot under the switched project"+ );+ assert_eq!(s.autosave.last_path, None);+ assert_eq!(s.autosave.saved_revision, None);+ if command == "file.open" {+ assert_eq!(std::fs::read(&b).unwrap(), b_bytes, "opening B must not alter its file bytes");+ }+ let prefs = s.prefs.clone();+ drop(s); // Simulate an unclean exit, leaving the failed-reset sentinel in place.+ let mut restart = Session { config: Some(store), prefs, ..Default::default() };+ let recovery = restart.begin_recovery().expect("previous project remains recoverable");+ assert_eq!(recovery.project.as_deref(), Some(a.as_str()));+ assert_eq!(recovery.autosave.as_deref(), Some(snapshot.as_str()));+ assert!(recovery.dirty);+ assert!(std::fs::read_to_string(snapshot).unwrap().contains("unsaved project A"));+ std::fs::remove_dir_all(dir).unwrap();+}++#[test]+fn opening_another_project_during_autosave_keeps_recovery_consistent_if_the_reset_fails() {+ autosave_project_transition_with_failed_reset("file.open", false);+}++#[test]+fn reopening_the_same_path_during_autosave_keeps_recovery_consistent_if_the_reset_fails() {+ autosave_project_transition_with_failed_reset("file.open", true);+}++#[test]+fn save_as_during_autosave_keeps_recovery_consistent_if_the_reset_fails() {+ autosave_project_transition_with_failed_reset("file.saveAs", false);+}+#[test]fn atomic_write_survives_a_crash_mid_write() {let d = tmp("atomic");