diff options
| author | tv <tv@krebsco.de> | 2026-11-16 02:13:20 +0000 |
|---|---|---|
| committer | tv <tv@krebsco.de> | 2026-11-16 02:13:20 +0000 |
| commit | ec96187b9cfa86a0f66208d15c80bacecce42fb3 (patch) | |
| tree | bde27bc6ad6d54deba8de245252121bac977aece /src/remake | |
| parent | 0afc17ab0c6e0e34ce63c33db736e4fe59305c12 (diff) | |
remakes: a map made on the way names no group's user
Under a strict policy a group of other writes goes as, and is named for,
the last change by history that touched its path, at it, below it or
above it. A change writing its first entry makes the maps above it on
the way, and touches them: where two users wrote their first entries
below one map at once, each making it, the later change touched the
other's path, and the other's write was replayed as its user's, refused
by every node, quarantined.
The change a group goes as is the last that wrote at its path or below
it, or replaced what was at a path above it (`last_written`): one that
made a map above it, finding nothing there at its history, didn't.
Swarms that aren't strict don't ask.
Diffstat (limited to 'src/remake')
| -rw-r--r-- | src/remake/delta.rs | 89 |
1 files changed, 79 insertions, 10 deletions
diff --git a/src/remake/delta.rs b/src/remake/delta.rs index 327249b..c3688cb 100644 --- a/src/remake/delta.rs +++ b/src/remake/delta.rs @@ -138,9 +138,9 @@ pub(crate) fn replay_newest( .map(|path| { let at = newest(&written, path).map_or(0, |(at, _)| at); // Under a strict policy, the user of the change it goes as: the last by - // history that touched it (`last_written`). + // history that wrote it (`last_written`). let user = if strict { - last_written(&written, path).and_then(|made| written[made].1.clone()) + last_written(src, &changes, &written, path).and_then(|made| written[made].1.clone()) } else { writer(&written, path) }; @@ -212,7 +212,7 @@ pub(crate) fn replay_newest( } _ => { let goes = if strict { - last_written(&written, &path).map_or(0, |made| made as i64) + last_written(src, &changes, &written, &path).map_or(0, |made| made as i64) } else { at }; @@ -638,16 +638,30 @@ fn touched(doc: &Document, changes: &[ChangeHash]) -> Vec<Touched> { .collect() } -/// Where, among the changes `written` is of (`touched`, in their order), the last that -/// touched `path`, a path above it or one below it, is. -fn last_written(written: &[Touched], path: &[String]) -> Option<usize> { - written.iter().rposition(|(_, _, paths)| { - paths - .iter() - .any(|other| other.starts_with(path) || path.starts_with(other)) +/// Where, among `changes` (in `src`; `written` is theirs, `touched`, in their order), the +/// last that wrote at `path` or below it, or replaced what was at a path above it, is: a +/// map one made on the way, where it found none, is no write of that change's at `path`. +fn last_written( + src: &Document, + changes: &[ChangeHash], + written: &[Touched], + path: &[String], +) -> Option<usize> { + (0..written.len()).rev().find(|&made| { + written[made].2.iter().any(|other| { + other.starts_with(path) + || path.starts_with(other) && found_at(src, &changes[made], other) + }) }) } +/// Whether the change `hash` (in `doc`) found something at `path` where it was made. +fn found_at(doc: &Document, hash: &ChangeHash, path: &[String]) -> bool { + doc.get_change_by_hash(hash) + .and_then(|change| At::new(doc, change.deps())) + .is_some_and(|before| matches!(store::read_held(&before, path), Ok(Some(_)))) +} + /// The time and user of the newest of `changes` that touched `path`, a path above it or /// one below it (of two at once, the user named last in order). fn newest(changes: &[Touched], path: &[String]) -> Option<(i64, Option<String>)> { @@ -1442,6 +1456,61 @@ mod tests { assert_eq!(written, [vec![path("config")], vec![path("notes")]]); } + /// Under a strict policy, a map made on the way is no write of the change that made it + /// at what another wrote below it: two users writing their first entries at once, each + /// making the map above them, each have theirs replayed as their own. + #[test] + fn maps_made_on_the_way_name_no_user() { + use crate::access::Right; + let path = |text: &str| -> Vec<String> { text.split('/').map(str::to_owned).collect() }; + let key = ed25519_dalek::SigningKey::from_bytes(&[7; 32]); + let mut old = strict_with(&key); + change(&mut old, |doc| { + for (user, entry) in [("alice", "servers/eu"), ("bob", "servers/us")] { + let rights = crate::access::registry::entry( + "root", + 1, + &[(path(entry), &[Right::Write][..])], + ); + store::write_path(doc, &path(&format!("_continuum/users/{user}")), &rights) + .unwrap(); + } + }); + let base = old.get_heads(); + let mut replayed = old.clone().with_actor(automerge::ActorId::random()); + let mut bob = old.clone().with_actor(automerge::ActorId::random()); + for (doc, user, entry, at) in [ + (&mut old, "alice", "servers/eu", 10), + (&mut bob, "bob", "servers/us", 20), + ] { + let mut transaction = doc.transaction(); + store::write_path(&mut transaction, &path(entry), &json!(1)).unwrap(); + transaction.commit_with( + automerge::transaction::CommitOptions::default() + .with_time(at) + .with_message(format!("User: {user}")), + ); + } + old.merge(&mut bob).unwrap(); + let stats = replay_newest( + &old, + &base, + &old.get_heads(), + &mut replayed, + crate::document::replica::Epoch::GENESIS, + "node", + &Translator::default(), + Superseded::Drop, + ); + assert!(stats.quarantined.is_empty(), "{:?}", stats.quarantined); + for entry in ["servers/eu", "servers/us"] { + assert_eq!( + store::read_path(&replayed, &path(entry)).unwrap(), + Some(json!(1)) + ); + } + } + /// The first group refused: those after it still replayed, still the node's (a /// fork, taking the refused one back, has no author of its own). #[test] |
