fa21db7df8
* claim: Save: hard-link the backup copy and check for unsaved changes once per revision * Save: keep the backup as a hard link and check for unsaved changes once per revision The backup of a save is the old file under a second name (a hard link renamed over the old .bak) instead of a copy written out again; where links are refused (FAT, shares, cloud folders) or the old file cannot be flushed, it is copied as before. Every point a save can stop at leaves the design file whole and the backup the version before it. Session::is_dirty compared the whole document with the saved one each time it was asked, which the window does every frame for every tab. The answer is kept per revision and pair of documents; the cache holds both, so neither can change in place while it stands, and doc_mut lets it go first so edits stay in place. On the rover in two unsaved tabs an idle frame takes 15.0 ms instead of 19.3 ms; a save with its backup of the 11.8 MB file writes in 9.6 ms instead of 18.9 ms. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
810 lines
37 KiB
Rust
810 lines
37 KiB
Rust
//! Crash-safe file writes: the new content goes to a temporary file next to the target, is
|
|
//! flushed to disk, and replaces the target in one rename. A crash or power cut at any moment
|
|
//! leaves the old file or the new one, never a torn mix. The previous version can be kept as
|
|
//! `<file>.bak`: the old file itself under that name (a hard link) where the file system allows,
|
|
//! else a copy written the same way.
|
|
|
|
use std::fs::{self, OpenOptions};
|
|
use std::io::Write;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
/// The backup of a file written with `backup: true`.
|
|
pub fn backup_path(path: &Path) -> PathBuf {
|
|
let mut s = path.as_os_str().to_owned();
|
|
s.push(".bak");
|
|
PathBuf::from(s)
|
|
}
|
|
|
|
fn temp_beside(path: &Path, tag: &str) -> PathBuf {
|
|
let name = path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "file".into());
|
|
let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.subsec_nanos()).unwrap_or(0);
|
|
path.with_file_name(format!(".{name}.{tag}.{}.{nanos}.tmp", std::process::id()))
|
|
}
|
|
|
|
fn write_synced(path: &Path, bytes: &[u8]) -> std::io::Result<()> {
|
|
let mut f = OpenOptions::new().write(true).create_new(true).open(path)?;
|
|
f.write_all(bytes)?;
|
|
flush(&f)
|
|
}
|
|
|
|
/// Flush a written file to the disk. On Apple systems `sync_all` asks the drive itself to flush
|
|
/// (`F_FULLFSYNC`), which a network share refuses (an SMB share: "Operation not supported", os
|
|
/// error 45), so a save there failed before it replaced anything. The plain `fsync` the share
|
|
/// does offer is used then, as SQLite and git do.
|
|
fn flush(f: &fs::File) -> std::io::Result<()> {
|
|
flush_with(f, fs::File::sync_all)
|
|
}
|
|
|
|
fn flush_with(f: &fs::File, full: impl FnOnce(&fs::File) -> std::io::Result<()>) -> std::io::Result<()> {
|
|
match full(f) {
|
|
#[cfg(target_vendor = "apple")]
|
|
Err(e) if e.kind() == std::io::ErrorKind::Unsupported || e.raw_os_error() == Some(45) => rustix::fs::fsync(f).map_err(std::io::Error::from),
|
|
r => r,
|
|
}
|
|
}
|
|
|
|
/// Flush the directory entry (the rename) to disk where the platform allows it.
|
|
fn sync_dir(path: &Path) {
|
|
#[cfg(unix)]
|
|
if let Some(dir) = path.parent().filter(|d| !d.as_os_str().is_empty())
|
|
&& let Ok(d) = fs::File::open(dir)
|
|
{
|
|
let _ = d.sync_all();
|
|
}
|
|
#[cfg(not(unix))]
|
|
let _ = path;
|
|
}
|
|
|
|
/// Steps of a save, so tests can stop one part way (as a crash would).
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
|
|
enum Step {
|
|
TempWritten,
|
|
BackupWritten,
|
|
#[allow(dead_code)] // stopping after the last step is a whole save (tests name it)
|
|
Replaced,
|
|
}
|
|
|
|
/// Most links followed before a path is called a loop.
|
|
const MAX_LINK_HOPS: usize = 40;
|
|
|
|
/// The file a save has to replace: `path`, or where a symbolic link at `path` (or a chain of
|
|
/// them) leads, so a design linked into a project from a synced folder is saved there and the
|
|
/// link survives. A link whose target is missing resolves to the place the target would be.
|
|
fn resolve_links(path: &Path) -> std::io::Result<PathBuf> {
|
|
let mut at = path.to_path_buf();
|
|
for _ in 0..MAX_LINK_HOPS {
|
|
if !fs::symlink_metadata(&at).is_ok_and(|m| m.file_type().is_symlink()) {
|
|
return Ok(at);
|
|
}
|
|
let to = fs::read_link(&at)?;
|
|
at = if to.is_absolute() { to } else { at.parent().map(|d| d.join(&to)).unwrap_or(to) };
|
|
}
|
|
Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, format!("{}: too many levels of symbolic links", path.display())))
|
|
}
|
|
|
|
/// Give the file that replaces `old` the permissions `old` had (a private `0600` design must not
|
|
/// come back readable by everyone, a group's `0664` must not lose the group's write access).
|
|
fn keep_permissions(old: &Option<fs::Permissions>, new: &Path) {
|
|
if let Some(p) = old {
|
|
let _ = fs::set_permissions(new, p.clone());
|
|
}
|
|
}
|
|
|
|
// Retrying only the already-synced atomic rename avoids rewriting a large image
|
|
// or deleting/truncating its existing target. ACL/read-only/other permanent
|
|
// refusals still fail. No file lock is broken and no security setting is changed.
|
|
fn replace_synced(source: &Path, destination: &Path) -> std::io::Result<()> {
|
|
// A read-only target is refused for good: fail at once rather than wait for it.
|
|
let read_only = fs::metadata(destination).is_ok_and(|m| m.permissions().readonly());
|
|
let windows = cfg!(windows);
|
|
rename_with_retry(|| fs::rename(source, destination), windows && !read_only, std::thread::sleep)
|
|
.map_err(|error| explain_refusal(error, windows, read_only))
|
|
}
|
|
|
|
/// The waits between attempts at a rename Windows refuses: doubling from 1 ms, then 250 ms at a
|
|
/// time, about 2 s in all. An antivirus or indexer scanning a file written a moment earlier can
|
|
/// hold it for several hundred milliseconds when the machine is busy (#8104); 127 ms was too short.
|
|
const RENAME_WAITS_MS: [u64; 15] = [1, 2, 4, 8, 16, 32, 64, 128, 250, 250, 250, 250, 250, 250, 250];
|
|
|
|
/// Whether `error` is Windows refusing a rename (access denied, os error 5, or a sharing
|
|
/// violation, os error 32): another program has the file open, or it is read-only or denied.
|
|
fn refused_by_windows(error: &std::io::Error) -> bool {
|
|
matches!(error.raw_os_error(), Some(5 | 32))
|
|
}
|
|
|
|
/// Say why Windows would not replace the file rather than only the bare "Access is denied", and
|
|
/// keep the system's own words.
|
|
fn explain_refusal(error: std::io::Error, windows: bool, read_only: bool) -> std::io::Error {
|
|
if !windows || !refused_by_windows(&error) {
|
|
return error;
|
|
}
|
|
let why =
|
|
if read_only { "the file is read-only" } else { "Windows would not replace the file: another program may have it open, or it is read-only" };
|
|
std::io::Error::new(error.kind(), format!("{why} ({error})"))
|
|
}
|
|
|
|
fn rename_with_retry(
|
|
mut rename: impl FnMut() -> std::io::Result<()>,
|
|
windows: bool,
|
|
mut wait: impl FnMut(std::time::Duration),
|
|
) -> std::io::Result<()> {
|
|
// Windows can refuse rename while an independently opened handle withholds
|
|
// FILE_SHARE_DELETE. Access denied may also be permanent, so keep an attempt
|
|
// bound and the last error. Requested sleeps total 2005 ms; scheduling/OS
|
|
// operation time is not a wall-clock latency guarantee.
|
|
let mut result = rename();
|
|
if !windows {
|
|
return result;
|
|
}
|
|
for milliseconds in RENAME_WAITS_MS {
|
|
if !result.as_ref().is_err_and(refused_by_windows) {
|
|
return result;
|
|
}
|
|
wait(std::time::Duration::from_millis(milliseconds));
|
|
result = rename();
|
|
}
|
|
result
|
|
}
|
|
|
|
/// Keep the file a save is about to replace as its backup without copying it: a second name for
|
|
/// the same file (a hard link) under a temporary name beside it, renamed over the old backup in
|
|
/// one step. The target keeps its name at every moment, and a save never writes into a file it
|
|
/// replaces (it renames a new one over it), so the backup stays the version it was. `Ok(false)`:
|
|
/// this file system refuses links (FAT and exFAT drives, many network shares and synced cloud
|
|
/// folders) or the old file could not be flushed first; the caller copies it then, as before. A
|
|
/// refused rename fails the save, as it does for a copy.
|
|
///
|
|
/// What differs from a copy: the backup is the old file itself, so it keeps that file's
|
|
/// modification time (the previous save's, where a copy has the time of this save), its owner
|
|
/// and its permissions (a copy is given the same permissions), and until the target is replaced
|
|
/// the two names share one file.
|
|
fn link_backup(path: &Path) -> std::io::Result<bool> {
|
|
#[cfg(test)]
|
|
if tests::LINKS_REFUSED.with(std::cell::Cell::get) {
|
|
return Ok(false);
|
|
}
|
|
// Flushed first, as a copy is: data still only in memory would be lost with it in a power cut.
|
|
if open_to_flush(path).and_then(|f| flush(&f)).is_err() {
|
|
return Ok(false);
|
|
}
|
|
let bak_tmp = temp_beside(path, "bak");
|
|
if fs::hard_link(path, &bak_tmp).is_err() {
|
|
return Ok(false);
|
|
}
|
|
if let Err(e) = replace_synced(&bak_tmp, &backup_path(path)) {
|
|
// Only the second name this call just made: the old file keeps its own.
|
|
let _ = fs::remove_file(&bak_tmp);
|
|
return Err(e);
|
|
}
|
|
Ok(true)
|
|
}
|
|
|
|
/// Open the file a save replaces so it can be flushed. Windows flushes only a file opened for
|
|
/// writing (nothing is written, and it is not truncated); elsewhere reading is enough.
|
|
fn open_to_flush(path: &Path) -> std::io::Result<fs::File> {
|
|
OpenOptions::new().read(true).write(cfg!(windows)).open(path)
|
|
}
|
|
|
|
fn write_steps(path: &Path, bytes: &[u8], backup: bool, stop: Option<Step>) -> std::io::Result<()> {
|
|
let permissions = fs::metadata(path).ok().filter(|m| m.is_file()).map(|m| m.permissions());
|
|
let tmp = temp_beside(path, "new");
|
|
if let Err(e) = write_synced(&tmp, bytes) {
|
|
let _ = fs::remove_file(&tmp);
|
|
return Err(e);
|
|
}
|
|
keep_permissions(&permissions, &tmp);
|
|
if stop == Some(Step::TempWritten) {
|
|
return Ok(());
|
|
}
|
|
let linked = if backup && path.is_file() { link_backup(path) } else { Ok(false) };
|
|
let linked = match linked {
|
|
Ok(linked) => linked,
|
|
Err(e) => {
|
|
let _ = fs::remove_file(&tmp);
|
|
return Err(e);
|
|
}
|
|
};
|
|
if backup && !linked && path.is_file() {
|
|
// Copy (not move) the old file, so the target exists at every moment.
|
|
let old = fs::read(path);
|
|
let bak_tmp = temp_beside(path, "bak");
|
|
let r = old
|
|
.and_then(|old| write_synced(&bak_tmp, &old))
|
|
.map(|_| keep_permissions(&permissions, &bak_tmp))
|
|
.and_then(|_| replace_synced(&bak_tmp, &backup_path(path)));
|
|
if let Err(e) = r {
|
|
let _ = fs::remove_file(&bak_tmp);
|
|
let _ = fs::remove_file(&tmp);
|
|
return Err(e);
|
|
}
|
|
}
|
|
if stop == Some(Step::BackupWritten) {
|
|
return Ok(());
|
|
}
|
|
if let Err(e) = replace_synced(&tmp, path) {
|
|
let _ = fs::remove_file(&tmp);
|
|
return Err(e);
|
|
}
|
|
sync_dir(path);
|
|
// Temporary files of saves that crashed part way (a minute old or more) go.
|
|
for t in stale_temps(path) {
|
|
if fs::metadata(&t).and_then(|m| m.modified()).ok().and_then(|m| m.elapsed().ok()).is_some_and(|age| age.as_secs() >= 60) {
|
|
let _ = fs::remove_file(t);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Write `bytes` to `path` atomically; with `backup`, the file being replaced is kept as
|
|
/// `<path>.bak` first. A symbolic link at `path` is followed (the file it points to is replaced,
|
|
/// the link stays), and the file keeps the permissions it had. The app's own folders (autosave,
|
|
/// crash reports) write through this without a [`crate::vfs::PathScope`]; a command writing a
|
|
/// path it was given calls [`crate::vfs::check`] first, which judges where the link leads.
|
|
pub fn write_atomic(path: &Path, bytes: &[u8], backup: bool) -> std::io::Result<()> {
|
|
// In the browser the host stores files (one write is already atomic there).
|
|
if cfg!(target_arch = "wasm32") {
|
|
let _ = backup;
|
|
return crate::vfs::write(&path.to_string_lossy(), bytes);
|
|
}
|
|
write_steps(&resolve_links(path)?, bytes, backup, None)
|
|
}
|
|
|
|
/// Publish a complete new file without replacing an existing destination, even if another
|
|
/// writer creates it after this call starts. Unsupported filesystems return an error.
|
|
pub fn create_atomic(path: &Path, bytes: &[u8]) -> std::io::Result<()> {
|
|
if cfg!(target_arch = "wasm32") {
|
|
let name = path.to_string_lossy();
|
|
if crate::vfs::exists(&name) {
|
|
return Err(std::io::Error::new(std::io::ErrorKind::AlreadyExists, "destination already exists"));
|
|
}
|
|
return crate::vfs::write(&name, bytes);
|
|
}
|
|
let tmp = temp_beside(path, "create");
|
|
// Only remove a temporary file that this invocation successfully created.
|
|
let mut file = OpenOptions::new().write(true).create_new(true).open(&tmp)?;
|
|
let result = file.write_all(bytes).and_then(|_| flush(&file));
|
|
drop(file);
|
|
let result = result.and_then(|_| fs::hard_link(&tmp, path));
|
|
let _ = fs::remove_file(&tmp);
|
|
if result.is_ok() {
|
|
sync_dir(path);
|
|
}
|
|
result
|
|
}
|
|
|
|
/// Leftover temporary files of saves that never finished (a crash part way), next to `path`
|
|
/// (next to the file a link at `path` points to, where a save puts them).
|
|
pub fn stale_temps(path: &Path) -> Vec<PathBuf> {
|
|
let resolved = resolve_links(path).unwrap_or_else(|_| path.to_path_buf());
|
|
let path = resolved.as_path();
|
|
let Some(name) = path.file_name().map(|n| n.to_string_lossy().to_string()) else { return Vec::new() };
|
|
let dir = path.parent().filter(|d| !d.as_os_str().is_empty()).unwrap_or(Path::new("."));
|
|
let prefix = format!(".{name}.");
|
|
fs::read_dir(dir)
|
|
.into_iter()
|
|
.flatten()
|
|
.flatten()
|
|
.map(|e| e.path())
|
|
.filter(|p| p.file_name().map(|n| n.to_string_lossy().to_string()).is_some_and(|n| n.starts_with(&prefix) && n.ends_with(".tmp")))
|
|
.collect()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
thread_local! {
|
|
/// This thread's saves find hard links refused ([`link_backup`]), as on a FAT drive: the
|
|
/// backup is copied, exactly as it is there.
|
|
pub(super) static LINKS_REFUSED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
|
|
}
|
|
|
|
/// A new, empty folder of its own for one test (nothing in it is removed).
|
|
fn fresh_dir(tag: &str) -> PathBuf {
|
|
let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0);
|
|
let d = std::env::temp_dir().join(format!("solidcraft-safe-write-{tag}-{}-{nanos}", std::process::id()));
|
|
fs::create_dir_all(&d).unwrap();
|
|
d
|
|
}
|
|
|
|
/// The time of a save with its backup, the backup linked against the backup copied (links
|
|
/// refused, as before hard links were used), taking turns. The file saved is
|
|
/// `SOLIDCRAFT_SAVE_BENCH_FILE` (a design), in a new folder in `SOLIDCRAFT_SAVE_BENCH_DIR`
|
|
/// (on the drive to measure; else the temporary folder). Run with `--ignored --nocapture`.
|
|
#[test]
|
|
#[ignore = "manual save measurement"]
|
|
fn save_time_with_the_backup_linked_or_copied() {
|
|
let Some(file) = std::env::var_os("SOLIDCRAFT_SAVE_BENCH_FILE") else { return };
|
|
let bytes = fs::read(file).unwrap();
|
|
let base = std::env::var_os("SOLIDCRAFT_SAVE_BENCH_DIR").map(PathBuf::from).unwrap_or_else(std::env::temp_dir);
|
|
let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0);
|
|
let d = base.join(format!("save-bench-{}-{nanos}", std::process::id()));
|
|
fs::create_dir_all(&d).unwrap();
|
|
let p = d.join("design.solidcraft");
|
|
write_atomic(&p, &bytes, true).unwrap();
|
|
let rounds: usize = std::env::var("SOLIDCRAFT_SAVE_BENCH_ROUNDS").ok().and_then(|n| n.parse().ok()).unwrap_or(11);
|
|
let mut times = [Vec::new(), Vec::new()];
|
|
for round in 0..2 * rounds {
|
|
let refused = round % 2 == 1;
|
|
LINKS_REFUSED.with(|r| r.set(refused));
|
|
let t = std::time::Instant::now();
|
|
write_atomic(&p, &bytes, true).unwrap();
|
|
times[usize::from(refused)].push(t.elapsed().as_secs_f64() * 1000.0);
|
|
}
|
|
LINKS_REFUSED.with(|r| r.set(false));
|
|
for (name, mut t) in ["linked", "copied"].into_iter().zip(times) {
|
|
t.sort_by(f64::total_cmp);
|
|
println!(
|
|
"SAVEBENCH bytes={} backup={name} median_ms={:.2} min_ms={:.2} max_ms={:.2} n={}",
|
|
bytes.len(),
|
|
t[t.len() / 2],
|
|
t[0],
|
|
t[t.len() - 1],
|
|
t.len()
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Saves keep the previous version as the backup, stopped after any step or not, whether the
|
|
/// file system links the old file as the backup or refuses links (a FAT drive, a share) so it
|
|
/// is copied: the design file is the old version or the new one, whole, and the backup is
|
|
/// the version before it, never the one being written.
|
|
#[test]
|
|
fn the_backup_is_the_previous_version_linked_or_copied_and_a_stopped_save_keeps_both() {
|
|
for refused in [false, true] {
|
|
LINKS_REFUSED.with(|r| r.set(refused));
|
|
let d = fresh_dir(if refused { "bak-copied" } else { "bak-linked" });
|
|
let p = d.join("a.solidcraft");
|
|
write_atomic(&p, b"one", true).unwrap();
|
|
write_atomic(&p, b"two", true).unwrap();
|
|
assert_eq!((fs::read(&p).unwrap(), fs::read(backup_path(&p)).unwrap()), (b"two".to_vec(), b"one".to_vec()), "refused {refused}");
|
|
for stop in [Step::TempWritten, Step::BackupWritten] {
|
|
write_steps(&p, b"three", true, Some(stop)).unwrap();
|
|
assert_eq!(fs::read(&p).unwrap(), b"two", "{stop:?}, refused {refused}");
|
|
let bak = fs::read(backup_path(&p)).unwrap();
|
|
let want: &[u8] = if stop == Step::TempWritten { b"one" } else { b"two" };
|
|
assert_eq!(bak, want, "{stop:?}, refused {refused}");
|
|
assert!(!stale_temps(&p).is_empty(), "the stopped save's temporary file is left over");
|
|
}
|
|
write_atomic(&p, b"four", true).unwrap();
|
|
write_atomic(&p, b"five", true).unwrap();
|
|
assert_eq!((fs::read(&p).unwrap(), fs::read(backup_path(&p)).unwrap()), (b"five".to_vec(), b"four".to_vec()), "refused {refused}");
|
|
}
|
|
LINKS_REFUSED.with(|r| r.set(false));
|
|
}
|
|
|
|
/// #5467: a lock is someone else's while it is refreshed; one left by a crash goes stale, and
|
|
/// this app's own lock never counts as the design being open elsewhere. Writing a design's
|
|
/// file changes its stamp.
|
|
#[test]
|
|
fn a_fresh_lock_from_another_app_holds_the_design_and_a_stale_or_own_one_does_not() {
|
|
use crate::design_lock as lock;
|
|
let d = dir("design-lock");
|
|
let design = d.join("Bracket.solidcraft");
|
|
std::fs::write(&design, b"one").unwrap();
|
|
assert_eq!(lock::lock_path(&design), d.join(".~Bracket.solidcraft.lock"));
|
|
assert!(!crate::is_design_path(&lock::lock_path(&design).to_string_lossy()), "never listed as a design");
|
|
|
|
let now = lock::now_secs();
|
|
let theirs = lock::Lock { host: "WORKSHOP-PC".into(), pid: std::process::id().wrapping_add(1), ..lock::Lock::mine(now - 600) };
|
|
lock::write(&design, &lock::Lock { refreshed: now - 30, ..theirs.clone() }).unwrap();
|
|
assert_eq!(lock::held_elsewhere(&design, now).map(|l| l.host), Some("WORKSHOP-PC".into()));
|
|
// Not refreshed for longer than three refreshes: left behind, ignored.
|
|
lock::write(&design, &lock::Lock { refreshed: now - lock::STALE_SECS - 1, ..theirs.clone() }).unwrap();
|
|
assert!(lock::held_elsewhere(&design, now).is_none());
|
|
lock::remove(&design);
|
|
assert!(lock::lock_path(&design).exists(), "another app's lock is left alone");
|
|
// This app's own lock: not "elsewhere", and removed on close.
|
|
lock::write(&design, &lock::Lock::mine(now)).unwrap();
|
|
assert!(lock::held_elsewhere(&design, now).is_none());
|
|
lock::remove(&design);
|
|
assert!(!lock::lock_path(&design).exists());
|
|
|
|
let known = lock::stamp(&design.to_string_lossy()).unwrap();
|
|
assert!(!lock::changed_since(&design.to_string_lossy(), &known));
|
|
std::fs::write(&design, b"written elsewhere").unwrap();
|
|
assert!(lock::changed_since(&design.to_string_lossy(), &known));
|
|
let _ = std::fs::remove_dir_all(&d);
|
|
}
|
|
|
|
#[test]
|
|
fn create_does_not_replace_an_existing_destination() {
|
|
let d = dir("create");
|
|
let p = d.join("render.png");
|
|
create_atomic(&p, b"first complete image").unwrap();
|
|
assert_eq!(create_atomic(&p, b"replacement").unwrap_err().kind(), std::io::ErrorKind::AlreadyExists);
|
|
assert_eq!(fs::read(&p).unwrap(), b"first complete image");
|
|
assert!(stale_temps(&p).is_empty());
|
|
fs::remove_dir_all(d).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn concurrent_creators_publish_exactly_one_whole_file() {
|
|
let d = dir("create-race");
|
|
let p = d.join("render.png");
|
|
let gate = std::sync::Arc::new(std::sync::Barrier::new(2));
|
|
let workers: Vec<_> = [b"first image".as_slice(), b"second image".as_slice()]
|
|
.into_iter()
|
|
.map(|bytes| {
|
|
let gate = gate.clone();
|
|
let p = p.clone();
|
|
std::thread::spawn(move || {
|
|
gate.wait();
|
|
create_atomic(&p, bytes)
|
|
})
|
|
})
|
|
.collect();
|
|
let results: Vec<_> = workers.into_iter().map(|w| w.join().unwrap()).collect();
|
|
assert_eq!(results.iter().filter(|r| r.is_ok()).count(), 1);
|
|
assert_eq!(results.iter().filter_map(|r| r.as_ref().err()).next().unwrap().kind(), std::io::ErrorKind::AlreadyExists);
|
|
let bytes = fs::read(&p).unwrap();
|
|
assert!(bytes == b"first image" || bytes == b"second image");
|
|
assert!(stale_temps(&p).is_empty());
|
|
fs::remove_dir_all(d).unwrap();
|
|
}
|
|
|
|
fn dir(tag: &str) -> PathBuf {
|
|
let d = std::env::temp_dir().join(format!("solidcraft-safe-write-{tag}-{}", std::process::id()));
|
|
let _ = fs::remove_dir_all(&d);
|
|
fs::create_dir_all(&d).unwrap();
|
|
d
|
|
}
|
|
|
|
/// A network share (SMB on macOS) refuses the drive flush `sync_all` asks for with "Operation
|
|
/// not supported" (os error 45). The file is then flushed the plain way and the save goes on;
|
|
/// any other failure still fails the save.
|
|
#[test]
|
|
fn a_share_that_refuses_the_full_flush_gets_a_plain_one() {
|
|
let d = dir("flush");
|
|
let p = d.join("a.solidcraft");
|
|
fs::write(&p, b"saved").unwrap();
|
|
let f = fs::File::open(&p).unwrap();
|
|
let refused = |_: &fs::File| Err(std::io::Error::from_raw_os_error(45));
|
|
#[cfg(target_vendor = "apple")]
|
|
flush_with(&f, refused).unwrap();
|
|
#[cfg(not(target_vendor = "apple"))]
|
|
assert!(flush_with(&f, refused).is_err(), "elsewhere sync_all is the plain flush already");
|
|
let unsupported = |_: &fs::File| Err(std::io::Error::from(std::io::ErrorKind::Unsupported));
|
|
assert_eq!(flush_with(&f, unsupported).is_ok(), cfg!(target_vendor = "apple"));
|
|
let broken = |_: &fs::File| Err(std::io::Error::from(std::io::ErrorKind::PermissionDenied));
|
|
assert_eq!(flush_with(&f, broken).unwrap_err().kind(), std::io::ErrorKind::PermissionDenied);
|
|
flush_with(&f, |_| Ok(())).unwrap();
|
|
drop(f);
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
|
|
#[test]
|
|
fn replaces_and_keeps_a_backup() {
|
|
let d = dir("bak");
|
|
let p = d.join("a.solidcraft");
|
|
write_atomic(&p, b"one", true).unwrap();
|
|
assert!(!backup_path(&p).exists(), "nothing to back up the first time");
|
|
write_atomic(&p, b"two", true).unwrap();
|
|
assert_eq!(fs::read(&p).unwrap(), b"two");
|
|
assert_eq!(fs::read(backup_path(&p)).unwrap(), b"one");
|
|
write_atomic(&p, b"three", false).unwrap();
|
|
assert_eq!(fs::read(backup_path(&p)).unwrap(), b"one");
|
|
assert!(stale_temps(&p).is_empty());
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
|
|
/// A save stopped after any step leaves the old file whole (or the new one).
|
|
#[test]
|
|
fn a_save_stopped_part_way_keeps_the_old_file() {
|
|
let d = dir("stop");
|
|
let p = d.join("a.solidcraft");
|
|
write_atomic(&p, b"old", true).unwrap();
|
|
for stop in [Step::TempWritten, Step::BackupWritten, Step::Replaced] {
|
|
write_steps(&p, b"new content", true, Some(stop)).unwrap();
|
|
let now = fs::read(&p).unwrap();
|
|
assert!(now == b"old" || now == b"new content", "{stop:?}: {now:?}");
|
|
if stop < Step::Replaced {
|
|
assert_eq!(now, b"old");
|
|
assert!(!stale_temps(&p).is_empty(), "the unfinished save's temporary file is left over");
|
|
for t in stale_temps(&p) {
|
|
fs::remove_file(t).unwrap();
|
|
}
|
|
}
|
|
write_atomic(&p, b"old", false).unwrap();
|
|
}
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
|
|
#[test]
|
|
fn a_failed_write_leaves_the_target() {
|
|
let d = dir("fail");
|
|
let p = d.join("missing-dir").join("a.solidcraft");
|
|
assert!(write_atomic(&p, b"x", true).is_err());
|
|
assert!(!p.exists());
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
mod unix {
|
|
use super::*;
|
|
use std::os::unix::fs::{PermissionsExt, symlink};
|
|
|
|
fn mode(p: &Path) -> u32 {
|
|
fs::metadata(p).unwrap().permissions().mode() & 0o777
|
|
}
|
|
|
|
/// saving through a link replaces the file it points to and leaves the link.
|
|
#[test]
|
|
fn a_save_through_a_link_updates_the_target() {
|
|
let d = dir("link");
|
|
fs::create_dir_all(d.join("cloud")).unwrap();
|
|
fs::create_dir_all(d.join("work")).unwrap();
|
|
let target = d.join("cloud").join("a.solidcraft");
|
|
let link = d.join("work").join("a.solidcraft");
|
|
write_atomic(&target, b"one", false).unwrap();
|
|
symlink(&target, &link).unwrap();
|
|
write_atomic(&link, b"two", true).unwrap();
|
|
assert!(fs::symlink_metadata(&link).unwrap().file_type().is_symlink(), "the link stays a link");
|
|
assert_eq!(fs::read(&target).unwrap(), b"two");
|
|
assert_eq!(fs::read(&link).unwrap(), b"two");
|
|
assert_eq!(fs::read(backup_path(&target)).unwrap(), b"one", "the backup sits beside the real file");
|
|
assert!(!backup_path(&link).exists());
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
|
|
#[test]
|
|
fn relative_and_chained_links_are_followed() {
|
|
let d = dir("chain");
|
|
fs::create_dir_all(d.join("real")).unwrap();
|
|
fs::create_dir_all(d.join("mid")).unwrap();
|
|
let target = d.join("real").join("a.solidcraft");
|
|
write_atomic(&target, b"one", false).unwrap();
|
|
symlink("../real/a.solidcraft", d.join("mid").join("b")).unwrap();
|
|
symlink("mid/b", d.join("c")).unwrap();
|
|
write_atomic(&d.join("c"), b"two", false).unwrap();
|
|
assert_eq!(fs::read(&target).unwrap(), b"two");
|
|
assert!(fs::symlink_metadata(d.join("c")).unwrap().file_type().is_symlink());
|
|
assert!(fs::symlink_metadata(d.join("mid").join("b")).unwrap().file_type().is_symlink());
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
|
|
#[test]
|
|
fn a_dangling_link_is_filled_in_and_a_loop_is_an_error() {
|
|
let d = dir("dangling");
|
|
let link = d.join("a.solidcraft");
|
|
let target = d.join("later.solidcraft");
|
|
symlink(&target, &link).unwrap();
|
|
write_atomic(&link, b"new", true).unwrap();
|
|
assert_eq!(fs::read(&target).unwrap(), b"new");
|
|
assert!(fs::symlink_metadata(&link).unwrap().file_type().is_symlink());
|
|
|
|
let (x, y) = (d.join("x"), d.join("y"));
|
|
symlink(&y, &x).unwrap();
|
|
symlink(&x, &y).unwrap();
|
|
let e = write_atomic(&x, b"loop", true).unwrap_err();
|
|
assert!(e.to_string().contains("symbolic links"), "{e}");
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
|
|
/// a private design stays private, a group's file keeps the group's access, and
|
|
/// the backup carries the same permissions.
|
|
#[test]
|
|
fn a_save_keeps_the_permissions() {
|
|
let d = dir("mode");
|
|
for want in [0o600, 0o640, 0o664, 0o444] {
|
|
let p = d.join(format!("a{want:o}.solidcraft"));
|
|
write_atomic(&p, b"one", false).unwrap();
|
|
fs::set_permissions(&p, fs::Permissions::from_mode(want)).unwrap();
|
|
write_atomic(&p, b"two", true).unwrap();
|
|
assert_eq!(fs::read(&p).unwrap(), b"two");
|
|
assert_eq!(mode(&p), want, "{want:o}");
|
|
assert_eq!(mode(&backup_path(&p)), want, "backup {want:o}");
|
|
let _ = fs::set_permissions(&p, fs::Permissions::from_mode(0o644));
|
|
}
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
|
|
/// Where links work the backup is the old file itself, not a copy: its inode, its
|
|
/// modification time and its permissions, with one name again once the save is done;
|
|
/// where they are refused it is a copy with the old file's permissions.
|
|
#[test]
|
|
fn the_backup_is_the_old_file_linked_or_a_copy_where_links_are_refused() {
|
|
use std::os::unix::fs::MetadataExt;
|
|
for refused in [false, true] {
|
|
LINKS_REFUSED.with(|r| r.set(refused));
|
|
let d = fresh_dir(if refused { "inode-copied" } else { "inode-linked" });
|
|
let p = d.join("a.solidcraft");
|
|
write_atomic(&p, b"one", true).unwrap();
|
|
fs::set_permissions(&p, fs::Permissions::from_mode(0o640)).unwrap();
|
|
let old = fs::metadata(&p).unwrap();
|
|
write_atomic(&p, b"two", true).unwrap();
|
|
let bak = fs::metadata(backup_path(&p)).unwrap();
|
|
let new = fs::metadata(&p).unwrap();
|
|
assert_ne!(new.ino(), old.ino(), "the design file is a new file");
|
|
assert_eq!(bak.ino() == old.ino(), !refused, "linked: the backup is the old file");
|
|
if !refused {
|
|
assert_eq!(bak.modified().unwrap(), old.modified().unwrap(), "it keeps the old file's time");
|
|
}
|
|
assert_eq!((bak.nlink(), new.nlink()), (1, 1), "one name each once the save is done");
|
|
assert_eq!((mode(&p), mode(&backup_path(&p))), (0o640, 0o640), "refused {refused}");
|
|
assert_eq!(fs::read(backup_path(&p)).unwrap(), b"one");
|
|
}
|
|
LINKS_REFUSED.with(|r| r.set(false));
|
|
}
|
|
|
|
#[test]
|
|
fn a_save_through_a_link_keeps_the_targets_permissions() {
|
|
let d = dir("linkmode");
|
|
let target = d.join("a.solidcraft");
|
|
write_atomic(&target, b"one", false).unwrap();
|
|
fs::set_permissions(&target, fs::Permissions::from_mode(0o600)).unwrap();
|
|
symlink(&target, d.join("l")).unwrap();
|
|
write_atomic(&d.join("l"), b"two", true).unwrap();
|
|
assert_eq!(mode(&target), 0o600);
|
|
assert_eq!(mode(&backup_path(&target)), 0o600);
|
|
let _ = fs::remove_dir_all(&d);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod rename_retry_tests {
|
|
use super::*;
|
|
use std::cell::Cell;
|
|
#[test]
|
|
fn only_windows_sharing_or_access_errors_retry_with_an_exact_finite_budget() {
|
|
for code in [5, 32] {
|
|
let calls = Cell::new(0);
|
|
let mut waits = Vec::new();
|
|
let result = rename_with_retry(
|
|
|| {
|
|
calls.set(calls.get() + 1);
|
|
if calls.get() < 3 { Err(std::io::Error::from_raw_os_error(code)) } else { Ok(()) }
|
|
},
|
|
true,
|
|
|delay| waits.push(delay.as_millis()),
|
|
);
|
|
assert!(result.is_ok());
|
|
assert_eq!(calls.get(), 3);
|
|
assert_eq!(waits, [1, 2]);
|
|
let calls = Cell::new(0);
|
|
let mut waits = Vec::new();
|
|
let error = rename_with_retry(
|
|
|| {
|
|
calls.set(calls.get() + 1);
|
|
Err(std::io::Error::from_raw_os_error(code))
|
|
},
|
|
true,
|
|
|delay| waits.push(delay.as_millis()),
|
|
)
|
|
.unwrap_err();
|
|
assert_eq!(error.raw_os_error(), Some(code));
|
|
assert_eq!(calls.get(), 16);
|
|
assert_eq!(waits, [1, 2, 4, 8, 16, 32, 64, 128, 250, 250, 250, 250, 250, 250, 250]);
|
|
assert_eq!(waits.iter().sum::<u128>(), 2005);
|
|
}
|
|
for (windows, code) in [(false, 5), (false, 32), (true, 2), (true, 3), (true, 87), (true, 183)] {
|
|
let calls = Cell::new(0);
|
|
let error = rename_with_retry(
|
|
|| {
|
|
calls.set(calls.get() + 1);
|
|
Err(std::io::Error::from_raw_os_error(code))
|
|
},
|
|
windows,
|
|
|_| panic!("unexpected retry"),
|
|
)
|
|
.unwrap_err();
|
|
assert_eq!(calls.get(), 1);
|
|
assert_eq!(error.raw_os_error(), Some(code));
|
|
}
|
|
let mut calls = 0;
|
|
rename_with_retry(
|
|
|| {
|
|
calls += 1;
|
|
Ok(())
|
|
},
|
|
true,
|
|
|_| panic!("success must not wait"),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(calls, 1);
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
#[test]
|
|
fn native_windows_rename_preserves_old_bytes_until_a_reader_releases_delete_sharing() {
|
|
use std::os::windows::fs::OpenOptionsExt;
|
|
let directory = std::env::temp_dir().join(format!("solidcraft-rename-reader-release-{}", std::process::id()));
|
|
fs::create_dir(&directory).unwrap();
|
|
let old = directory.join("image.png");
|
|
let pending = directory.join("completed.tmp");
|
|
fs::write(&old, b"old complete image").unwrap();
|
|
write_synced(&pending, b"new complete image").unwrap();
|
|
let mut reader = Some(OpenOptions::new().read(true).share_mode(1).open(&old).unwrap());
|
|
let error = fs::rename(&pending, &old).unwrap_err();
|
|
assert!(matches!(error.raw_os_error(), Some(5 | 32)), "{error}");
|
|
let calls = Cell::new(0);
|
|
rename_with_retry(
|
|
|| {
|
|
calls.set(calls.get() + 1);
|
|
fs::rename(&pending, &old)
|
|
},
|
|
true,
|
|
|delay| {
|
|
assert_eq!(fs::read(&old).unwrap(), b"old complete image");
|
|
drop(reader.take());
|
|
std::thread::sleep(delay);
|
|
},
|
|
)
|
|
.unwrap();
|
|
assert!(calls.get() >= 2 && calls.get() <= 16);
|
|
assert_eq!(fs::read(&old).unwrap(), b"new complete image");
|
|
assert!(!pending.exists());
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
/// #8104: a scanner (antivirus, indexer, thumbnailer) that opens the target without delete
|
|
/// sharing and keeps it for a few hundred milliseconds under load delays the replace; it does
|
|
/// not fail it, and the old file stays whole until the new one takes its place.
|
|
#[cfg(windows)]
|
|
#[test]
|
|
fn a_reader_holding_the_target_for_a_while_delays_the_replace_without_failing_it() {
|
|
use std::os::windows::fs::OpenOptionsExt;
|
|
let directory = std::env::temp_dir().join(format!("solidcraft-rename-slow-reader-{}", std::process::id()));
|
|
let _ = fs::remove_dir_all(&directory);
|
|
fs::create_dir(&directory).unwrap();
|
|
let path = directory.join("library.json");
|
|
fs::write(&path, b"old whole library").unwrap();
|
|
let reader = OpenOptions::new().read(true).share_mode(1).open(&path).unwrap();
|
|
let scanner = std::thread::spawn(move || {
|
|
std::thread::sleep(std::time::Duration::from_millis(400));
|
|
drop(reader);
|
|
});
|
|
write_atomic(&path, b"new whole library", false).unwrap();
|
|
scanner.join().unwrap();
|
|
assert_eq!(fs::read(&path).unwrap(), b"new whole library");
|
|
assert!(stale_temps(&path).is_empty());
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
/// A read-only target is refused for good: the export fails at once with that reason, rather
|
|
/// than after the wait for a program holding the file, and the old file is kept.
|
|
#[cfg(windows)]
|
|
#[test]
|
|
fn a_read_only_target_fails_at_once_and_says_so() {
|
|
let directory = std::env::temp_dir().join(format!("solidcraft-rename-read-only-{}", std::process::id()));
|
|
let _ = fs::remove_dir_all(&directory);
|
|
fs::create_dir(&directory).unwrap();
|
|
let path = directory.join("render.png");
|
|
fs::write(&path, b"old image").unwrap();
|
|
let writable = fs::metadata(&path).unwrap().permissions();
|
|
let mut read_only = writable.clone();
|
|
read_only.set_readonly(true);
|
|
fs::set_permissions(&path, read_only).unwrap();
|
|
let started = std::time::Instant::now();
|
|
let error = write_atomic(&path, b"new image", false).unwrap_err();
|
|
assert!(started.elapsed() < std::time::Duration::from_millis(1000), "{:?}", started.elapsed());
|
|
assert!(error.to_string().contains("the file is read-only"), "{error}");
|
|
assert!(error.to_string().contains(&std::io::Error::from_raw_os_error(5).to_string()), "{error}");
|
|
assert_eq!(fs::read(&path).unwrap(), b"old image");
|
|
assert!(stale_temps(&path).is_empty());
|
|
fs::set_permissions(&path, writable).unwrap();
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
#[test]
|
|
fn persistent_native_lock_is_an_error_without_destroying_or_bypassing_the_target() {
|
|
use std::os::windows::fs::OpenOptionsExt;
|
|
let directory = std::env::temp_dir().join(format!("solidcraft-rename-persistent-reader-{}", std::process::id()));
|
|
fs::create_dir(&directory).unwrap();
|
|
let path = directory.join("image.exr");
|
|
fs::write(&path, b"old whole raw master").unwrap();
|
|
let reader = OpenOptions::new().read(true).share_mode(1).open(&path).unwrap();
|
|
let error = write_atomic(&path, b"new whole raw master", false).unwrap_err();
|
|
assert!(error.to_string().contains("another program may have it open, or it is read-only"), "{error}");
|
|
assert_eq!(error.kind(), std::io::Error::from_raw_os_error(5).kind());
|
|
assert_eq!(fs::read(&path).unwrap(), b"old whole raw master");
|
|
assert!(stale_temps(&path).is_empty());
|
|
drop(reader);
|
|
write_atomic(&path, b"new whole raw master", false).unwrap();
|
|
assert_eq!(fs::read(&path).unwrap(), b"new whole raw master");
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
}
|