Add service layer and enhance peer information retrieval in API crate

- Introduced a new `service` module to handle asynchronous operations for fetching peer information and topology.
- Updated the `Cargo.toml` to include `serde` as a dependency for serialization.
- Modified the routing in `route.rs` to include a new endpoint for retrieving topology and refactored the existing peer retrieval logic.
- Added a new struct `PeerInfoWithPeers` to encapsulate peer information along with their connections.

Author: incubator4

crates/api/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 axum.workspace = true
 clap.workspace = true
+serde.workspace = true
 tokio.workspace = true
 k8s = { path = "../k8s" }
 provider = { path = "../provider" }

crates/api/src/main.rs

@@ -1,4 +1,5 @@
 mod route;
+mod service;
 use clap::Parser;
 use std::{error::Error, net::SocketAddr, result::Result, time::Duration};
 use tracing::level_filters::LevelFilter;

crates/api/src/route.rs

@@ -2,32 +2,31 @@ use std::time::Duration;
 
 use axum::{Json, Router, extract::State, routing::get};
 use k8s::Client;
-use provider::optimism::p2p::P2P;
-use rpc_types_optimism::p2p::PeerInfo;
+use rpc_types_optimism::p2p::{PeerDump, PeerInfo};
+use serde::{Deserialize, Serialize};
+
+use crate::service;
 
 #[derive(Clone)]
 pub struct AppState {
     pub client: Client,
     pub timeout: Duration,
 }
 
-pub async fn get_peers(State(state): State<AppState>) -> Json<Vec<PeerInfo>> {
+#[derive(Clone, Serialize, Deserialize)]
+pub struct PeerInfoWithPeers {
+    #[serde(flatten)]
+    pub info: PeerInfo,
+    #[serde(flatten)]
+    pub peers: PeerDump,
+}
+
+pub async fn list_peers_info(State(state): State<AppState>) -> Json<Vec<PeerInfo>> {
     let endpoints = state.client.discover_rpc_endpoints().await.unwrap();
 
     let handles: Vec<_> = endpoints
         .into_iter()
-        .map(|e| {
-            let timeout = state.timeout;
-            tokio::spawn(async move {
-                tokio::time::timeout(timeout, async {
-                    let p = provider::create_provider(&e);
-                    p.info().await
-                })
-                .await
-                .ok()
-                .and_then(|r| r.ok())
-            })
-        })
+        .map(|e| tokio::spawn(service::info(e, state.timeout)))
         .collect();
 
     let mut results = Vec::new();
@@ -40,8 +39,37 @@ pub async fn get_peers(State(state): State<AppState>) -> Json<Vec<PeerInfo>> {
     Json(results)
 }
 
+pub async fn get_topology(State(state): State<AppState>) -> Json<Vec<PeerInfoWithPeers>> {
+    let endpoints = state.client.discover_rpc_endpoints().await.unwrap();
+    let timeout = state.timeout;
+
+    let handles: Vec<_> = endpoints
+        .into_iter()
+        .map({
+            move |e| {
+                let timeout = timeout;
+                tokio::spawn(async move {
+                    let info = service::info(e.clone(), timeout).await;
+                    let peers = service::peers(e, true, timeout).await;
+                    (info, peers)
+                })
+            }
+        })
+        .collect();
+
+    let mut results = Vec::new();
+    for handle in handles {
+        if let Ok((Some(info), Some(peers))) = handle.await {
+            results.push(PeerInfoWithPeers { info, peers });
+        }
+    }
+
+    Json(results)
+}
+
 pub fn routes() -> Router<AppState> {
     Router::new()
         .route("/healthz", get(|| async { "OK" }))
-        .route("/peers", get(get_peers))
+        .route("/peers", get(list_peers_info))
+        .route("/topology", get(get_topology))
 }

crates/api/src/service.rs

@@ -0,0 +1,24 @@
+use std::time::Duration;
+
+use provider::optimism::p2p::P2P;
+use rpc_types_optimism::p2p::{PeerDump, PeerInfo};
+
+pub async fn info(url: String, timeout: Duration) -> Option<PeerInfo> {
+    tokio::time::timeout(timeout, async {
+        let p = provider::create_provider(&url);
+        p.info().await
+    })
+    .await
+    .ok()
+    .and_then(|r| r.ok())
+}
+
+pub async fn peers(url: String, connected: bool, timeout: Duration) -> Option<PeerDump> {
+    tokio::time::timeout(timeout, async {
+        let p = provider::create_provider(&url);
+        p.peers(connected).await
+    })
+    .await
+    .ok()
+    .and_then(|r| r.ok())
+}