diff options
Diffstat (limited to 'src/federation/store')
| -rw-r--r-- | src/federation/store/memory.rs | 126 |
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(); |
