aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-16 02:13:20 +0000
committertv <tv@krebsco.de>2026-11-16 02:13:20 +0000
commitec96187b9cfa86a0f66208d15c80bacecce42fb3 (patch)
treebde27bc6ad6d54deba8de245252121bac977aece
parent0afc17ab0c6e0e34ce63c33db736e4fe59305c12 (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.
-rw-r--r--src/remake/delta.rs89
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]