From fe058b3356edcad7f3d069a4e84af1bbedffada6 Mon Sep 17 00:00:00 2001 From: tv Date: Sun, 15 Nov 2026 18:44:42 +0000 Subject: remakes: a chain replayed to what its part of the replay ends at A rejoin replays in two parts: what was written before it began, then what was written during it. A chain to a signed value was read to what the old document reads now, from the envelopes written within the part: a value written again during the rejoin made the first part's chain lead to an envelope that part doesn't hold, and the second part's start from one it doesn't either. Both were quarantined, and the new epoch kept the base's value. Each part's chain now leads to what the old document reads where that part ends. --- src/remake/delta.rs | 55 +++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 51 insertions(+), 4 deletions(-) (limited to 'src/remake') diff --git a/src/remake/delta.rs b/src/remake/delta.rs index c8e07c0..78a8097 100644 --- a/src/remake/delta.rs +++ b/src/remake/delta.rs @@ -148,7 +148,7 @@ pub(crate) fn replay_newest( // written at the same time (it may decide who may write that). let mut links: BTreeMap<(i64, usize), (Vec, String, String)> = BTreeMap::new(); for place in signed { - match chain(src, &changes, &place, dst) { + match chain(src, after, &changes, &place, dst) { Chain::Links(chain) => { // In their order, whatever their clocks say. let mut at = i64::MIN; @@ -404,13 +404,23 @@ enum Chain { } /// The chain of envelopes `src` holds at `place` (written by `changes`) that leads from -/// what `dst` holds there to what `src` reads there, following `prev`. -fn chain(src: &Document, changes: &[ChangeHash], place: &[String], dst: &Document) -> Chain { +/// what `dst` holds there to what `src` reads there at `after`, where the replay ends, +/// following `prev`. +fn chain( + src: &Document, + after: &[ChangeHash], + changes: &[ChangeHash], + place: &[String], + dst: &Document, +) -> Chain { let raw = |doc: &dyn Fn() -> Option| match doc() { Some(serde_json::Value::String(text)) => Some(text), _ => None, }; - let Some(target) = raw(&|| store::read_path(src, place).ok().flatten()) else { + let Some(end) = At::new(src, after) else { + return Chain::Broken("the replay's end isn't in the old document".to_owned()); + }; + let Some(target) = raw(&|| store::read_path(&end, place).ok().flatten()) else { return Chain::Broken("no value its user signed is there to replay".to_owned()); }; let Ok(payload) = envelope::read(&target) else { @@ -1179,6 +1189,43 @@ mod tests { assert!(stats.quarantined.is_empty()); } + /// Replayed in two parts, as a rejoin does (what was written before it began, then + /// what was written during it): each part's chain leads to what the old document + /// reads where that part ends. + #[test] + fn signed_values_replay_in_parts() { + let key = ed25519_dalek::SigningKey::from_bytes(&[7; 32]); + let mut old = strict_with(&key); + let first = signed_after(&key, None, 1); + alice_writes(&mut old, 5, &first); + let base = old.get_heads(); + let mut replayed = old.clone().with_actor(automerge::ActorId::random()); + let second = signed_after(&key, Some(&first), 2); + alice_writes(&mut old, 10, &second); + let began = old.get_heads(); + let third = signed_after(&key, Some(&second), 3); + alice_writes(&mut old, 20, &third); + let fourth = signed_after(&key, Some(&third), 4); + alice_writes(&mut old, 30, &fourth); + for (from, to) in [(&base, &began), (&began, &old.get_heads())] { + let stats = replay_newest( + &old, + from, + to, + &mut replayed, + crate::document::replica::Epoch::GENESIS, + "node", + &Translator::default(), + Superseded::Drop, + ); + assert!(stats.quarantined.is_empty(), "{:?}", stats.quarantined); + } + assert_eq!( + store::read_candidates(&replayed, &["config".to_owned()]).unwrap(), + [json!(fourth)] + ); + } + /// 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] -- cgit v1.3.1