diff options
Diffstat (limited to 'src/federation/store/memory.rs')
| -rw-r--r-- | src/federation/store/memory.rs | 69 |
1 files changed, 22 insertions, 47 deletions
diff --git a/src/federation/store/memory.rs b/src/federation/store/memory.rs index 6a67bfa..8f97299 100644 --- a/src/federation/store/memory.rs +++ b/src/federation/store/memory.rs @@ -113,31 +113,27 @@ impl<F: Fold> Store<F> { }) } - /// The root of a fork at heads of one store or of several, each given with its heads, - /// made by `spec`: its bytes, and those of the events it keeps. A fork at heads of - /// several stores merges them. + /// The root of a fork at `heads`, which the store holds, made by `spec`: its bytes, and + /// those of the events it keeps. pub(crate) fn fork( - sides: &[(&Self, &[Id])], + &self, + heads: &[Id], spec: &[u8], ) -> Result<(Vec<u8>, Vec<Vec<u8>>), Refused> { - let mut states = Vec::new(); - let mut heads = BTreeSet::new(); - for (store, at) in sides { - if let Some(head) = at.iter().find(|head| !store.holds(head)) { - return Err(Refused::new(format!("{head} isn't held there"))); - } - states.push(store.state_at(at)); - heads.extend(at.iter().copied()); + if let Some(head) = heads.iter().find(|head| !self.holds(head)) { + return Err(Refused::new(format!("{head} isn't held here"))); } - let heads: Vec<Id> = heads.into_iter().collect(); - let states: Vec<&F::State> = states.iter().collect(); - let (root, keeps) = F::fork(&states, &heads, spec)?; + let heads: Vec<Id> = heads + .iter() + .copied() + .collect::<BTreeSet<_>>() + .into_iter() + .collect(); + let (root, keeps) = F::fork(&self.state_at(&heads), &heads, spec)?; let kept = keeps .iter() .map(|id| { - sides - .iter() - .find_map(|(store, _)| store.get(id)) + self.get(id) .map(<[u8]>::to_vec) .ok_or_else(|| Refused::new(format!("{id} isn't held"))) }) @@ -145,10 +141,10 @@ impl<F: Fold> Store<F> { Ok((root, kept)) } - /// Whether `root` is the root of the fork at those heads, made by `spec`, as a node - /// holding them builds it. - pub(crate) fn checks_fork(sides: &[(&Self, &[Id])], spec: &[u8], root: &[u8]) -> bool { - Self::fork(sides, spec).is_ok_and(|(built, _)| built == root) + /// Whether `root` is the root of the fork at `heads`, made by `spec`, as this store + /// builds it. + pub(crate) fn checks_fork(&self, heads: &[Id], spec: &[u8], root: &[u8]) -> bool { + self.fork(heads, spec).is_ok_and(|(built, _)| built == root) } /// Whether the store holds an event: taken after its checkpoint, or one of its heads. @@ -816,14 +812,11 @@ mod tests { let root = store.id(); let here = taken(store.offer(testfold::put(&[root], "a", "1"))); let spec = testfold::fork_spec(1, "fork"); - let (fork_root, kept) = Store::fork(&[(&store, &[here])], &spec).expect("a fork"); + let (fork_root, kept) = store.fork(&[here], &spec).expect("a fork"); let mut fork: Store<TestFold> = Store::new(fork_root.clone(), kept).expect("its root"); - assert!(Store::checks_fork(&[(&store, &[here])], &spec, &fork_root)); - assert!(!Store::checks_fork( - &[(&store, &[here])], - &testfold::fork_spec(2, "fork"), - &fork_root - )); + assert!(store.checks_fork(&[here], &spec, &fork_root)); + assert!(!store.checks_fork(&[here], &testfold::fork_spec(2, "fork"), &fork_root)); + assert!(store.fork(&[Id::of(b"nothing held")], &spec).is_err()); assert_eq!(fork.state().counts()["a"], "1"); assert_eq!(fork.state().era(), (1, Some(&"fork".to_owned()))); let stayed = testfold::put(&[here], "a", "2"); @@ -837,24 +830,6 @@ mod tests { } #[test] - fn a_merge_keeps_each_sides_values_the_lower_id_across() { - let mut left = store(); - let mut right: Store<TestFold> = - Store::new(testfold::root("other"), Vec::new()).expect("a root"); - let l = taken(left.offer(testfold::put(&[left.id()], "a", "left"))); - let only = taken(left.offer(testfold::put(&[l], "b", "left"))); - let r = taken(right.offer(testfold::put(&[right.id()], "a", "right"))); - let spec = testfold::fork_spec(1, "merge"); - let (merge_root, kept) = - Store::fork(&[(&left, &[only]), (&right, &[r])], &spec).expect("a merge"); - let merged: Store<TestFold> = Store::new(merge_root, kept).expect("its root"); - let lower = if l < r { "left" } else { "right" }; - assert_eq!(merged.state().counts()["a"], lower); - assert_eq!(merged.state().counts()["b"], "left"); - assert!(Store::fork(&[(&left, &[r])], &spec).is_err()); - } - - #[test] fn an_event_waits_until_all_it_builds_on_is_held() { let mut store = store(); let root = store.id(); |
