Six durability experiments of 3 October 2026: results, raw output, the two prototypes, the runner
f8975ed verified | //! dspike: the core a durability module needs, small enough to compare two languages on. | |
| //! | |
| //! dspike append FILE TEXT one line appended and on the disk before it returns | |
| //! dspike replace FILE TEXT the file replaced atomically: never half, never lost | |
| //! dspike stage SRC DST a consistent copy of a live SQLite database, checked | |
| //! dspike checkpoint DB every committed change into the main file, the log emptied | |
| use std::error::Error; | |
| use std::fs::{self, File, OpenOptions}; | |
| use std::io::Write; | |
| use std::path::{Path, PathBuf}; | |
| use std::time::Duration; | |
| use rusqlite::{backup::Backup, Connection, OpenFlags}; | |
| type Res<T> = Result<T, Box<dyn Error>>; | |
| fn append_line(path: &Path, text: &str) -> Res<()> { | |
| let mut f = OpenOptions::new().append(true).create(true).open(path)?; | |
| f.write_all(text.as_bytes())?; | |
| f.write_all(b"\n")?; | |
| f.sync_data()?; // fdatasync: the data and the size, not the timestamps | |
| Ok(()) | |
| } | |
| fn sync_dir(dir: &Path) -> Res<()> { | |
| File::open(dir)?.sync_all()?; | |
| Ok(()) | |
| } | |
| fn parent(path: &Path) -> PathBuf { | |
| match path.parent() { | |
| Some(p) if !p.as_os_str().is_empty() => p.to_path_buf(), | |
| _ => PathBuf::from("."), | |
| } | |
| } | |
| /// Removes the temporary file unless told the rename happened: a half file never stays. | |
| struct Tmp { | |
| path: PathBuf, | |
| keep: bool, | |
| } | |
| impl Drop for Tmp { | |
| fn drop(&mut self) { | |
| if !self.keep { | |
| let _ = fs::remove_file(&self.path); | |
| } | |
| } | |
| } | |
| fn replace(path: &Path, text: &str) -> Res<()> { | |
| let dir = parent(path); | |
| let name = format!("{}.tmp{}", path.file_name().ok_or("no file name")?.to_string_lossy(), std::process::id()); | |
| let mut tmp = Tmp { path: dir.join(name), keep: false }; | |
| let mut f = OpenOptions::new().write(true).create_new(true).open(&tmp.path)?; | |
| f.write_all(text.as_bytes())?; | |
| f.sync_all()?; | |
| drop(f); | |
| fs::rename(&tmp.path, path)?; | |
| tmp.keep = true; | |
| sync_dir(&dir) // the rename itself is on the disk only after this | |
| } | |
| fn stage(src: &Path, dst: &Path) -> Res<()> { | |
| let mut tmp = Tmp { path: PathBuf::from(format!("{}.tmp", dst.display())), keep: false }; | |
| let _ = fs::remove_file(&tmp.path); | |
| let from = Connection::open_with_flags(src, OpenFlags::SQLITE_OPEN_READ_ONLY)?; | |
| from.busy_timeout(Duration::from_secs(30))?; | |
| { | |
| let mut to = Connection::open(&tmp.path)?; | |
| // one step of all pages. `run_to_completion` panics on -1 (its wrapper wants a positive page count), | |
| // which the first version of this file found out at run time. | |
| Backup::new(&from, &mut to)?.step(-1)?; | |
| let check: String = to.query_row("PRAGMA quick_check", [], |r| r.get(0))?; | |
| if check != "ok" { | |
| return Err(format!("the copy does not pass quick_check: {check}").into()); | |
| } | |
| } | |
| File::open(&tmp.path)?.sync_all()?; | |
| fs::rename(&tmp.path, dst)?; | |
| tmp.keep = true; | |
| sync_dir(&parent(dst)) | |
| } | |
| fn checkpoint(path: &Path) -> Res<()> { | |
| let db = Connection::open(path)?; | |
| db.busy_timeout(Duration::from_secs(5))?; | |
| let busy: i64 = db.query_row("PRAGMA wal_checkpoint(TRUNCATE)", [], |r| r.get(0))?; | |
| if busy != 0 { | |
| return Err("the database still has a writer".into()); | |
| } | |
| println!("checkpointed {}", path.display()); | |
| Ok(()) | |
| } | |
| fn main() { | |
| let a: Vec<String> = std::env::args().skip(1).collect(); | |
| let a: Vec<&str> = a.iter().map(String::as_str).collect(); | |
| let done = match a.as_slice() { | |
| ["append", file, text] => append_line(Path::new(file), text), | |
| ["replace", file, text] => replace(Path::new(file), text), | |
| ["stage", src, dst] => stage(Path::new(src), Path::new(dst)), | |
| ["checkpoint", db] => checkpoint(Path::new(db)), | |
| _ => { | |
| eprintln!("usage: dspike append FILE TEXT | replace FILE TEXT | stage SRC DST | checkpoint DB"); | |
| std::process::exit(2); | |
| } | |
| }; | |
| if let Err(e) = done { | |
| eprintln!("dspike: {e}"); | |
| std::process::exit(1); | |
| } | |
| } | |