diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/federation/store/memory.rs | 69 | ||||
| -rw-r--r-- | src/federation/store/mod.rs | 4 | ||||
| -rw-r--r-- | src/federation/store/testfold.rs | 15 |
3 files changed, 27 insertions, 61 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(); diff --git a/src/federation/store/mod.rs b/src/federation/store/mod.rs index c87f337..b11c81a 100644 --- a/src/federation/store/mod.rs +++ b/src/federation/store/mod.rs @@ -97,9 +97,9 @@ pub(crate) trait Fold { /// The state a checkpoint reads as, with the events it keeps. fn start(checkpoint: &[u8], kept: &[(Id, Vec<u8>)]) -> Result<Self::State, Refused>; - /// The root of a fork at `heads` of the stores reading as `at`, made by `spec`: its + /// The root of a fork at `heads` of the store reading as `at`, made by `spec`: its /// bytes, and the events it keeps. - fn fork(at: &[&Self::State], heads: &[Id], spec: &[u8]) -> Result<(Vec<u8>, Vec<Id>), Refused>; + fn fork(at: &Self::State, heads: &[Id], spec: &[u8]) -> Result<(Vec<u8>, Vec<Id>), Refused>; /// The heads of a later checkpoint, where a store reading as `now` moves to one. fn moves_to(now: &Self::State) -> Option<Vec<Id>>; diff --git a/src/federation/store/testfold.rs b/src/federation/store/testfold.rs index 094c424..bbe0307 100644 --- a/src/federation/store/testfold.rs +++ b/src/federation/store/testfold.rs @@ -406,19 +406,10 @@ impl Fold for TestFold { Ok(state) } - fn fork(at: &[&State], heads: &[Id], spec: &[u8]) -> Result<(Vec<u8>, Vec<Id>), Refused> { + fn fork(at: &State, heads: &[Id], spec: &[u8]) -> Result<(Vec<u8>, Vec<Id>), Refused> { let (era, tag): (u64, String) = serde_json::from_slice(spec).map_err(|_| Refused::new("no spec"))?; - let mut counting: BTreeMap<String, Id> = BTreeMap::new(); - let mut locks = BTreeSet::new(); - for state in at { - for (key, id) in state.counting() { - let lowest = counting.entry(key).or_insert(id); - *lowest = (*lowest).min(id); - } - locks.extend(state.locks.iter().cloned()); - } - let keeps: Vec<Id> = counting.into_values().collect(); + let keeps: Vec<Id> = at.counting().into_values().collect(); let root = Checkpoint { name: String::new(), at: hex(heads.iter().copied()), @@ -426,7 +417,7 @@ impl Fold for TestFold { era, tag, cut: 0, - locks: locks.into_iter().collect(), + locks: at.locks.iter().cloned().collect(), }; let bytes = serde_json::to_vec(&root).expect("a root encodes"); Ok((bytes, keeps)) |
