From c11324bef3e93aac3748c6bb62c4a60872ea3f62 Mon Sep 17 00:00:00 2001
From: tv <tv@krebsco.de>
Date: Mon, 26 Oct 2026 22:57:47 +0100
Subject: peers in /peers is an attrset

---
 src/api/peers.rs | 52 ++++++++++++++++++++++++++++------------------------
 1 file changed, 28 insertions(+), 24 deletions(-)

(limited to 'src/api/peers.rs')

diff --git a/src/api/peers.rs b/src/api/peers.rs
index f0fd1d9..bc32ae1 100644
--- a/src/api/peers.rs
+++ b/src/api/peers.rs
@@ -1,5 +1,7 @@
 //! /peers handlers.
 
+use std::collections::BTreeMap;
+
 use axum::{
     Json,
     extract::{Path, Query, State},
@@ -44,7 +46,6 @@ impl From<Epoch> for EpochInfo {
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct PeerStatus {
-    public_key: String,
     /// The name the peer gave itself in the member list, if any (not unique).
     alias: Option<String>,
     validated_swarm: Option<String>,
@@ -58,7 +59,7 @@ pub(crate) struct PeerStatus {
     /// Whether that epoch equals ours, i.e. whether we sync with this peer.
     same_epoch: Option<bool>,
     /// Number of heads in its last keepalive; absent before one, or when it had more
-    /// than 32 (then only their digest is sent).
+    /// than 32 (then only their digest and some of them are sent).
     heads: Option<usize>,
     /// We keep it alive and sync with it on our own; other peers we only answer.
     neighbour: bool,
@@ -92,7 +93,8 @@ pub(crate) struct PeerListResponse {
     /// Number of heads of our document. Several heads are concurrent changes no later
     /// change has merged yet.
     local_heads: usize,
-    peers: Vec<PeerStatus>,
+    /// By public key.
+    peers: BTreeMap<String, PeerStatus>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -110,7 +112,7 @@ pub(crate) async fn list_peers(
     let now = Instant::now();
     let local_epoch = state.local_epoch();
     let mut aliases = crate::swarm::members::aliases(&state.doc.read().await.doc);
-    let mut peers = Vec::with_capacity(snapshot.len());
+    let mut peers = BTreeMap::new();
 
     for (public_key, peer_state_mutex) in snapshot {
         let neighbour = crate::swarm::topology::is_neighbour(&state, &public_key);
@@ -138,29 +140,31 @@ pub(crate) async fn list_peers(
             ),
         };
 
-        peers.push(PeerStatus {
-            alias: aliases.remove(&public_key),
+        let alias = aliases.remove(&public_key);
+        peers.insert(
             public_key,
-            validated_swarm: ps.standing.swarm_id().map(str::to_owned),
-            status,
-            handshake_complete: ps.hello_state == HelloState::Established,
-            last_seen_secs_ago: ps
-                .last_seen
-                .map(|t| now.saturating_duration_since(t).as_secs()),
-            dormant_for_secs,
-            has_pending_delivery: ps.sync.sending.is_some() || ps.sync.retry_at.is_some(),
-            epoch: ps.epoch.map(EpochInfo::from),
-            same_epoch: ps.epoch.map(|epoch| epoch == local_epoch),
-            heads: ps.reported_heads,
-            neighbour,
-            rtt_ms,
-            traffic,
-            incidents: ps.incidents,
-            sync_throughput,
-        });
+            PeerStatus {
+                alias,
+                validated_swarm: ps.standing.swarm_id().map(str::to_owned),
+                status,
+                handshake_complete: ps.hello_state == HelloState::Established,
+                last_seen_secs_ago: ps
+                    .last_seen
+                    .map(|t| now.saturating_duration_since(t).as_secs()),
+                dormant_for_secs,
+                has_pending_delivery: ps.sync.sending.is_some() || ps.sync.retry_at.is_some(),
+                epoch: ps.epoch.map(EpochInfo::from),
+                same_epoch: ps.epoch.map(|epoch| epoch == local_epoch),
+                heads: ps.reported_heads,
+                neighbour,
+                rtt_ms,
+                traffic,
+                incidents: ps.incidents,
+                sync_throughput,
+            },
+        );
     }
 
-    peers.sort_by(|a, b| a.public_key.cmp(&b.public_key));
     let local_heads = state.doc.read().await.heads().len();
     Ok(Json(PeerListResponse {
         local_alias: state.alias.clone(),
-- 
cgit v1.3.1