diff options
| author | tv <tv@krebsco.de> | 2026-11-19 13:34:24 +0000 |
|---|---|---|
| committer | tv <tv@krebsco.de> | 2026-11-19 14:39:54 +0100 |
| commit | 9164ebfe9a4014cbbaaaff90c5a1d722e39457fd (patch) | |
| tree | 9a45156bd4919054939d12c97a19672e92e07b98 /src | |
| parent | 7a5aeb02024ddff71ba60f40913555cd21a633ad (diff) | |
federation: which nodes know a revision, in counts and before a `true`
`GET /events/counts` says, of each node a party lists, what it said it
speaks and knows (`knows`, by node ID): the wire versions, the oldest and
the newest, and the newest revision of the federation it knows, by
number and ID and as people read it, its number null where this
continuum doesn't know it; null where it said nothing, a build from
before SPEAKS or one the node didn't hear from; the node's own as it is.
So the nodes still to upgrade before a revision passes show, every
party's, where before a party's operators could check only their own.
A party's client, backing a proposal that moves to another revision,
warns of every node of any party not known to know it, a line a party
naming each and what it said: once it passes, those stop at it till
upgraded. `next` warns alike, of the revision it moves to, or of the
later one it suggests. A warning, not a refusal: what a node heard is
no proof, and a node not heard from may well be upgraded.
Diffstat (limited to 'src')
| -rw-r--r-- | src/api/events.rs | 46 | ||||
| -rw-r--r-- | src/federation/client.rs | 66 | ||||
| -rw-r--r-- | src/federation/party.rs | 42 | ||||
| -rw-r--r-- | src/swarm/speaking.rs | 26 |
4 files changed, 170 insertions, 10 deletions
diff --git a/src/api/events.rs b/src/api/events.rs index 7bb322e..f49c540 100644 --- a/src/api/events.rs +++ b/src/api/events.rs @@ -106,6 +106,41 @@ async fn summary(State(state): State<AppState>) -> Response { }) } +/// What `node` says it speaks and knows (SPEAKS, `swarm::speaking`), this node's own as +/// it is: the wire versions it speaks, the oldest and the newest, and the newest revision +/// of the federation it knows, by number and ID and as people read it, its number null +/// where this continuum doesn't know it. Null where the node said nothing: a build from +/// before SPEAKS, or one not heard from. +fn knows(state: &AppState, node: &str) -> JsonValue { + let speaks = if node == state.local_id() { + Some(crate::swarm::speaking::own()) + } else { + state.speaking.of(node) + }; + let Some(speaks) = speaks else { + return JsonValue::Null; + }; + let revision = speaks.revision.map(|id| { + let id = Id(id); + match Revision::of(&id) { + Some(revision) => json!({ + "number": revision.0, + "id": id.to_string(), + "named": revision.to_string(), + }), + None => json!({ + "number": null, + "id": id.to_string(), + "named": format!("{id}, a revision this continuum doesn't know"), + }), + } + }); + json!({ + "wire": [speaks.oldest, speaks.newest], + "revision": revision, + }) +} + /// The revisions this continuum knows, the base revision first: each its number, its ID, /// the feature it adds and what that adds, and as people read it. fn revisions() -> Vec<JsonValue> { @@ -143,7 +178,8 @@ async fn event(State(state): State<AppState>, Path(id): Path<String>) -> Respons } /// `GET /events/counts`: what counts, as the store reads now: the current version, each -/// party's keys and nodes, the values at places, the members, and the proposals on the +/// party's keys and nodes, what each of those nodes says it speaks and knows (`knows`), +/// the values at places, the members, and the proposals on the /// current version, each with the events proposing it a vote may build on (`proposing`: /// for a checkpoint, those above its heads), the votes on it, the parties /// voting `true` and `false`, whether it passed and whether it is dead, and why a party's @@ -157,11 +193,17 @@ async fn counts(State(state): State<AppState>) -> Response { .parties .keys() .map(|party| { + let nodes = read.nodes_of(party, current); + let knows: serde_json::Map<String, JsonValue> = nodes + .iter() + .map(|node| (node.clone(), knows(&state, node))) + .collect(); ( party.clone(), json!({ "keys": read.keys_of(party, current), - "nodes": read.nodes_of(party, current), + "nodes": nodes, + "knows": knows, }), ) }) diff --git a/src/federation/client.rs b/src/federation/client.rs index 7b9d3d7..45f5019 100644 --- a/src/federation/client.rs +++ b/src/federation/client.rs @@ -22,6 +22,7 @@ use serde::{Deserialize, Serialize}; use super::event::{Does, Event, Signed}; use super::jcs::{self, Json}; +use super::revision::Revision; use super::store::Id; use super::version::Version; @@ -480,6 +481,41 @@ pub(crate) fn changes(current: &Json, proposed: &Json) -> Vec<String> { lines } +/// Of the parties' nodes, those not known to know `revision`, by what the node a client +/// talks to heard each say it knows (`knows` in `counts`, from `GET /events/counts`): a +/// line for each party with any, naming them and what each said. Once a version of +/// `revision` passes, such a node stops at it till upgraded. None where every node said +/// it knows it. +pub(crate) fn unready(counts: &serde_json::Value, revision: Revision) -> Vec<String> { + let mut lines = Vec::new(); + for (party, of) in counts["parties"].as_object().into_iter().flatten() { + let behind: Vec<String> = of["knows"] + .as_object() + .into_iter() + .flatten() + .filter_map(|(node, knows)| { + let newest = &knows["revision"]; + let named = newest["named"].as_str().unwrap_or("?"); + match newest["number"].as_u64() { + Some(number) if usize::try_from(number).is_ok_and(|n| n >= revision.0) => None, + Some(_) => Some(format!("{node} knows {named} at newest")), + None if newest.is_object() => Some(format!("{node} knows {named}")), + None if knows.is_object() => Some(format!( + "{node} knows no revision: built without the federation" + )), + None => Some(format!( + "{node} said nothing: a build from before SPEAKS, or not heard from" + )), + } + }) + .collect(); + if !behind.is_empty() { + lines.push(format!("{party}: {}", behind.join("; "))); + } + } + lines +} + /// The parties that voted twice, by the votes `records` keep: of each version they name, /// a party whose `true` and `false` are on one proposal, or whose `true` is on two /// proposals of which neither is dead by all the votes. Each vote counts as checked from @@ -908,4 +944,34 @@ mod tests { )] ); } + + /// Of the nodes `knows` names, those that didn't say they know a revision are named, + /// with what each said; a party whose nodes all did, not. + #[test] + fn nodes_not_known_to_know_a_revision_are_named() { + let one = Revision(1); + let id = one.id().to_string(); + let counts = serde_json::json!({"parties": { + "lass": {"knows": { + "a": {"wire": [52, 52], "revision": {"number": 1, "id": id, "named": "one"}}, + }}, + "tv": {"knows": { + "b": {"wire": [52, 52], "revision": {"number": 0, "named": "the base"}}, + "c": null, + "d": {"wire": [52, 52], "revision": {"number": null, "named": "x, unknown"}}, + "e": {"wire": [52, 52], "revision": null}, + "f": {"wire": [52, 53], "revision": {"number": 2, "named": "two"}}, + }}, + }}); + assert_eq!( + unready(&counts, one), + [ + "tv: b knows the base at newest; c said nothing: a build from before SPEAKS, \ + or not heard from; d knows x, unknown; e knows no revision: built without \ + the federation" + ] + ); + assert!(unready(&counts, Revision(0)).len() == 1); + assert!(unready(&serde_json::json!({}), one).is_empty()); + } } diff --git a/src/federation/party.rs b/src/federation/party.rs index a12dc7f..2c8dc4b 100644 --- a/src/federation/party.rs +++ b/src/federation/party.rs @@ -314,7 +314,15 @@ pub(crate) async fn main() -> Result<()> { moves to it, once every party's nodes run a continuum that knows it", current.revision ); + warn_unready(&node.counts().await?, later); } + } else if let Some(revision) = next["revision"] + .as_str() + .and_then(Id::from_hex) + .and_then(|id| Revision::of(&id)) + && revision != current.revision + { + warn_unready(&node.counts().await?, revision); } println!("{}", serde_json::to_string_pretty(&next)?); return Ok(()); @@ -755,18 +763,21 @@ async fn vote( })) if hash == proposal => version, _ => bail!("the node's {proposing} isn't the proposal it names"), }; - // A later revision: the node knows it, or it stops at the version once it passes. + // A later revision: the node knows it, or it stops at the version once it passes; and + // so does every other node not known to know it. if yes && let Ok(version) = Version::read(&proposed) && version.revision != current.revision - && !node.revisions().await?.contains(&version.revision.id()) { - bail!( - "{proposal} moves to {}, which the node doesn't know: once it passed, a node that \ - doesn't stops at it, and votes nothing till upgraded; upgrade this node and every \ - other of the party to a continuum that knows it, then back it", - version.revision - ); + if !node.revisions().await?.contains(&version.revision.id()) { + bail!( + "{proposal} moves to {}, which the node doesn't know: once it passed, a node \ + that doesn't stops at it, and votes nothing till upgraded; upgrade this node \ + and every other of the party to a continuum that knows it, then back it", + version.revision + ); + } + warn_unready(&counts, version.revision); } // The votes on its party's earlier proposals it backed, for the nays among them. let mut nays = Vec::new(); @@ -816,6 +827,21 @@ async fn vote( node.put(&cast).await } +/// Warns of the nodes not known to know `revision`, by `counts` (`client::unready`). +fn warn_unready(counts: &JsonValue, revision: Revision) { + let behind = client::unready(counts, revision); + if behind.is_empty() { + return; + } + eprintln!( + "Warning: these nodes aren't known to know {revision}, as far as the node heard from \ + them; once a version of it passes, each stops at it till upgraded:" + ); + for line in behind { + eprintln!(" {line}"); + } +} + /// Signs again what a move refused: of the latest event it signed at each place, its key /// set and its node list, those the node refuses as not above its checkpoint's heads, or /// as built on one it refuses. diff --git a/src/swarm/speaking.rs b/src/swarm/speaking.rs index dcbfac4..e1a8d2c 100644 --- a/src/swarm/speaking.rs +++ b/src/swarm/speaking.rs @@ -43,4 +43,30 @@ impl Speaking { } heard.insert(peer.to_owned(), speaks); } + + /// What `peer` said last, if it said anything. + pub(crate) fn of(&self, peer: &str) -> Option<Speaks> { + self.0.lock_or_recover().get(peer).copied() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn a_peer_is_heard_as_it_spoke_last() { + let speaking = Speaking::default(); + assert_eq!(speaking.of("a"), None); + speaking.heard("a", own()); + let older = Speaks { + oldest: 1, + newest: 1, + revision: None, + }; + speaking.heard("b", older); + speaking.heard("a", older); + assert_eq!(speaking.of("a"), Some(older)); + assert_eq!(own().newest, wire::VERSION); + } } |
