From 12805eb32f0a236d5e28866c03ebc3bef3f72247 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sat, 3 Oct 2026 01:28:47 +0200 Subject: [PATCH] CultCache Rust: a soft push_all asks the one reader, as TypeScript's does Absent writes, a store it reads is left byte for byte, and anything the reader refuses (an unreadable file, a dangling link) is refused. The readability manifest walk now runs a soft flush over every vector, so TypeScript and Rust are pinned by the same files. Co-Authored-By: Claude Sonnet 5.5 --- packages/cultcache-rs/src/lib.rs | 62 ++++++++++++++++--- .../readability/manifest.txt | 2 +- 2 files changed, 54 insertions(+), 10 deletions(-) diff --git a/packages/cultcache-rs/src/lib.rs b/packages/cultcache-rs/src/lib.rs index fae1e7f9..94e43396 100644 --- a/packages/cultcache-rs/src/lib.rs +++ b/packages/cultcache-rs/src/lib.rs @@ -549,6 +549,8 @@ impl std::error::Error for CultCacheStoreWriteFailed {} #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct PushAllOptions { + /// Seed the store only where nothing is: a single-file flush writes when nothing is at the path, leaves a store it can + /// read byte for byte, and refuses what its reader refuses (a dangling link included), as a plain flush refuses. pub soft: bool, } @@ -934,7 +936,7 @@ impl SingleFileMessagePackBackingStore { let bytes = match fs::read(&self.path) { Ok(bytes) => bytes, Err(error) if error.kind() == std::io::ErrorKind::NotFound && is_absent(&self.path)? => { - return Ok(DiskStore::empty()); + return Ok(DiskStore::absent()); } Err(error) => { return Err(anyhow::Error::new(error) @@ -991,7 +993,7 @@ impl SingleFileMessagePackBackingStore { // A dangling link holds no store, so a whole-file replace has no header to keep and replaces the link (R3 pins // this). The only NotFound the reader returns is that one: a merging writer has already refused it when it // read the current entries. - Err(error) if io_not_found(&error) => DiskStore::empty(), + Err(error) if io_not_found(&error) => DiskStore::absent(), other => other?, }; let bytes = encode_store_snapshot(entries, &disk) @@ -1263,8 +1265,14 @@ impl CacheBackingStore for SingleFileMessagePackBackingStore { }) } - fn push_all(&mut self, entries: &[CultCacheEnvelope], _options: PushAllOptions) -> Result<()> { + fn push_all(&mut self, entries: &[CultCacheEnvelope], options: PushAllOptions) -> Result<()> { self.with_exclusive_lock(|| { + // A soft flush asks the one reader: nothing at the path is written, a store it reads is left alone, and anything + // the reader refuses (an unreadable file, a dangling link) is refused here as it is for open. + if options.soft && !self.read_store_unlocked()?.absent { + return Ok(()); + } + let mut entries = entries.to_vec(); entries.sort_by_key(entry_id); self.write_all_unlocked(&entries) @@ -2896,24 +2904,26 @@ fn decode_store_file(bytes: &[u8], header: Option<&str>) -> Result { let format = readable_store_format(header) .ok_or_else(|| anyhow!("the first slot is not a store header this runtime reads"))?; let (envelopes, catalog) = decode_store_snapshot(bytes)?; - Ok(DiskStore { format, envelopes, catalog }) + Ok(DiskStore { absent: false, format, envelopes, catalog }) } - None => Ok(DiskStore { format: STORE_FORMAT_V1, envelopes: decode_legacy_envelopes(bytes)?, catalog: Vec::new() }), + None => Ok(DiskStore { absent: false, format: STORE_FORMAT_V1, envelopes: decode_legacy_envelopes(bytes)?, catalog: Vec::new() }), } } /// What a store file holds, as its one reader decoded it: the header a rewrite keeps, its envelopes, and the catalog entries it /// publishes them by, which a rewrite lays back for the ids they name. struct DiskStore { + /// Nothing was at the path; the other fields describe an empty v1 store. + absent: bool, format: &'static str, envelopes: Vec, catalog: Vec, } impl DiskStore { - /// A file that is gone: an empty v1 store. - fn empty() -> Self { - Self { format: STORE_FORMAT_V1, envelopes: Vec::new(), catalog: Vec::new() } + /// A file that is gone, or a dangling link a whole-file replace is about to replace: an empty v1 store. + fn absent() -> Self { + Self { absent: true, format: STORE_FORMAT_V1, envelopes: Vec::new(), catalog: Vec::new() } } } @@ -5136,18 +5146,24 @@ mod tests { let bytes = std::fs::read(root.join(vector))?; // A v3 store keeps its marker through a rewrite; every other file that reads is written v1. let header = if vector.contains("v3") { "cultcache.store.v3" } else { STORE_FORMAT_V1 }; - for operation in ["open", "push_all", "push"] { + for operation in ["open", "soft_push_all", "push_all", "push"] { let temp = tempfile::tempdir()?; let path = temp.path().join("store.msgpack"); std::fs::write(&path, &bytes)?; let mut store = SingleFileMessagePackBackingStore::new(&path); let outcome = match operation { "open" => store.pull_all().map(|_| ()), + "soft_push_all" => store.push_all(&[snapshot_envelope("x", b"one")], PushAllOptions { soft: true }), "push_all" => store.push_all(&[snapshot_envelope("x", b"one")], PushAllOptions::default()), _ => store.push(&snapshot_envelope("x", b"one")), }; let what = format!("{vector} {operation}"); assert_eq!(outcome.is_ok(), reads, "{what}: {outcome:?}"); + if operation == "soft_push_all" && reads { + // A soft flush leaves a store it reads byte for byte. + assert_eq!(std::fs::read(&path)?, bytes, "{what} rewrote a store it reads"); + continue; + } if !reads { let error = outcome.unwrap_err(); let expected = if vector == "header-v9.bin" { @@ -5998,6 +6014,34 @@ mod tests { Ok(()) } + // The two cases the vectors cannot hold: nothing at the path is written, and a dangling link is refused and left as it is. + #[test] + fn a_soft_push_all_writes_where_nothing_is_and_refuses_a_dangling_link() -> Result<()> { + let temp = tempfile::tempdir()?; + let path = temp.path().join("store.cc"); + SingleFileMessagePackBackingStore::new(&path).push_all(&[snapshot_envelope("a", b"1")], PushAllOptions { soft: true })?; + let seeded = fs::read(&path)?; + let mut store = SingleFileMessagePackBackingStore::new(&path); + assert_eq!(store.pull_all()?.len(), 1); + store.push_all(&[snapshot_envelope("b", b"2")], PushAllOptions { soft: true })?; + assert_eq!(fs::read(&path)?, seeded, "a soft flush over a store it reads wrote"); + + #[cfg(unix)] + { + let volume = temp.path().join("volume"); + fs::create_dir(&volume)?; + let link = temp.path().join("dangling.cc"); + std::os::unix::fs::symlink(volume.join("store.cc"), &link)?; + let error = SingleFileMessagePackBackingStore::new(&link) + .push_all(&[snapshot_envelope("a", b"1")], PushAllOptions { soft: true }) + .unwrap_err(); + assert!(io_not_found(&error), "{error:#}"); + assert!(fs::symlink_metadata(&link)?.file_type().is_symlink(), "the link was replaced"); + assert_eq!(fs::read_dir(&volume)?.count(), 0, "nothing reached the link's volume"); + } + Ok(()) + } + #[cfg(unix)] #[test] fn r3_decides_resolve_or_refuse_a_push_all_through_a_dangling_link_replaces_the_link() -> Result<()> { diff --git a/tests/vectors/document-variants-c2a/readability/manifest.txt b/tests/vectors/document-variants-c2a/readability/manifest.txt index 6e42b894..dd1fc4b4 100644 --- a/tests/vectors/document-variants-c2a/readability/manifest.txt +++ b/tests/vectors/document-variants-c2a/readability/manifest.txt @@ -1,4 +1,4 @@ -# Whether each runtime's own reader opens the file. A flush and a commit replace a file exactly when it reads. +# Whether each runtime's own reader opens the file. A flush and a commit replace a file exactly when it reads; where a runtime has a soft flush (TypeScript, Rust) it leaves a file that reads byte for byte and refuses one that does not. # Columns: file, csharp, rust, typescript, python. `../v3-base.msgpack` is the one valid store. ../v3-base.msgpack reads reads reads reads zero-byte.bin refuses refuses refuses refuses