diff options
Diffstat (limited to 'src/federation')
| -rw-r--r-- | src/federation/client.rs | 66 | ||||
| -rw-r--r-- | src/federation/party.rs | 42 |
2 files changed, 100 insertions, 8 deletions
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. |
