aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-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();