aboutsummaryrefslogtreecommitdiffstats
path: root/src/federation
diff options
context:
space:
mode:
Diffstat (limited to 'src/federation')
-rw-r--r--src/federation/fold.rs36
-rw-r--r--src/federation/held.rs88
2 files changed, 119 insertions, 5 deletions
diff --git a/src/federation/fold.rs b/src/federation/fold.rs
index 6ffdc5a..78f5c39 100644
--- a/src/federation/fold.rs
+++ b/src/federation/fold.rs
@@ -328,6 +328,34 @@ impl State {
ballots
}
+ /// The version event writing the proposal of hash `proposal` on the current version,
+ /// where it passed here: on the `true` votes of the first parties by name that pass it,
+ /// each party's of the lowest ID, so that nodes holding those votes write the same.
+ pub(crate) fn version_event(&self, proposal: &Id) -> Option<Vec<u8>> {
+ let current = self.current();
+ let mut yes: BTreeMap<&str, Id> = BTreeMap::new();
+ for (id, signed, _) in self.signed() {
+ if let Does::Vote {
+ on,
+ proposal: voted,
+ yes: true,
+ } = &signed.does
+ && *on == current.hash
+ && voted == proposal
+ {
+ let lowest = yes.entry(signed.party.as_str()).or_insert(*id);
+ *lowest = (*lowest).min(*id);
+ }
+ }
+ let needed = (2 * current.parties.len()).div_ceil(3);
+ if yes.len() < needed {
+ return None;
+ }
+ let mut deps: Vec<Id> = yes.into_values().take(needed).collect();
+ deps.sort_unstable();
+ Some(event::version_event(&deps, *proposal))
+ }
+
/// Whether a proposal of hash `proposal` is proposed on `on` here.
fn proposed_on(&self, proposal: &Id, on: &Id) -> bool {
self.signed().any(|(_, signed, under)| {
@@ -851,6 +879,7 @@ mod tests {
let (tv, lass, makefu) = (tv(), lass(), makefu());
let (mut store, first, next, proposal) = proposed();
let yes = taken(store.offer(tv.vote(&[proposal], first.hash(), next.hash(), true)));
+ assert_eq!(store.state().version_event(&next.hash()), None);
assert!(judged(
store.offer(harness::version_event(&[yes], next.hash()))
));
@@ -865,8 +894,13 @@ mod tests {
"names/r/x",
harness::str("1")
))));
- let written = taken(store.offer(harness::version_event(&[yes, also], next.hash())));
+ let written = store.state().version_event(&next.hash()).expect("passed");
+ let mut deps = [yes, also];
+ deps.sort_unstable();
+ assert_eq!(written, harness::version_event(&deps, next.hash()));
+ let written = taken(store.offer(written));
assert_eq!(store.state().current().number, 1);
+ assert_eq!(store.state().version_event(&next.hash()), None);
taken(store.offer(tv.write(&[written], "names/r/x", harness::str("1"))));
assert_eq!(store.state().value("names/r/x"), Some(&harness::str("1")));
// A vote on the version that was current lapses with it.
diff --git a/src/federation/held.rs b/src/federation/held.rs
index ae2264b..6e075aa 100644
--- a/src/federation/held.rs
+++ b/src/federation/held.rs
@@ -546,6 +546,34 @@ impl Holding {
Ok(signed)
}
+ /// The version events writing what passed on the current version, as its store reads
+ /// now, offered to it: those it takes, to put into the document. A node writes a version
+ /// as soon as it holds it passed (`docs/federation.md`, Changing the policy).
+ pub(crate) fn passed(&self) -> Vec<Vec<u8>> {
+ let mut inner = self.inner.lock_or_recover();
+ let inner = &mut *inner;
+ let Some(store) = inner.store.as_mut() else {
+ return Vec::new();
+ };
+ let state = store.state();
+ let writing: Vec<Vec<u8>> = state
+ .ballots(&state.current().hash)
+ .keys()
+ .filter_map(|proposal| state.version_event(proposal))
+ .collect();
+ let mut written = Vec::new();
+ for bytes in writing {
+ if let Offered::Taken(_) = store.offer(bytes.clone()) {
+ info!(event = %Id::of(&bytes), "Writing a version that passed");
+ written.push(bytes);
+ }
+ }
+ if !written.is_empty() {
+ self.settle(inner);
+ }
+ written
+ }
+
/// What it signs now, voting by itself by its operator's rules: to put into the
/// document.
pub(crate) fn act(&self) -> Vec<Vec<u8>> {
@@ -629,8 +657,8 @@ fn found(pin: &Id, root: &[u8], events: &BTreeMap<Id, Vec<u8>>) -> Option<Built>
}
/// Reads the store from the document whenever it changes, and from the changes the node
-/// refused now and then; puts again what the document lacks, a random wait after it
-/// first lacked it.
+/// refused now and then; writes what passed and what it signs voting by itself; puts again
+/// what the document lacks, a random wait after it first lacked it.
pub(crate) async fn run_worker(state: crate::state::AppState) {
let mut changed = state.change_tx.subscribe();
let mut due: Option<tokio::time::Instant> = None;
@@ -663,20 +691,27 @@ pub(crate) async fn run_worker(state: crate::state::AppState) {
holding.read(unread);
}
let signed = holding.act();
+ let passed = holding.passed();
(
!holding.lacking(&doc.blocking_read().doc).is_empty(),
signed,
+ passed,
)
});
- let (lacking, signed) = read.await.unwrap_or_else(|error| {
+ let (lacking, signed, passed) = read.await.unwrap_or_else(|error| {
error!(error = %error, "Reading the store from the document failed");
- (false, Vec::new())
+ (false, Vec::new(), Vec::new())
});
for bytes in signed {
if let Err(error) = write(&state, None, bytes).await {
warn!(error = %error, "Couldn't put what it signed for its party: put again later");
}
}
+ for bytes in passed {
+ if let Err(error) = write(&state, None, bytes).await {
+ warn!(error = %error, "Couldn't write a version that passed: put again later");
+ }
+ }
let member = state
.holding
.member(state.local_id(), state.holding.party());
@@ -1166,6 +1201,51 @@ mod tests {
assert!(events::ids(&doc).contains(&Id::of(&beside)));
}
+ /// Two proposals on the first version passing at once, tv backing both: a node writes
+ /// the one it takes, and refuses the other, of its own.
+ #[test]
+ fn a_node_writes_what_passed() {
+ let (tv, lass, makefu) = (
+ Party::new("tv", 1),
+ Party::new("lass", 2),
+ Party::new("makefu", 3),
+ );
+ let first = Spec::first(&[&tv, &lass, &makefu], &[]);
+ let root = first.root();
+ let on = first.hash();
+ let one = first.after(on);
+ let mut two = first.after(on);
+ two.rules.push(("names/x".to_owned(), harness::str("tv")));
+ let p1 = tv.propose(&[Id::of(&root)], &one.json());
+ let p2 = lass.propose(&[Id::of(&root)], &two.json());
+ let mut doc = events::started(Federation::NAME, &root).unwrap();
+ for event in [
+ &p1,
+ &p2,
+ &tv.vote(&[Id::of(&p1)], on, one.hash(), true),
+ &lass.vote(&[Id::of(&p1)], on, one.hash(), true),
+ &tv.vote(&[Id::of(&p2)], on, two.hash(), true),
+ &makefu.vote(&[Id::of(&p2)], on, two.hash(), true),
+ ] {
+ put(&mut doc, event);
+ }
+ let holding = Holding::default();
+ assert_eq!(holding.passed(), Vec::<Vec<u8>>::new());
+ read(&holding, &doc, 0);
+ let written = holding.passed();
+ assert_eq!(written.len(), 1);
+ let current = holding.with(|store| store.state().current().hash).unwrap();
+ assert!(current == one.hash() || current == two.hash());
+ let other = if current == one.hash() { &two } else { &one };
+ let refused = holding.with(|store| store.own().0).unwrap();
+ assert_eq!(refused.len(), 1);
+ assert_eq!(
+ holding.with(|store| store.state().version_event(&other.hash())),
+ Some(None)
+ );
+ assert_eq!(holding.passed(), Vec::<Vec<u8>>::new());
+ }
+
/// Rows the next stages test.
const LATER: &[u32] = &[21, 22];