aboutsummaryrefslogtreecommitdiffstats
path: root/src/federation/store/memory.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/federation/store/memory.rs')
-rw-r--r--src/federation/store/memory.rs54
1 files changed, 54 insertions, 0 deletions
diff --git a/src/federation/store/memory.rs b/src/federation/store/memory.rs
index 80d428e..ec25b14 100644
--- a/src/federation/store/memory.rs
+++ b/src/federation/store/memory.rs
@@ -538,6 +538,33 @@ impl<F: Fold> Store<F> {
}
}
+ /// Itself, refusing `own` as its node refused them of its own and `dropped` as its
+ /// operator had it drop them: a store read anew, before anything is offered to it,
+ /// refuses what its node refused so before, whatever order the events come in
+ /// (`docs/store.md`, A node's own).
+ pub(crate) fn refusing(mut self, own: &[Id], dropped: &[Id]) -> Self {
+ self.refused
+ .extend(own.iter().map(|id| (*id, Refusal::Own)));
+ self.refused
+ .extend(dropped.iter().map(|id| (*id, Refusal::Dropped)));
+ self
+ }
+
+ /// What its node refused of its own, and what its operator had it drop.
+ pub(crate) fn own(&self) -> (Vec<Id>, Vec<Id>) {
+ let of = |refusal: Refusal| {
+ let mut ids: Vec<Id> = self
+ .refused
+ .iter()
+ .filter(|(_, why)| **why == refusal)
+ .map(|(id, _)| *id)
+ .collect();
+ ids.sort_unstable();
+ ids
+ };
+ (of(Refusal::Own), of(Refusal::Dropped))
+ }
+
/// Refuses an event, and what waits for it.
fn refuse(&mut self, id: Id, why: Refusal) -> Offered {
self.refused.insert(id, why.clone());
@@ -722,6 +749,33 @@ mod tests {
assert!(store.drop_taken(&[root]).is_err());
}
+ #[test]
+ fn a_store_read_anew_refuses_what_its_node_refused_of_its_own() {
+ let mut store = store();
+ let root = store.id();
+ let one = testfold::era(&[root], 1, "one");
+ let other = testfold::era(&[root], 1, "other");
+ let dropped = taken(store.offer(testfold::put(&[root], "b", "1")));
+ taken(store.offer(one.clone()));
+ assert_eq!(store.offer(other.clone()), Offered::Refused(Refusal::Own));
+ store.drop_taken(&[dropped]).unwrap();
+ let (own, drops) = store.own();
+ assert_eq!(
+ (own.as_slice(), drops.as_slice()),
+ (&[Id::of(&other)][..], &[dropped][..])
+ );
+ // Read anew, the other era first: refused as before.
+ let mut anew = self::store().refusing(&own, &drops);
+ assert_eq!(anew.offer(other), Offered::Refused(Refusal::Own));
+ assert_eq!(
+ anew.offer(testfold::put(&[root], "b", "1")),
+ Offered::Refused(Refusal::Dropped)
+ );
+ assert!(matches!(anew.offer(one), Offered::Taken(_)));
+ assert_eq!(anew.state().era(), (1, Some(&"one".to_owned())));
+ assert_eq!(anew.own(), (own, drops));
+ }
+
/// A store whose root holds puts and a lock, cut at the lock: the cut's ID, the lock's,
/// and the first put's, which the checkpoint forgets.
fn cut_at_a_lock() -> (Store<TestFold>, Id, Id, Id) {