aboutsummaryrefslogtreecommitdiffstats
path: root/src/federation/store/memory.rs
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-16 16:20:59 +0000
committertv <tv@krebsco.de>2026-11-16 18:01:35 +0100
commit11244e60fbcef6b154c7b657ce2c50d56277bf7b (patch)
treeb1bdcfcfcef3c580da79ad0ca8f91c6210d7f97b /src/federation/store/memory.rs
parentceddd407c434edde2a1490b912854444dcda97fe (diff)
store: a node's own refusals, and its operator's drops
Where its history takes an event but the fold has the node refuse it by what it took before (the federation's second version changing one), the store refuses it as its own. An operator may have the node drop events taken after its checkpoint, with everything built on them, and refuse them from then on; what the checkpoint keeps, or holds by ID, isn't dropped, as every event after it builds on that. The operator takes either back by allowing it, and what was refused for being built on it, to be offered again. The fold for the tests shows both with its eras.
Diffstat (limited to 'src/federation/store/memory.rs')
-rw-r--r--src/federation/store/memory.rs126
1 files changed, 126 insertions, 0 deletions
diff --git a/src/federation/store/memory.rs b/src/federation/store/memory.rs
index 4ff5386..85fac7f 100644
--- a/src/federation/store/memory.rs
+++ b/src/federation/store/memory.rs
@@ -17,6 +17,10 @@ pub(crate) enum Refusal {
/// It isn't above the checkpoint's heads: it builds on what came before them, or on
/// nothing.
NotAbove,
+ /// Its history takes it, but the node doesn't, by what it took before.
+ Own,
+ /// Its operator had the node drop it.
+ Dropped,
}
/// What became of an event offered to a store.
@@ -274,6 +278,9 @@ impl<F: Fold> Store<F> {
if let Err(why) = F::judge(&at, &id, &event.bytes) {
return self.refuse(id, Refusal::Judged(why));
}
+ if !F::keeps(&self.state, &id, &event.bytes) {
+ return self.refuse(id, Refusal::Own);
+ }
F::add(&mut self.state, &id, &event.bytes);
self.events.insert(id, event);
self.order.push(id);
@@ -281,6 +288,75 @@ impl<F: Fold> Store<F> {
Offered::Taken(vec![id])
}
+ /// The events refused, and why: for reports.
+ pub(crate) fn refused(&self) -> impl Iterator<Item = (&Id, &Refusal)> {
+ self.refused.iter()
+ }
+
+ /// Drops events taken after the checkpoint, with everything built on them, as their
+ /// operator has the node do: it refuses them from then on, until its operator allows
+ /// them again. What the checkpoint keeps, or holds by ID, it drops not: every event
+ /// after it builds on that. Returns what it dropped, in the order taken.
+ pub(crate) fn drop_taken(&mut self, ids: &[Id]) -> Result<Vec<Id>, Refused> {
+ if let Some(id) = ids.iter().find(|id| !self.events.contains_key(id)) {
+ return Err(Refused::new(format!(
+ "{id} isn't an event taken after the checkpoint"
+ )));
+ }
+ let mut dropped: HashMap<Id, Refusal> =
+ ids.iter().map(|id| (*id, Refusal::Dropped)).collect();
+ for id in &self.order {
+ if dropped.contains_key(id) {
+ continue;
+ }
+ if let Some(on) = self.events[id]
+ .dependencies
+ .iter()
+ .find(|dependency| dropped.contains_key(dependency))
+ {
+ let on = *on;
+ dropped.insert(*id, Refusal::BuiltOn(on));
+ }
+ }
+ let order: Vec<Id> = self
+ .order
+ .iter()
+ .filter(|id| dropped.contains_key(id))
+ .copied()
+ .collect();
+ self.order.retain(|id| !dropped.contains_key(id));
+ for id in &order {
+ self.events.remove(id);
+ }
+ self.refused.extend(dropped);
+ let mut state = self.start.clone();
+ for id in &self.order {
+ F::add(&mut state, id, &self.events[id].bytes);
+ }
+ self.state = state;
+ Ok(order)
+ }
+
+ /// Takes back what the node refused of its own, or dropped, as its operator says
+ /// otherwise: `ids`, and what was refused for being built on them. They are taken when
+ /// offered again, where the store takes them then.
+ pub(crate) fn allow(&mut self, ids: &[Id]) {
+ let mut todo: Vec<Id> = ids
+ .iter()
+ .filter(|id| matches!(self.refused.get(id), Some(Refusal::Own | Refusal::Dropped)))
+ .copied()
+ .collect();
+ while let Some(id) = todo.pop() {
+ self.refused.remove(&id);
+ todo.extend(
+ self.refused
+ .iter()
+ .filter(|(_, why)| **why == Refusal::BuiltOn(id))
+ .map(|(waiter, _)| *waiter),
+ );
+ }
+ }
+
/// Refuses an event, and what waits for it.
fn refuse(&mut self, id: Id, why: Refusal) -> Offered {
self.refused.insert(id, why.clone());
@@ -411,6 +487,56 @@ mod tests {
}
#[test]
+ fn a_node_keeps_the_first_of_two_eras_of_one_number() {
+ let mut store = store();
+ let root = store.id();
+ let one = taken(store.offer(testfold::era(&[root], 1, "one")));
+ let other = testfold::era(&[root], 1, "other");
+ let beside = Id::of(&other);
+ assert_eq!(store.offer(other.clone()), Offered::Refused(Refusal::Own));
+ assert_eq!(
+ store.offer(testfold::put(&[beside], "a", "1")),
+ Offered::Refused(Refusal::BuiltOn(beside))
+ );
+ // The same era written again, at another history before it, is one the node
+ // took; at a history after it, it is no era there.
+ let elsewhere = taken(store.offer(testfold::put(&[root], "b", "1")));
+ assert!(matches!(
+ store.offer(testfold::era(&[elsewhere], 1, "one")),
+ Offered::Taken(_)
+ ));
+ assert!(matches!(
+ store.offer(testfold::era(&[one], 1, "one")),
+ Offered::Refused(Refusal::Judged(_))
+ ));
+ assert_eq!(store.state().era(), (1, Some(&"one".to_owned())));
+ }
+
+ #[test]
+ fn an_operator_drops_what_its_node_took_and_takes_the_other() {
+ let mut store = store();
+ let root = store.id();
+ let one = taken(store.offer(testfold::era(&[root], 1, "one")));
+ let on = taken(store.offer(testfold::put(&[one], "a", "1")));
+ let unrelated = taken(store.offer(testfold::put(&[root], "b", "1")));
+ let other = testfold::era(&[root], 1, "other");
+ let beside = Id::of(&other);
+ assert_eq!(store.offer(other.clone()), Offered::Refused(Refusal::Own));
+ assert_eq!(store.drop_taken(&[one]), Ok(vec![one, on]));
+ assert_eq!(store.taken(), &[unrelated]);
+ assert_eq!(store.state().era(), (0, Some(&String::new())));
+ assert_eq!(store.refusal(&on), Some(&Refusal::BuiltOn(one)));
+ store.allow(&[beside]);
+ assert_eq!(store.offer(other), Offered::Taken(vec![beside]));
+ assert_eq!(store.state().era(), (1, Some(&"other".to_owned())));
+ assert_eq!(
+ store.offer(testfold::era(&[root], 1, "one")),
+ Offered::Refused(Refusal::Dropped)
+ );
+ assert!(store.drop_taken(&[root]).is_err());
+ }
+
+ #[test]
fn an_event_waits_until_all_it_builds_on_is_held() {
let mut store = store();
let root = store.id();