aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/federation/store/memory.rs69
-rw-r--r--src/federation/store/mod.rs4
-rw-r--r--src/federation/store/testfold.rs15
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))