feat: Interface status for info route

lfbrehm · lfbrehm · commit 46ce8206639e · 2026-05-07T15:54:46.000+02:00
diff --git a/api/src/routes/info.rs b/api/src/routes/info.rs
@@ -1,5 +1,4 @@
 use crate::server_state::ServerState;
-use aruna_core::structs::Status;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::routing::get;
@@ -60,8 +59,31 @@ pub struct TimeoutConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
 pub struct InterfaceStatus {
-    pub s3_status: String,
-    pub rest_status: String,
+    pub rest: RestInterfaceStatus,
+    pub s3: S3InterfaceStatus,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
+#[serde(tag = "status")]
+pub enum RestInterfaceStatus {
+    Available {
+        bind_address: String,
+        base_url: String,
+        api_base_url: String,
+        info_url: String,
+        swagger_ui_url: String,
+    },
+    Unavailable,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
+#[serde(tag = "status")]
+pub enum S3InterfaceStatus {
+    Available {
+        bind_address: String,
+        base_url: String,
+    },
+    Unavailable,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ToSchema)]
@@ -138,12 +160,25 @@ pub async fn get_info(State(state): State<Arc<ServerState>>) -> (StatusCode, Jso
         }
         None => BlobStatus::Unavailable,
     };
-    // TODO: 
-    // - Replace hardcoded values
-    // - Add s3 interface address
+    let interface_runtime = state.interface_state().await;
     let interface_status = InterfaceStatus {
-        s3_status: Status::Available.to_string(),
-        rest_status: Status::Available.to_string(),
+        rest: match interface_runtime.rest {
+            Some(rest) => RestInterfaceStatus::Available {
+                bind_address: rest.bind_address.to_string(),
+                base_url: rest.base_url,
+                api_base_url: rest.api_base_url,
+                info_url: rest.info_url,
+                swagger_ui_url: rest.swagger_ui_url,
+            },
+            None => RestInterfaceStatus::Unavailable,
+        },
+        s3: match interface_runtime.s3 {
+            Some(s3) => S3InterfaceStatus::Available {
+                bind_address: s3.bind_address.to_string(),
+                base_url: s3.base_url,
+            },
+            None => S3InterfaceStatus::Unavailable,
+        },
     };
     let storage_metrics = state.get_ctx().storage_handle.snapshot_metrics();
     let database_status = DatabaseStatus {
@@ -169,11 +204,14 @@ pub async fn get_info(State(state): State<Arc<ServerState>>) -> (StatusCode, Jso
 
 #[cfg(test)]
 mod tests {
-    use super::{BlobStatus, InfoResponse, InterfaceStatus, NetStatus, DatabaseStatus, get_info};
+    use super::{
+        BlobStatus, DatabaseStatus, InfoResponse, InterfaceStatus, NetStatus,
+        RestInterfaceStatus, S3InterfaceStatus, get_info,
+    };
     use crate::openapi::ApiDoc;
     use crate::server_state::ServerState;
     use aruna_core::effects::StorageEffect;
-    use aruna_core::structs::{NodeCapabilities, RealmId, Status};
+    use aruna_core::structs::{NodeCapabilities, RealmId};
     use aruna_operations::driver::DriverContext;
     use aruna_storage::storage;
     use axum::Json;
@@ -229,8 +267,8 @@ mod tests {
                 net_state: NetStatus::Unavailable,
                 blob_status: BlobStatus::Unavailable,
                 interface_status: InterfaceStatus {
-                    s3_status: Status::Available.to_string(),
-                    rest_status: Status::Available.to_string(),
+                    rest: RestInterfaceStatus::Unavailable,
+                    s3: S3InterfaceStatus::Unavailable,
                 },
                 database_status: DatabaseStatus {
                     requests_total: baseline.requests_total,
@@ -246,6 +284,40 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn get_info_reports_registered_interface_paths() {
+        let (state, _tempdir) = setup_state().await;
+        state
+            .register_rest_interface("0.0.0.0:3000".parse().unwrap())
+            .await;
+        state
+            .register_s3_interface(
+                "0.0.0.0:1337".parse().unwrap(),
+                "http://localhost:1337".to_string(),
+            )
+            .await;
+
+        let (status, Json(response)) = get_info(State(state)).await;
+
+        assert_eq!(status, StatusCode::OK);
+        assert_eq!(
+            response.interface_status,
+            InterfaceStatus {
+                rest: RestInterfaceStatus::Available {
+                    bind_address: "0.0.0.0:3000".to_string(),
+                    base_url: "http://127.0.0.1:3000".to_string(),
+                    api_base_url: "http://127.0.0.1:3000/api/v1".to_string(),
+                    info_url: "http://127.0.0.1:3000/api/v1/info".to_string(),
+                    swagger_ui_url: "http://127.0.0.1:3000/swagger-ui".to_string(),
+                },
+                s3: S3InterfaceStatus::Available {
+                    bind_address: "0.0.0.0:1337".to_string(),
+                    base_url: "http://localhost:1337".to_string(),
+                },
+            }
+        );
+    }
+
     #[tokio::test]
     async fn get_info_reports_storage_error_metrics() {
         let (state, _tempdir) = setup_state().await;
diff --git a/api/src/server.rs b/api/src/server.rs
@@ -42,10 +42,14 @@ impl Server {
     }
 
     pub async fn run(self) -> Result<(), ServerSetupError> {
-        let router = self.build_router();
-
-        // Create TCP listener for main HTTP server
         let listener = TcpListener::bind(self.config.http_addr).await?;
+        self.run_with_listener(listener).await
+    }
+
+    pub async fn run_with_listener(self, listener: TcpListener) -> Result<(), ServerSetupError> {
+        let bound_addr = listener.local_addr()?;
+        self.state.register_rest_interface(bound_addr).await;
+        let router = self.build_router();
 
         axum::serve(
             listener,
diff --git a/api/src/server_state.rs b/api/src/server_state.rs
@@ -27,6 +27,7 @@ use iroh::EndpointAddr;
 use jsonwebtoken::DecodingKey;
 use serde::{Serialize, de::DeserializeOwned};
 use std::collections::{HashMap, HashSet};
+use std::net::SocketAddr;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use tokio::sync::RwLock;
@@ -58,6 +59,28 @@ pub struct ServerState {
     node_id: NodeId,
     // Contains OIDC config and Client
     oidc_validator: Option<Arc<OidcValidator>>,
+    interface_state: Arc<RwLock<InterfaceRuntimeState>>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct InterfaceRuntimeState {
+    pub rest: Option<RestInterfaceRuntime>,
+    pub s3: Option<S3InterfaceRuntime>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RestInterfaceRuntime {
+    pub bind_address: SocketAddr,
+    pub base_url: String,
+    pub api_base_url: String,
+    pub info_url: String,
+    pub swagger_ui_url: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct S3InterfaceRuntime {
+    pub bind_address: SocketAddr,
+    pub base_url: String,
 }
 
 impl ServerState {
@@ -101,6 +124,7 @@ impl ServerState {
             trusted_realms_list: Arc::new(RwLock::new(trusted_realms)),
             issuer_keys: Arc::new(RwLock::new(HashMap::default())),
             initial_admin_claim,
+            interface_state: Arc::new(RwLock::new(InterfaceRuntimeState::default())),
         };
         state.persist_trusted_realms().await;
         state
@@ -142,6 +166,23 @@ impl ServerState {
             .ok_or(OidcError::NotConfigured)
     }
 
+    pub async fn register_rest_interface(&self, bind_address: SocketAddr) {
+        let mut interface_state = self.interface_state.write().await;
+        interface_state.rest = Some(RestInterfaceRuntime::from_bind_address(bind_address));
+    }
+
+    pub async fn register_s3_interface(&self, bind_address: SocketAddr, base_url: String) {
+        let mut interface_state = self.interface_state.write().await;
+        interface_state.s3 = Some(S3InterfaceRuntime {
+            bind_address,
+            base_url,
+        });
+    }
+
+    pub async fn interface_state(&self) -> InterfaceRuntimeState {
+        self.interface_state.read().await.clone()
+    }
+
     pub async fn get_oidc_provider_by_token(
         &self,
         selector: &OidcTokenSelector,
@@ -463,3 +504,24 @@ where
 pub fn swagger_ui() -> SwaggerUi {
     SwaggerUi::new("/swagger-ui").url("/api-docs/openapi.json", ApiDoc::openapi())
 }
+
+impl RestInterfaceRuntime {
+    pub fn from_bind_address(bind_address: SocketAddr) -> Self {
+        let host = match bind_address.ip() {
+            std::net::IpAddr::V4(ip) if ip.is_unspecified() => {
+                std::net::Ipv4Addr::LOCALHOST.to_string()
+            }
+            std::net::IpAddr::V6(ip) if ip.is_unspecified() => "::1".to_string(),
+            std::net::IpAddr::V6(ip) => format!("[{ip}]"),
+            std::net::IpAddr::V4(ip) => ip.to_string(),
+        };
+        let base_url = format!("http://{host}:{}", bind_address.port());
+        Self {
+            bind_address,
+            api_base_url: format!("{base_url}/api/v1"),
+            info_url: format!("{base_url}/api/v1/info"),
+            swagger_ui_url: format!("{base_url}/swagger-ui"),
+            base_url,
+        }
+    }
+}
diff --git a/aruna-doctor/src/info.rs b/aruna-doctor/src/info.rs
@@ -306,7 +306,6 @@ mod tests {
     use aruna_operations::incoming::initialize_net_incoming;
     use aruna_operations::task_incoming::initialize_task_incoming;
     use aruna_tasks::TaskHandle;
-    use axum::Router;
     use ed25519_dalek::SigningKey;
     use std::str::FromStr;
     use std::sync::Arc;
@@ -440,14 +439,9 @@ mod tests {
 
         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
         let addr = listener.local_addr().unwrap();
-        let router: Router = Server::new(state, ServerConfig { http_addr: addr }).build_router();
+        let server = Server::new(state, ServerConfig { http_addr: addr });
         let server_task = tokio::spawn(async move {
-            axum::serve(
-                listener,
-                router.into_make_service_with_connect_info::<std::net::SocketAddr>(),
-            )
-            .await
-            .unwrap();
+            server.run_with_listener(listener).await.unwrap();
         });
 
         TestNode {
@@ -575,6 +569,15 @@ mod tests {
         let info = fetch_info(&config).await.unwrap();
 
         assert!(matches!(info.net_state, aruna_api::routes::info::NetStatus::Available { .. }));
+        assert!(matches!(
+            info.interface_status.rest,
+            aruna_api::routes::info::RestInterfaceStatus::Available {
+                ref base_url,
+                ref info_url,
+                ..
+            } if base_url == &format!("http://{}", node.http_addr)
+                && info_url == &format!("http://{}/api/v1/info", node.http_addr)
+        ));
         node.shutdown().await;
     }
 }
diff --git a/aruna/src/main.rs b/aruna/src/main.rs
@@ -32,6 +32,7 @@ use aruna_operations::task_incoming::initialize_task_incoming;
 use aruna_tasks::TaskHandle;
 use std::collections::HashMap;
 use std::sync::Arc;
+use tokio::net::TcpListener;
 use tracing::{error, info, warn};
 
 #[tokio::main]
@@ -228,7 +229,7 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
     let server_config = ServerConfig {
         http_addr: config.http_socket_addr,
     };
-    let server = Server::new(state, server_config);
+    let server = Server::new(state.clone(), server_config);
 
     // S3 Server
     let s3_address = format!("{}:{}", config.s3_address, config.s3_port);
@@ -243,7 +244,17 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
     .await
     .unwrap();
 
-    let server_handle = s3_server.run().await.unwrap();
+    let s3_listener = TcpListener::bind(&s3_address).await.unwrap();
+    let s3_bound_addr = s3_listener.local_addr().unwrap();
+    state
+        .register_s3_interface(
+            s3_bound_addr,
+            format!("http://{}:{}", config.s3_host, s3_bound_addr.port()),
+        )
+        .await;
+    let (_s3_addr, server_handle) = s3_server.run_with_listener(s3_listener).unwrap();
+
+    let rest_listener = TcpListener::bind(config.http_socket_addr).await?;
 
     tokio::select! {
         res = server_handle => {
@@ -252,7 +263,7 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
                 Err(e) => error!("S3 Server panicked: {:?}", e),
             }
         }
-        res = server.run() => {
+        res = server.run_with_listener(rest_listener) => {
             match res {
                 Ok(_) => info!("REST Server stopped normally"),
                 Err(e) => error!("REST Server panicked: {:?}", e),
