summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-19 13:50:25 +0000
committertv <tv@krebsco.de>2026-11-19 14:53:47 +0100
commit7d91c37ec1c606f70ec7a90ce9be4b0aa5c518c4 (patch)
tree9116ed3a2fbc69cba32500d2b8b48f85c6d46c51 /src
parentc1bf987314774d135316d95480baeb6eb7e1dc70 (diff)
peers: what each peer said it speaks and knows, in GET /peers
GET /peers shows, of each peer, what it said with its handshakes (SPEAKS): its `knows`, the wire versions it speaks, the oldest and the newest, and the newest revision of the federation it knows; null where it said nothing, a build from before SPEAKS or no handshake from it since the node started. `localKnows` is the node's own. So every swarm, federated or not, shows which builds its nodes run, as far as each heard. `swarm::speaking::shown` shapes it, for GET /events/counts too, whose `knows` is the same; docs/openapi.yaml has it once, as `Knows`. Without the federation feature, a revision reads as one this continuum doesn't know. `Speaking::of` is now used in every build, not only federated ones, which warned of it as dead code.
Diffstat (limited to 'src')
-rw-r--r--src/api/events.rs31
-rw-r--r--src/api/peers.rs14
-rw-r--r--src/swarm/speaking.rs51
3 files changed, 69 insertions, 27 deletions
diff --git a/src/api/events.rs b/src/api/events.rs
index f49c540..45c9a32 100644
--- a/src/api/events.rs
+++ b/src/api/events.rs
@@ -106,39 +106,16 @@ 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.
+/// What `node` says it speaks and knows (SPEAKS, `swarm::speaking::shown`), this node's
+/// own as it is; 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,
- })
+ speaks.map_or(JsonValue::Null, crate::swarm::speaking::shown)
}
/// The revisions this continuum knows, the base revision first: each its number, its ID,
diff --git a/src/api/peers.rs b/src/api/peers.rs
index 2bdde96..1f7af21 100644
--- a/src/api/peers.rs
+++ b/src/api/peers.rs
@@ -17,6 +17,7 @@ use crate::document::store;
use crate::locks::MutexExt;
use crate::state::{AppState, HelloState, Incidents, Liveness};
use crate::swarm::peer::forgotten_path;
+use crate::swarm::speaking;
use crate::transport::Destination;
use crate::transport::paths::ClockOffset;
use crate::transport::traffic::PeerTraffic;
@@ -67,6 +68,11 @@ pub(crate) struct PeerStatus {
/// absent before it said so in this session. Keys of members not in our member
/// list are left out.
pub(crate) reaches: Option<Vec<String>>,
+ /// What it said it speaks and knows with its handshakes (SPEAKS,
+ /// `swarm::speaking::shown`): the wire versions, the newest revision of the
+ /// federation. Null where it said nothing: a build from before SPEAKS, or no
+ /// handshake from it since we started.
+ pub(crate) knows: serde_json::Value,
/// Messages and payload bytes exchanged with it, by kind, since we started (or
/// since it was last listed).
pub(crate) traffic: PeerTraffic,
@@ -139,6 +145,8 @@ pub(crate) struct PeerListResponse {
pub(crate) local_addresses: Vec<String>,
/// The members we reach (`swarm::reach`), as we last told our neighbours.
pub(crate) local_reaches: Vec<String>,
+ /// What we tell peers we speak and know, as `PeerStatus::knows`.
+ pub(crate) local_knows: serde_json::Value,
/// By node ID.
pub(crate) peers: BTreeMap<String, PeerStatus>,
}
@@ -228,6 +236,10 @@ pub(crate) async fn peer_list(state: &AppState) -> PeerListResponse {
.effective(&peer, now, state.timing.rtt_fresh_for())
.map(|rtt| rtt.as_millis() as u64 / 2),
});
+ let knows = state
+ .speaking
+ .of(&peer)
+ .map_or(serde_json::Value::Null, speaking::shown);
peers.insert(
peer,
PeerStatus {
@@ -254,6 +266,7 @@ pub(crate) async fn peer_list(state: &AppState) -> PeerListResponse {
heads: ps.reported_heads,
neighbour,
reaches: crate::swarm::reach::of(ps.reaches.as_ref()).map(&named),
+ knows,
traffic,
incidents: ps.incidents,
sync_throughput,
@@ -269,6 +282,7 @@ pub(crate) async fn peer_list(state: &AppState) -> PeerListResponse {
local_addresses: state.transport.local_addresses(),
local_epoch: local_epoch.into(),
local_reaches: named(crate::swarm::reach::published(&state)),
+ local_knows: speaking::shown(speaking::own()),
local_heads,
peers,
}
diff --git a/src/swarm/speaking.rs b/src/swarm/speaking.rs
index e1a8d2c..4626fb1 100644
--- a/src/swarm/speaking.rs
+++ b/src/swarm/speaking.rs
@@ -30,6 +30,44 @@ fn newest_revision() -> Option<[u8; 32]> {
None
}
+/// `speaks` as the API shows it (`knows` in `GET /peers` and `GET /events/counts`): the
+/// wire versions, the oldest and the newest, and the newest revision of the federation,
+/// by number and ID and as people read it, its number null where this continuum doesn't
+/// know it; null where there is none.
+pub(crate) fn shown(speaks: Speaks) -> serde_json::Value {
+ serde_json::json!({
+ "wire": [speaks.oldest, speaks.newest],
+ "revision": speaks.revision.map(revision_shown),
+ })
+}
+
+#[cfg(feature = "federation")]
+fn revision_shown(id: [u8; 32]) -> serde_json::Value {
+ use crate::federation::revision::Revision;
+ let id = crate::federation::store::Id(id);
+ match Revision::of(&id) {
+ Some(revision) => serde_json::json!({
+ "number": revision.0,
+ "id": id.to_string(),
+ "named": revision.to_string(),
+ }),
+ None => unknown(&id.to_string()),
+ }
+}
+
+#[cfg(not(feature = "federation"))]
+fn revision_shown(id: [u8; 32]) -> serde_json::Value {
+ unknown(&crate::transport::Hex(&id).to_string())
+}
+
+fn unknown(id: &str) -> serde_json::Value {
+ serde_json::json!({
+ "number": null,
+ "id": id,
+ "named": format!("{id}, a revision this continuum doesn't know"),
+ })
+}
+
/// The SPEAKS each peer sent last, by node ID.
#[derive(Default)]
pub(crate) struct Speaking(std::sync::Mutex<BTreeMap<String, Speaks>>);
@@ -68,5 +106,18 @@ mod tests {
speaking.heard("a", older);
assert_eq!(speaking.of("a"), Some(older));
assert_eq!(own().newest, wire::VERSION);
+ let unknown = shown(Speaks {
+ revision: Some([7; 32]),
+ ..older
+ });
+ assert_eq!(unknown["wire"], serde_json::json!([1, 1]));
+ assert_eq!(unknown["revision"]["number"], serde_json::Value::Null);
+ assert_eq!(unknown["revision"]["id"], "07".repeat(32));
+ assert_eq!(shown(older)["revision"], serde_json::Value::Null);
+ #[cfg(feature = "federation")]
+ assert_eq!(
+ shown(own())["revision"]["number"],
+ crate::federation::revision::FEATURES.len()
+ );
}
}