sn-node: Yggdrasil config generation and admin socket client (genconf, status)

2026-09-24 15:58:12 +02:00
parent 23dc906da0
commit c422deee7c
8 changed files with 1046 additions and 2 deletions
@@ -0,0 +1,126 @@
+//! Integration tests for the Yggdrasil admin socket client, against a
+//! fake admin server speaking the documented protocol.
+
+#![forbid(unsafe_code)]
+#![allow(clippy::unwrap_used, clippy::expect_used)]
+
+use std::time::Duration;
+
+use sn_node::error::NodeError;
+use sn_node::yggdrasil::{peers_from_response, AdminClient, AdminEndpoint, SelfInfo};
+
+const SELF_RESPONSE: &str = concat!(
+    r#"{"request": {"request": "getself"}, "status": "success", "response": {"#,
+    r#""200:1111:2222:3333:4444:5555:6666:7777": {"#,
+    r#""address": "200:1111:2222:3333:4444:5555:6666:7777","#,
+    r#""key": "0000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1111","#,
+    r#""build_name": "yggdrasil", "build_version": "0.5.12","#,
+    r#""subnet": "300:1111:2222:3333::/64", "coords": [1, 2, 3]}}}"#
+);
+
+const PEERS_RESPONSE: &str = concat!(
+    r#"{"request": {"request": "getpeers"}, "status": "success", "response": {"#,
+    r#""200:1111:2222:3333:4444:5555:6666:7777": {"coords": [1]}, "#,
+    r#""200:9999:2222:3333:4444:5555:6666:7777": {"#,
+    r#""coords": [1, 2], "port": 1, "key": "ffff...", "#,
+    r#""remote": "tcp://[fe80::1%25eth0]:1337"}}}"#
+);
+
+const ERROR_RESPONSE: &str =
+    r#"{"request": {"request": "getself"}, "status": "error", "error": "boom"}"#;
+
+/// Fake admin server: answers each connection's request line, then closes.
+async fn fake_admin_server(response: &'static str) -> std::net::SocketAddr {
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = listener.local_addr().unwrap();
+    tokio::spawn(async move {
+        loop {
+            let Ok((mut socket, _)) = listener.accept().await else {
+                break;
+            };
+            let mut line = Vec::new();
+            let mut byte = [0u8; 1];
+            while !line.ends_with(b"\n") {
+                if socket.read(&mut byte).await.unwrap_or(0) == 0 {
+                    break;
+                }
+                line.push(byte[0]);
+            }
+            socket.write_all(response.as_bytes()).await.ok();
+            socket.shutdown().await.ok();
+        }
+    });
+    addr
+}
+
+fn tcp_endpoint(addr: std::net::SocketAddr) -> AdminEndpoint {
+    AdminEndpoint::Tcp {
+        host: addr.ip().to_string(),
+        port: addr.port(),
+    }
+}
+
+#[tokio::test]
+async fn get_self_parses_address_subnet_and_version() {
+    let endpoint = tcp_endpoint(fake_admin_server(SELF_RESPONSE).await);
+    let info = SelfInfo::from_response(
+        &AdminClient::connect(&endpoint, Duration::from_secs(2))
+            .await
+            .unwrap()
+            .request("getself")
+            .await
+            .unwrap(),
+    )
+    .unwrap();
+
+    assert_eq!(
+        info.address.inner().to_string(),
+        "200:1111:2222:3333:4444:5555:6666:7777"
+    );
+    assert_eq!(info.subnet.as_deref(), Some("300:1111:2222:3333::/64"));
+    assert_eq!(info.build_version.as_deref(), Some("0.5.12"));
+}
+
+#[tokio::test]
+async fn get_peers_lists_remote_uris() {
+    let endpoint = tcp_endpoint(fake_admin_server(PEERS_RESPONSE).await);
+    let value = AdminClient::connect(&endpoint, Duration::from_secs(2))
+        .await
+        .unwrap()
+        .request("getpeers")
+        .await
+        .unwrap();
+    let peers = peers_from_response(&value).unwrap();
+
+    assert_eq!(peers.len(), 2);
+    assert_eq!(
+        peers[1].remote.as_deref(),
+        Some("tcp://[fe80::1%25eth0]:1337")
+    );
+}
+
+#[tokio::test]
+async fn admin_error_is_surfaced() {
+    let endpoint = tcp_endpoint(fake_admin_server(ERROR_RESPONSE).await);
+    let mut client = AdminClient::connect(&endpoint, Duration::from_secs(2))
+        .await
+        .unwrap();
+    let err = client.request("getself").await.unwrap_err();
+    assert!(matches!(err, NodeError::AdminFailed(ref text) if text == "boom"));
+}
+
+#[tokio::test]
+async fn connection_refused_becomes_io_or_timeout_error() {
+    // Port 1 on localhost: virtually guaranteed to be closed.
+    let endpoint = AdminEndpoint::Tcp {
+        host: "127.0.0.1".into(),
+        port: 1,
+    };
+    let result = AdminClient::get_self(&endpoint, Duration::from_millis(500)).await;
+    assert!(matches!(
+        result,
+        Err(NodeError::Io(_)) | Err(NodeError::Timeout)
+    ));
+}