diff options
| author | tv <tv@krebsco.de> | 2026-11-16 19:47:09 +0000 |
|---|---|---|
| committer | tv <tv@krebsco.de> | 2026-11-16 21:26:10 +0100 |
| commit | 3ee3816076d07b0e9b2c56cc7ea6e50951745027 (patch) | |
| tree | 1fcf2dc2df6967794e9b653563cc86c41816cf31 /src/federation/store | |
| parent | 0ba4c7363cfa2a9963ecd6a06392ea5c4dac3ad1 (diff) | |
store: a store read anew refuses what its node refused of its own
A node refuses some events by what it took before (the federation: a second version
changing the one it reads), and others as its operator has it drop them; read anew, its
store would take events in another order, and so maybe the other one. `own` lists what
the store refused so, and `refusing` has a store starting out refuse them from the
start, whatever order the events then come in (`docs/store.md`, A node's own).
Diffstat (limited to 'src/federation/store')
| -rw-r--r-- | src/federation/store/memory.rs | 54 |
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) { |
