Files
solidcraft/crates/engine/src/recovery.rs
Dahak BuildsandDahak Builds dcbedbd805 Don't blindly reopen a design that stopped the last session (#5064) (#10443)
A design that crashes or hangs the app while it is being reopened was
reopened blindly every launch, bricking the app each time. A launch that
reopens designs now marks them in the recovery folder; the marker is
cleared as each design finishes opening. A launch that finds the marker
left behind skips those designs once and says which one the last session
stopped on, so the app starts usable and the loop breaks.

Co-authored-by: Dahak Builds <dahakbuilds@users.noreply.github.com>
2026-11-04 17:16:15 +00:00

760 lines
35 KiB
Rust

//! Autosave and crash recovery.
//!
//! Each open design keeps its own recovery entry in the recovery folder: `<id>.sc` (the design
//! as of the last autosave), `<id>.json` (its file path, name and time) and `<id>.lock`, which
//! the app holds locked while it runs. Autosaves are written atomically, only when the design
//! has unsaved changes it hasn't written yet; a design with nothing unsaved has no entry. An
//! entry whose lock nobody holds belongs to an app that crashed (or closed with unsaved changes):
//! the next launch offers to recover it.
use std::fs::{self, File, OpenOptions};
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use serde::{Deserialize, Serialize};
use solidcraft_doc::Document;
use crate::{EngineError, Result, Session};
/// The recovery folder: `SOLIDCRAFT_RECOVERY_DIR`, else the platform's per-user data folder.
/// Spelled with long names (`vfs::long_names`): an agent's commands reach it by this path, and
/// short (8.3) names are refused there.
pub fn default_dir() -> Option<PathBuf> {
use solidcraft_io::vfs::long_names;
// Tests never touch the user's real recovery folder.
if cfg!(test) {
return Some(solidcraft_io::vfs::temp_dir().join(format!("solidcraft-test-recovery-{}", std::process::id())));
}
if let Some(d) = solidcraft_geom::env::var_os("RECOVERY_DIR").filter(|d| !d.is_empty()) {
return Some(long_names(Path::new(&d)));
}
let env = |k: &str| std::env::var_os(k).filter(|d| !d.is_empty()).map(PathBuf::from);
let root = if cfg!(windows) {
env("LOCALAPPDATA")?
} else if cfg!(target_os = "macos") {
env("HOME")?.join("Library/Application Support")
} else {
env("XDG_DATA_HOME").or_else(|| env("HOME").map(|h| h.join(".local/share")))?
};
let (dir, legacy) = dirs_under(&long_names(&root), cfg!(windows) || cfg!(target_os = "macos"));
// Compatibility shim (docs/compatibility.md): autosaves made before the rename (or, in the
// Flatpak sandbox, under an earlier app id) are copied to the new folder on first launch; the
// old folder is left as it was.
for old in solidcraft_io::legacy_flatpak_paths(&dir).into_iter().chain([legacy]) {
if let Err(e) = solidcraft_io::adopt_legacy_dir(&dir, &old) {
log::warn!("recovery: could not copy {} to {}: {e}", old.display(), dir.display());
}
}
Some(dir)
}
/// SolidCraft's per-user data folder (the recovery folder's parent unless
/// `SOLIDCRAFT_RECOVERY_DIR` moves that): `%LOCALAPPDATA%\SolidCraft`,
/// `~/Library/Application Support/SolidCraft`, or `$XDG_DATA_HOME/solidcraft`
/// (`~/.local/share/solidcraft`).
pub fn data_dir() -> Option<PathBuf> {
let env = |k: &str| std::env::var_os(k).filter(|d| !d.is_empty()).map(PathBuf::from);
if cfg!(windows) {
Some(env("LOCALAPPDATA")?.join("SolidCraft"))
} else if cfg!(target_os = "macos") {
Some(env("HOME")?.join("Library/Application Support/SolidCraft"))
} else {
Some(env("XDG_DATA_HOME").or_else(|| env("HOME").map(|h| h.join(".local/share")))?.join("solidcraft"))
}
}
/// The recovery folder under the per-user data `root`, and the folder earlier releases used.
/// Windows and macOS name the app's folder in title case, other systems in lower case.
fn dirs_under(root: &Path, title_case: bool) -> (PathBuf, PathBuf) {
let (name, legacy) = if title_case { ("SolidCraft", "SolveCraft") } else { ("solidcraft", "solvecraft") };
(root.join(name).join("recovery"), root.join(legacy).join("recovery"))
}
/// What an entry's `<id>.json` holds.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Entry {
pub id: String,
/// The design's file, if it had one.
pub path: Option<String>,
pub name: String,
/// When it was autosaved (seconds since 1970).
pub saved_at: u64,
pub features: usize,
}
fn unix_now() -> u64 {
SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0)
}
fn valid_id(id: &str) -> bool {
!id.is_empty() && id.len() <= 64 && id.chars().all(|c| c.is_ascii_alphanumeric() || c == '-')
}
/// Recovery metadata is small; a damaged or hostile entry must not exhaust memory.
const MAX_ENTRY_BYTES: usize = 1 << 20;
/// Read only bounded, regular-file metadata. The second type check and bounded read
/// also protect against files changed while the recovery folder is being scanned.
fn read_entry(path: &Path) -> Option<Entry> {
let metadata = fs::metadata(path).ok()?;
if !metadata.is_file() || metadata.len() > MAX_ENTRY_BYTES as u64 {
return None;
}
let file = File::open(path).ok()?;
if !file.metadata().ok()?.is_file() {
return None;
}
let mut bytes = Vec::with_capacity(metadata.len() as usize);
file.take(MAX_ENTRY_BYTES as u64 + 1).read_to_end(&mut bytes).ok()?;
if bytes.len() > MAX_ENTRY_BYTES {
return None;
}
serde_json::from_slice(&bytes).ok()
}
/// An entry's design: `<id>.sc`, or `<id>.solidcraft` / `<id>.solvecraft` for an autosave an
/// earlier release wrote (compatibility shim, docs/compatibility.md).
fn design_file(dir: &Path, id: &str) -> PathBuf {
solidcraft_io::DESIGN_EXTS.iter().map(|ext| file(dir, id, ext)).find(|p| p.is_file()).unwrap_or_else(|| file(dir, id, solidcraft_io::DESIGN_EXT))
}
fn file(dir: &Path, id: &str, ext: &str) -> PathBuf {
dir.join(format!("{id}.{ext}"))
}
/// Entries left by apps that are no longer running, newest first.
pub fn orphans(dir: &Path) -> Vec<Entry> {
let mut out: Vec<Entry> = fs::read_dir(dir)
.into_iter()
.flatten()
.flatten()
.filter_map(|e| {
let p = e.path();
if p.extension().and_then(|x| x.to_str()) != Some("json") {
return None;
}
let id = p.file_stem().and_then(|s| s.to_str())?;
let entry = read_entry(&p)?;
if !valid_id(id) || entry.id != id || !design_file(dir, id).is_file() {
return None;
}
// Held by a running app: not an orphan.
let lock = File::open(file(dir, &entry.id, "lock"));
if let Ok(l) = &lock
&& l.try_lock().is_err()
{
return None;
}
Some(entry)
})
.take(1000)
.collect();
out.sort_by_key(|e| std::cmp::Reverse(e.saved_at));
out
}
/// Read an entry's design.
pub fn load(dir: &Path, id: &str) -> Result<(Document, Entry)> {
if !valid_id(id) {
return Err(EngineError::Other(format!("no recovered design `{id}`")));
}
let entry = read_entry(&file(dir, id, "json")).filter(|e| e.id == id).ok_or_else(|| EngineError::Other(format!("no recovered design `{id}`")))?;
let path = design_file(dir, id);
let bytes = solidcraft_io::limits::read(&path.to_string_lossy(), solidcraft_io::limits::Kind::Design)
.map_err(|e| EngineError::Other(format!("recovered design `{id}`: {e}")))?;
Ok((solidcraft_io::read_design(&bytes)?, entry))
}
/// Delete an entry. Only a real one: `<id>.json` must describe entry `id` and its design must
/// be there, so a folder and id that merely name someone's `part.sc` delete nothing.
pub fn remove(dir: &Path, id: &str) -> Result<()> {
let is_entry = valid_id(id) && read_entry(&file(dir, id, "json")).is_some_and(|e| e.id == id) && design_file(dir, id).is_file();
if !is_entry {
return Err(EngineError::Other(format!("no recovered design `{id}`")));
}
for ext in ["json", "lock"].into_iter().chain(solidcraft_io::DESIGN_EXTS) {
let _ = fs::remove_file(file(dir, id, ext));
}
Ok(())
}
/// #5064: marker file in the recovery folder listing the designs a launch is reopening.
const REOPEN_MARKER: &str = "reopening.json";
/// A launch that reopens designs marks them here. The marker is removed as each design
/// finishes opening; one still there at the next launch means the last session died (crashed,
/// hung, or was force-quit) while opening those designs — blindly reopening them would brick
/// the app the same way, so the next launch skips them instead (#5064).
pub fn begin_reopen(dir: &Path, paths: &[String]) {
if paths.is_empty() || fs::create_dir_all(dir).is_err() {
return;
}
if let Ok(bytes) = serde_json::to_vec(paths) {
let _ = fs::write(dir.join(REOPEN_MARKER), bytes);
}
}
/// The designs the previous session was reopening when it died (empty: nothing is stuck).
pub fn stuck_reopen(dir: &Path) -> Vec<String> {
read_reopen_marker(dir).unwrap_or_default()
}
/// The skip has been said: forget the marker so the launch after the skip reopens normally.
pub fn clear_reopen(dir: &Path) {
let _ = fs::remove_file(dir.join(REOPEN_MARKER));
}
/// One reopened design finished (opened or failed to): take it off the marker. When the last
/// one is gone the marker goes with it, so a healthy session leaves nothing behind.
pub fn reopen_finished(dir: &Path, path: &str) {
let Some(mut left) = read_reopen_marker(dir) else { return };
left.retain(|p| p != path);
if left.is_empty() {
clear_reopen(dir);
} else if let Ok(bytes) = serde_json::to_vec(&left) {
let _ = fs::write(dir.join(REOPEN_MARKER), bytes);
}
}
/// The marker's paths, bounded like every other file read from the folder.
fn read_reopen_marker(dir: &Path) -> Option<Vec<String>> {
let path = dir.join(REOPEN_MARKER);
let meta = fs::metadata(&path).ok()?;
if !meta.is_file() || meta.len() > MAX_ENTRY_BYTES as u64 {
return None;
}
serde_json::from_slice(&fs::read(&path).ok()?).ok()
}
/// One open design's autosaver. Keep it with that design when switching tabs.
pub struct Autosaver {
pub dir: PathBuf,
pub id: String,
/// Autosave this often while there are unsaved changes.
pub interval: Duration,
lock: Option<File>,
/// The design and what was hidden at the last autosave.
last: Option<(Arc<Document>, crate::Visibility)>,
last_at: Instant,
has_entry: bool,
/// The autosave being written on a worker thread: the design and what was hidden as it
/// started, and the outcome once the thread ends. A large design takes long enough to write
/// (and longer with its evaluated model) that the window must not wait for it.
writing: Option<Writing>,
}
/// An autosaver going away with a write still running (the app quit without closing it) lets the
/// write end first, so the entry it leaves is whole.
impl Drop for Autosaver {
fn drop(&mut self) {
if let Some(w) = self.writing.take() {
let _ = w.done.recv();
}
}
}
/// An autosave a worker thread is writing.
struct Writing {
doc: Arc<Document>,
visibility: crate::Visibility,
done: std::sync::mpsc::Receiver<Result<()>>,
}
/// What one autosave writes, taken from the session in an instant.
struct Snapshot {
dir: PathBuf,
id: String,
doc: Arc<Document>,
visibility: crate::Visibility,
path: Option<String>,
}
impl Snapshot {
/// Write the design and its entry (the slow part: serialising and compressing the design).
fn write(&self) -> Result<()> {
let io = |e: std::io::Error| EngineError::Other(format!("autosave: {e}"));
let bytes = if self.visibility.is_empty() {
solidcraft_io::write_design_container(&self.doc)?
} else {
let mut doc = (*self.doc).clone();
doc.visibility = self.visibility.clone();
solidcraft_io::write_design_container(&doc)?
};
solidcraft_io::write_atomic(&file(&self.dir, &self.id, solidcraft_io::DESIGN_EXT), &bytes, false).map_err(io)?;
let entry = Entry {
id: self.id.clone(),
path: self.path.clone(),
name: self.doc.name.clone(),
saved_at: unix_now(),
features: self.doc.features.len(),
};
let meta = serde_json::to_vec_pretty(&entry).map_err(|e| EngineError::Other(e.to_string()))?;
solidcraft_io::write_atomic(&file(&self.dir, &self.id, "json"), &meta, false).map_err(io)?;
Ok(())
}
}
impl Autosaver {
/// Start autosaving into `dir` (created if needed), holding this design's lock.
pub fn new(dir: &Path, interval: Duration) -> Result<Autosaver> {
let io = |e: std::io::Error| EngineError::Other(format!("{}: {e}", dir.display()));
fs::create_dir_all(dir).map_err(io)?;
// Locks of apps that ended with nothing to recover.
for e in fs::read_dir(dir).into_iter().flatten().flatten() {
let p = e.path();
if p.extension().and_then(|x| x.to_str()) == Some("lock")
&& !p.with_extension("json").exists()
&& File::open(&p).is_ok_and(|l| l.try_lock().is_ok())
{
let _ = fs::remove_file(&p);
}
}
// Unique within the process too: an app started again in the same second (tests that
// "crash" and restart) must not take over the crashed app's entry.
static SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let seq = SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let id = format!("{}-{}-{seq}", unix_now(), std::process::id());
let lock = OpenOptions::new().create(true).truncate(false).write(true).open(file(dir, &id, "lock")).map_err(io)?;
lock.lock().map_err(io)?;
Ok(Autosaver { dir: dir.to_path_buf(), id, interval, lock: Some(lock), last: None, last_at: Instant::now(), has_entry: false, writing: None })
}
/// Autosave now if the design has unsaved changes not written yet (and drop the entry when
/// nothing is unsaved), waiting for the write. Returns whether it wrote.
pub fn save(&mut self, s: &Session) -> Result<bool> {
self.finish(s, true)?;
let Some(snapshot) = self.begin(s) else { return Ok(false) };
let written = snapshot.write();
self.written(s, snapshot.doc, snapshot.visibility, written)?;
Ok(true)
}
/// Whether the last autosave holds `s` as it is now, with no write still running: what a
/// crash now would leave for the next launch to offer. A finished write counts once a
/// [`Self::tick`] has taken its outcome.
pub fn caught_up(&self, s: &Session) -> bool {
self.writing.is_none()
&& self.last.as_ref().is_some_and(|(doc, visibility)| (Arc::ptr_eq(doc, &s.doc) || **doc == *s.doc) && *visibility == s.visibility)
}
/// Autosave when the interval has passed, or right away after a big operation. The design
/// is written on a worker thread; true when this call started a write.
pub fn tick(&mut self, s: &Session, big: bool) -> Result<bool> {
// A write still running: nothing new starts until it has ended.
if !self.finish(s, false)? {
return Ok(false);
}
if !big && self.last_at.elapsed() < self.interval {
return Ok(false);
}
let Some(snapshot) = self.begin(s) else { return Ok(false) };
#[cfg(not(target_arch = "wasm32"))]
{
let (tx, rx) = std::sync::mpsc::channel();
let (doc, visibility) = (snapshot.doc.clone(), snapshot.visibility.clone());
let started = std::thread::Builder::new().name("autosave".into()).spawn(move || {
let _ = tx.send(snapshot.write());
});
match started {
Ok(_) => {
self.writing = Some(Writing { doc, visibility, done: rx });
Ok(true)
}
// No thread to write on: write here, as before.
Err(_) => {
let snapshot = Snapshot { dir: self.dir.clone(), id: self.id.clone(), doc, visibility, path: s.path.clone() };
let written = snapshot.write();
self.written(s, snapshot.doc, snapshot.visibility, written)?;
Ok(true)
}
}
}
#[cfg(target_arch = "wasm32")]
{
let written = snapshot.write();
self.written(s, snapshot.doc, snapshot.visibility, written)?;
Ok(true)
}
}
/// What the next autosave writes: `None` when there is nothing to write (and, with nothing
/// unsaved, the entry has been dropped).
fn begin(&mut self, s: &Session) -> Option<Snapshot> {
self.last_at = Instant::now();
if !s.is_dirty() {
if self.has_entry {
for ext in ["json"].into_iter().chain(solidcraft_io::DESIGN_EXTS) {
let _ = fs::remove_file(file(&self.dir, &self.id, ext));
}
self.has_entry = false;
}
self.last = None;
// Crash replays start from the saved file (or a new design) from here.
crate::crash::rebased(s, s.path.as_deref().map(Path::new), false);
return None;
}
if self.last.as_ref().is_some_and(|(l, v)| (Arc::ptr_eq(l, &s.doc) || **l == *s.doc) && *v == s.visibility) {
return None;
}
Some(Snapshot { dir: self.dir.clone(), id: self.id.clone(), doc: s.doc.clone(), visibility: s.visibility.clone(), path: s.path.clone() })
}
/// The running write's outcome, once it has one (`wait`: wait for it). True when no write
/// is running any more.
fn finish(&mut self, s: &Session, wait: bool) -> Result<bool> {
let Some(w) = self.writing.take() else { return Ok(true) };
let outcome = if wait {
w.done.recv().unwrap_or_else(|_| Err(EngineError::Other("autosave: the writer stopped".into())))
} else {
match w.done.try_recv() {
Ok(r) => r,
Err(std::sync::mpsc::TryRecvError::Empty) => {
self.writing = Some(w);
return Ok(false);
}
Err(std::sync::mpsc::TryRecvError::Disconnected) => Err(EngineError::Other("autosave: the writer stopped".into())),
}
};
self.written(s, w.doc, w.visibility, outcome)?;
Ok(true)
}
/// A write of `doc` (with `visibility`) ended with `outcome`.
fn written(&mut self, s: &Session, doc: Arc<Document>, visibility: crate::Visibility, outcome: Result<()>) -> Result<()> {
outcome?;
self.has_entry = true;
// Crash replays start from this autosave from here, unless the design changed while it
// was written: the journal then keeps the commands since its older start.
if Arc::ptr_eq(&s.doc, &doc) {
crate::crash::rebased(s, Some(&file(&self.dir, &self.id, solidcraft_io::DESIGN_EXT)), true);
}
self.last = Some((doc, visibility));
Ok(())
}
/// The user closed this design (saving it or choosing Don't Save): discard only its entry.
pub fn discard(mut self) {
// A write still running would recreate the entry, without a lock, after it is removed:
// the next launch would offer a design the user closed.
if let Some(w) = self.writing.take() {
let _ = w.done.recv();
}
for ext in ["json"].into_iter().chain(solidcraft_io::DESIGN_EXTS) {
let _ = fs::remove_file(file(&self.dir, &self.id, ext));
}
self.lock = None;
let _ = fs::remove_file(file(&self.dir, &self.id, "lock"));
}
/// Closing the app: with nothing unsaved the entry goes; otherwise it stays for the next
/// launch to offer. The lock is released either way.
pub fn close(mut self, s: &Session) {
let _ = self.save(s);
if !self.has_entry {
let _ = fs::remove_file(file(&self.dir, &self.id, "lock"));
}
self.lock = None;
}
}
#[cfg(test)]
mod tests {
#[test]
fn autosave_from_a_legacy_folder_is_listed_and_loads() {
// Autosaves written by earlier releases: `.solvecraft` (before the rename) and
// `.solidcraft` (before designs were saved as `.sc`).
for ext in solidcraft_io::LEGACY_DESIGN_EXTS {
let d = std::env::temp_dir().join(format!("solidcraft-recovery-legacy-{ext}-{}", std::process::id()));
let _ = fs::remove_dir_all(&d);
fs::create_dir_all(&d).unwrap();
let id = "1-2-3";
let doc = Document::default();
fs::write(d.join(format!("{id}.{ext}")), solidcraft_io::write_design(&doc)).unwrap();
let entry = Entry { id: id.into(), path: Some(format!("/d/part.{ext}")), name: "part".into(), saved_at: 1, features: 0 };
fs::write(d.join(format!("{id}.json")), serde_json::to_vec(&entry).unwrap()).unwrap();
assert_eq!(orphans(&d).iter().map(|e| e.id.as_str()).collect::<Vec<_>>(), [id], ".{ext}");
let (_, loaded) = load(&d, id).unwrap();
assert_eq!(loaded, entry);
remove(&d, id).unwrap();
assert!(orphans(&d).is_empty() && !d.join(format!("{id}.{ext}")).exists(), ".{ext}");
let _ = fs::remove_dir_all(&d);
}
}
/// New autosaves are written as `<id>.sc`.
#[test]
fn autosaves_are_written_as_sc() {
let d = dir("sc-ext");
let mut s = Session::default();
let mut a = Autosaver::new(&d, Duration::ZERO).unwrap();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
assert!(a.save(&s).unwrap());
assert!(d.join(format!("{}.sc", a.id)).is_file());
assert!(!d.join(format!("{}.solidcraft", a.id)).exists());
a.discard();
let _ = fs::remove_dir_all(&d);
}
#[test]
fn recovery_dirs_and_their_legacy_names() {
let (dir, legacy) = super::dirs_under(Path::new("/data"), false);
assert_eq!((dir.as_path(), legacy.as_path()), (Path::new("/data/solidcraft/recovery"), Path::new("/data/solvecraft/recovery")));
let (dir, legacy) = super::dirs_under(Path::new("/data"), true);
assert_eq!((dir.as_path(), legacy.as_path()), (Path::new("/data/SolidCraft/recovery"), Path::new("/data/SolveCraft/recovery")));
}
use super::*;
use serde_json::json;
fn dir(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("solidcraft-recovery-{tag}-{}", std::process::id()));
let _ = fs::remove_dir_all(&d);
d
}
/// Ticks (bounded) until the autosave a tick started has been written and taken up, as the
/// app's own frames would. A tick right after the one that started a write can find it still
/// running under load and take nothing up, so a test that then changes the session (marking
/// it saved) and checks the files would race the worker.
fn tick_until_caught_up(a: &mut Autosaver, s: &Session) {
let began = Instant::now();
while !a.caught_up(s) {
assert!(began.elapsed() < Duration::from_secs(30), "the autosave never caught up");
std::thread::sleep(Duration::from_millis(1));
a.tick(s, false).unwrap();
}
}
#[test]
fn autosave_only_unsaved_changes_and_recover_after_a_crash() {
let d = dir("crash");
let mut s = Session::default();
let mut a = Autosaver::new(&d, Duration::from_secs(3600)).unwrap();
assert!(!a.save(&s).unwrap(), "nothing unsaved");
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
assert!(!a.tick(&s, false).unwrap(), "not due yet");
assert!(a.tick(&s, true).unwrap(), "after a big operation");
assert!(!a.save(&s).unwrap(), "unchanged since the last autosave");
// Our own entry is locked: not offered.
assert!(orphans(&d).is_empty());
// The app dies without closing (the lock goes with the process).
drop(a);
let found = orphans(&d);
assert_eq!(found.len(), 1);
let (doc, entry) = load(&d, &found[0].id).unwrap();
assert_eq!(doc, *s.doc);
assert_eq!(entry.features, 1);
remove(&d, &entry.id).unwrap();
assert!(orphans(&d).is_empty());
let _ = fs::remove_dir_all(&d);
}
/// A tick doesn't wait for the autosave (#3044): it starts the write on a worker and
/// returns; the outcome is taken up by a later tick, and nothing new starts meanwhile. The
/// entry is the design as it was when the write started, even when it changed since.
#[test]
fn autosave_writes_on_a_worker_and_a_later_tick_takes_it_up() {
let d = dir("worker");
let mut s = Session::default();
let mut a = Autosaver::new(&d, Duration::ZERO).unwrap();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
let written = s.doc.clone();
assert!(a.tick(&s, false).unwrap(), "a write started");
assert!(a.writing.is_some(), "and runs on its own thread");
s.execute("solid.box", &json!({"length": 5, "width": 5, "height": 5, "center": [20, 0, 2.5], "operation": "new"})).unwrap();
// Ticks while it runs start nothing; the one that finds it ended takes it up and,
// the design having changed since, starts the next write.
let began = Instant::now();
while !a.tick(&s, false).unwrap() {
assert!(a.writing.is_some(), "nothing new starts while the write runs");
assert!(began.elapsed() < Duration::from_secs(30));
std::thread::sleep(Duration::from_millis(1));
}
assert!(a.has_entry);
assert!(a.last.as_ref().is_some_and(|(doc, _)| Arc::ptr_eq(doc, &written)), "the first write was the design as it started");
assert!(a.writing.as_ref().is_some_and(|w| Arc::ptr_eq(&w.doc, &s.doc)), "the next one writes the changed design");
drop(a);
let found = orphans(&d);
assert_eq!(found.len(), 1);
assert_eq!(load(&d, &found[0].id).unwrap().0, *s.doc, "dropping the autosaver lets its write end");
let _ = fs::remove_dir_all(&d);
}
#[test]
fn an_app_restarted_in_the_same_second_still_offers_the_crashed_ones_work() {
let d = dir("restart");
let mut s = Session::default();
let mut a = Autosaver::new(&d, Duration::from_secs(3600)).unwrap();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
assert!(a.save(&s).unwrap());
drop(a);
let b = Autosaver::new(&d, Duration::from_secs(3600)).unwrap();
let found = orphans(&d);
assert_eq!(found.len(), 1, "the crashed app's entry is offered");
assert_ne!(found[0].id, b.id);
let _ = fs::remove_dir_all(&d);
}
/// `doc.recovery_discard` deletes recovery entries only (#205): a folder and id that merely
/// name someone's design, or a `<id>.json` describing another entry, delete nothing.
#[test]
fn discarding_refuses_what_is_not_a_recovery_entry() {
let d = dir("discard");
fs::create_dir_all(&d).unwrap();
let part = d.join("part.solidcraft");
fs::write(&part, solidcraft_io::write_design(&Document::default())).unwrap();
let mut s = Session::default();
let discard = |s: &mut Session, id: &str| s.execute("doc.recovery_discard", &json!({"dir": d.to_string_lossy(), "id": id}));
let e = discard(&mut s, "part").unwrap_err();
assert!(e.to_string().contains("no recovered design `part`"), "{e}");
let other = Entry { id: "other".into(), path: None, name: "x".into(), saved_at: 1, features: 0 };
fs::write(d.join("part.json"), serde_json::to_vec(&other).unwrap()).unwrap();
assert!(discard(&mut s, "part").is_err());
assert!(discard(&mut s, "../part").is_err());
assert!(part.exists() && d.join("part.json").exists(), "nothing deleted");
// A real entry still goes.
let mine = Entry { id: "part".into(), ..other };
fs::write(d.join("part.json"), serde_json::to_vec(&mine).unwrap()).unwrap();
assert_eq!(discard(&mut s, "part").unwrap()["discarded"], json!(["part"]));
assert!(!part.exists());
let _ = fs::remove_dir_all(&d);
}
/// `doc.recover {discard: true}` opens a real entry and then deletes it; given a folder and
/// id that only name someone's design, it deletes nothing (#205 review).
#[test]
fn recover_with_discard_deletes_only_the_entry_it_opened() {
let d = dir("recover-discard");
let mut s = Session::default();
let mut a = Autosaver::new(&d, Duration::from_secs(3600)).unwrap();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
assert!(a.save(&s).unwrap());
let id = a.id.clone();
drop(a);
let mut t = Session::default();
let r = t.execute("doc.recover", &json!({"dir": d.to_string_lossy(), "id": id, "discard": true})).unwrap();
assert_eq!(r["features"], 1, "{r}");
assert!(orphans(&d).is_empty() && !file(&d, &id, "json").exists() && !file(&d, &id, solidcraft_io::DESIGN_EXT).exists());
let part = d.join("part.solidcraft");
fs::write(&part, solidcraft_io::write_design(&Document::default())).unwrap();
assert!(t.execute("doc.recover", &json!({"dir": d.to_string_lossy(), "id": "part", "discard": true})).is_err());
assert!(part.exists());
let _ = fs::remove_dir_all(&d);
}
#[test]
fn saving_drops_the_entry_and_a_clean_close_leaves_nothing() {
let d = dir("clean");
let mut s = Session::default();
let mut a = Autosaver::new(&d, Duration::ZERO).unwrap();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
assert!(a.tick(&s, false).unwrap());
tick_until_caught_up(&mut a, &s);
s.mark_saved();
a.tick(&s, false).unwrap();
assert!(!file(&d, &a.id, solidcraft_io::DESIGN_EXT).exists());
a.close(&s);
assert_eq!(fs::read_dir(&d).unwrap().count(), 0);
// Closing with unsaved changes keeps them for the next launch.
let b = Autosaver::new(&d, Duration::ZERO).unwrap();
s.execute("solid.box", &json!({"length": 5, "width": 5, "height": 5})).unwrap();
b.close(&s);
assert_eq!(orphans(&d).len(), 1);
assert!(load(&d, "../etc").is_err());
let _ = fs::remove_dir_all(&d);
}
/// A corrupted or hostile recovery entry must not consume unbounded memory at startup.
/// A metadata file exactly at the limit is still accepted.
#[test]
fn oversized_recovery_metadata_does_not_hide_valid_entries() {
let d = dir("bounded-metadata");
fs::create_dir_all(&d).unwrap();
let good = Entry { id: "good".into(), path: None, name: "good".into(), saved_at: 1, features: 0 };
let mut boundary = Entry { id: "boundary".into(), path: None, name: String::new(), saved_at: 2, features: 0 };
let base_len = serde_json::to_vec(&boundary).unwrap().len();
boundary.name = "x".repeat((1 << 20) - base_len);
let oversized = Entry { id: "oversized".into(), name: "x".repeat(1 << 20), ..good.clone() };
for entry in [&good, &boundary, &oversized] {
fs::write(file(&d, &entry.id, solidcraft_io::DESIGN_EXT), solidcraft_io::write_design(&Document::default())).unwrap();
fs::write(file(&d, &entry.id, "json"), serde_json::to_vec(entry).unwrap()).unwrap();
}
assert_eq!(fs::metadata(file(&d, "boundary", "json")).unwrap().len(), 1 << 20);
assert!(fs::metadata(file(&d, "oversized", "json")).unwrap().len() > 1 << 20);
let mut ids: Vec<String> = orphans(&d).into_iter().map(|e| e.id).collect();
ids.sort();
assert_eq!(ids, ["boundary", "good"]);
assert_eq!(load(&d, "good").unwrap().1, good);
assert_eq!(load(&d, "boundary").unwrap().1, boundary);
assert!(load(&d, "oversized").is_err());
assert!(remove(&d, "oversized").is_err());
assert!(file(&d, "oversized", "json").exists(), "invalid metadata must not delete a design");
fs::remove_dir_all(&d).unwrap();
}
/// A mismatched metadata ID must not redirect the recovered design's save path.
#[test]
fn recovery_metadata_id_must_match_its_filename() {
let d = dir("metadata-id");
fs::create_dir_all(&d).unwrap();
let wrong = Entry { id: "other".into(), path: Some("/unrelated-design.solidcraft".into()), name: "wrong".into(), saved_at: 1, features: 0 };
fs::write(file(&d, "actual", "json"), serde_json::to_vec(&wrong).unwrap()).unwrap();
for id in ["actual", "other"] {
fs::write(file(&d, id, solidcraft_io::DESIGN_EXT), solidcraft_io::write_design(&Document::default())).unwrap();
}
assert!(orphans(&d).is_empty(), "metadata under another ID must not be offered");
assert!(load(&d, "actual").is_err(), "a mismatched path must not become the next save target");
assert!(remove(&d, "actual").is_err());
assert!(file(&d, "actual", solidcraft_io::DESIGN_EXT).exists());
fs::remove_dir_all(&d).unwrap();
}
/// A device posing as a JSON file must not block the startup recovery scan.
#[cfg(target_os = "linux")]
#[test]
fn recovery_scan_skips_non_regular_metadata_files() {
use std::os::unix::fs::symlink;
let d = dir("device-metadata");
fs::create_dir_all(&d).unwrap();
symlink("/dev/zero", file(&d, "device", "json")).unwrap();
assert!(orphans(&d).is_empty());
assert!(load(&d, "device").is_err());
assert!(remove(&d, "device").is_err());
fs::remove_dir_all(&d).unwrap();
}
/// #5064: a design that kills the app while it is being reopened must not be blindly
/// reopened every launch. The marker survives the death, the next launch sees what the
/// last one died on, and a healthy session clears it by itself.
#[test]
fn reopen_guard_survives_a_session_that_died_mid_reopen() {
let d = dir("reopen-guard");
assert!(stuck_reopen(&d).is_empty(), "no marker: nothing is stuck");
begin_reopen(&d, &[]);
assert!(!d.join(REOPEN_MARKER).exists(), "nothing to reopen writes no marker");
let paths = vec!["/d/one.solidcraft".to_string(), "/d/two.solidcraft".to_string()];
begin_reopen(&d, &paths);
assert_eq!(stuck_reopen(&d), paths);
// The first design opens; the session dies on the second.
reopen_finished(&d, "/d/one.solidcraft");
assert_eq!(stuck_reopen(&d), vec!["/d/two.solidcraft".to_string()]);
// The skip clears the marker so the launch after it reopens normally.
clear_reopen(&d);
assert!(stuck_reopen(&d).is_empty());
// A healthy session: every design finishes and the marker goes with the last one.
begin_reopen(&d, &paths);
reopen_finished(&d, "/d/one.solidcraft");
reopen_finished(&d, "/d/two.solidcraft");
assert!(stuck_reopen(&d).is_empty() && !d.join(REOPEN_MARKER).exists());
// A damaged marker is ignored, not fatal.
fs::write(d.join(REOPEN_MARKER), b"not json").unwrap();
assert!(stuck_reopen(&d).is_empty());
reopen_finished(&d, "/d/one.solidcraft");
fs::remove_dir_all(&d).unwrap();
}
}