Add bound and advertised addresses to GetIdent

Adds bound_addresses and advertised_addresses to GetIdent responses to enable tools and automations to extract that information for future use.

Author: AhmedSoliman

crates/core/build.rs

@@ -28,6 +28,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     tonic_prost_build::configure()
         .bytes(".")
+        .enum_attribute("AddressKind", "#[derive(::serde::Serialize)]")
+        .enum_attribute("AddressKind", "#[serde(rename_all = \"kebab-case\")]")
         .file_descriptor_set_path(out_dir.join("node_ctl_svc_descriptor.bin"))
         // allow older protobuf compiler to be used
         .protoc_arg("--experimental_allow_proto3_optional")

crates/core/protobuf/node_ctl_svc.proto

@@ -55,6 +55,17 @@ message ProvisionClusterResponse {
 }
 
 message IdentResponse {
+  enum AddressKind {
+    UNKNOWN = 0;
+    TCP = 1;
+    HTTP = 2;
+    UNIX = 3;
+  }
+  message NetAddress {
+    string name = 1;
+    string address = 2;
+    AddressKind kind = 3;
+  }
   restate.common.NodeStatus status = 1;
   // node id may be unset if the node hasn't yet joined a cluster
   optional restate.common.NodeId node_id = 2;
@@ -72,6 +83,8 @@ message IdentResponse {
   uint32 logs_version = 11;
   uint32 schema_version = 12;
   uint32 partition_table_version = 13;
+  repeated NetAddress bound_addresses = 14;
+  repeated NetAddress advertised_addresses = 15;
 }
 
 message GetMetadataRequest {

crates/core/src/identification.rs

@@ -8,6 +8,9 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 
+// re-export the AddressKind enum from the protobuf
+pub use crate::protobuf::node_ctl_svc::ident_response::AddressKind as NetAddressKind;
+
 use std::time::Duration;
 
 use enumset::EnumSet;
@@ -18,6 +21,11 @@ use restate_types::config::Configuration;
 use restate_types::health::{
     AdminStatus, LogServerStatus, MetadataServerStatus, NodeStatus, WorkerStatus,
 };
+use restate_types::net::address::{
+    AdminPort, AdvertisedAddress, ControlPort, FabricPort, HttpIngressPort, ListenerPort,
+    PeerNetAddress,
+};
+use restate_types::net::listener::{AddressBook, Addresses};
 use restate_types::nodes_config::Role;
 use restate_types::{NodeId, Version};
 
@@ -45,6 +53,16 @@ pub struct Identification {
     pub logs_version: Version,
     pub schema_version: Version,
     pub partition_table_version: Version,
+    pub bound_addresses: Vec<NetAddress>,
+    pub advertised_addresses: Vec<NetAddress>,
+}
+
+#[derive(serde::Serialize, prost_dto::IntoProst)]
+#[prost(target = "crate::protobuf::node_ctl_svc::ident_response::NetAddress")]
+pub struct NetAddress {
+    pub name: String,
+    pub address: String,
+    pub kind: NetAddressKind,
 }
 
 fn enum_set_to_vec(roles: &EnumSet<Role>) -> Vec<String> {
@@ -55,20 +73,34 @@ impl Identification {
     /// Gets the identification information for this node. It needs to be called from within the
     /// [`TaskCenter`].
     pub fn get() -> Self {
-        let (node_status, admin_status, worker_status, metadata_server_status, log_server_status) =
-            TaskCenter::with_current(|tc| {
-                let health = tc.health();
-                (
-                    health.current_node_status(),
-                    health.current_admin_status(),
-                    health.current_worker_status(),
-                    health.current_metadata_store_status(),
-                    health.current_log_server_status(),
-                )
-            });
+        let configuration = Configuration::pinned();
+
+        let (
+            node_status,
+            admin_status,
+            worker_status,
+            metadata_server_status,
+            log_server_status,
+            bound_addresses,
+            advertised_addresses,
+        ) = TaskCenter::with_current(|tc| {
+            let health = tc.health();
+            let address_book = tc.address_book();
+
+            let bound_addresses = collect_bound_addresses(address_book);
+            let advertised_addresses = collect_advertised_addresses(&configuration, address_book);
+            (
+                health.current_node_status(),
+                health.current_admin_status(),
+                health.current_worker_status(),
+                health.current_metadata_store_status(),
+                health.current_log_server_status(),
+                bound_addresses,
+                advertised_addresses,
+            )
+        });
         let age = TaskCenter::with_current(|tc| tc.age());
         let metadata = Metadata::current();
-        let configuration = Configuration::pinned();
 
         Identification {
             status: node_status,
@@ -84,6 +116,108 @@ impl Identification {
             logs_version: metadata.logs_version(),
             schema_version: metadata.schema_version(),
             partition_table_version: metadata.partition_table_version(),
+            bound_addresses,
+            advertised_addresses,
         }
     }
 }
+
+fn collect_bound_addresses(address_book: &AddressBook) -> Vec<NetAddress> {
+    let mut addresses = Vec::with_capacity(4);
+
+    push_addresses(
+        address_book.get_bound_addresses::<HttpIngressPort>(),
+        &mut addresses,
+    );
+
+    push_addresses(
+        address_book.get_bound_addresses::<AdminPort>(),
+        &mut addresses,
+    );
+
+    push_addresses(
+        address_book.get_bound_addresses::<FabricPort>(),
+        &mut addresses,
+    );
+
+    push_addresses(
+        address_book.get_bound_addresses::<ControlPort>(),
+        &mut addresses,
+    );
+
+    addresses
+}
+
+fn collect_advertised_addresses(
+    config: &Configuration,
+    address_book: &AddressBook,
+) -> Vec<NetAddress> {
+    let mut addresses = Vec::with_capacity(3);
+
+    if config.has_role(Role::HttpIngress) {
+        push_advertised(
+            config.ingress.advertised_address(address_book),
+            &mut addresses,
+        );
+    }
+
+    if config.has_role(Role::Admin) {
+        push_advertised(
+            config.admin.advertised_address(address_book),
+            &mut addresses,
+        );
+    }
+
+    // fabric
+    push_advertised(
+        config.common.advertised_address(address_book),
+        &mut addresses,
+    );
+
+    addresses
+}
+
+#[inline(always)]
+fn push_addresses<P: ListenerPort + 'static>(
+    address: Option<Addresses<P>>,
+    buf: &mut Vec<NetAddress>,
+) {
+    let Some(addresses) = address else {
+        return;
+    };
+
+    if let Some(tcp_bind_address) = addresses.tcp_bind_address() {
+        buf.push(NetAddress {
+            name: P::NAME.to_owned(),
+            address: tcp_bind_address.to_string(),
+            kind: NetAddressKind::Tcp,
+        });
+    }
+
+    if let Some(uds_path) = addresses.uds_path() {
+        buf.push(NetAddress {
+            name: P::NAME.to_owned(),
+            address: uds_path.display().to_string(),
+            kind: NetAddressKind::Unix,
+        });
+    }
+}
+
+#[inline(always)]
+fn push_advertised<P: ListenerPort + 'static>(
+    address: AdvertisedAddress<P>,
+    buf: &mut Vec<NetAddress>,
+) {
+    let Ok(address) = address.into_address() else {
+        return;
+    };
+
+    buf.push(NetAddress {
+        kind: match &address {
+            PeerNetAddress::Uds(..) => NetAddressKind::Unix,
+            PeerNetAddress::Http(..) => NetAddressKind::Http,
+        },
+        name: P::NAME.to_owned(),
+        address: address.to_string(),
+    })
+}

crates/types/src/net/listener.rs

@@ -383,13 +383,22 @@ impl Drop for ListenersErased {
     }
 }
 
-#[allow(dead_code)]
 pub struct Addresses<P: ListenerPort> {
     tcp_bind_address: Option<SocketAddr>,
     uds_path: Option<PathBuf>,
     _phantom: std::marker::PhantomData<P>,
 }
 
+impl<P: ListenerPort + 'static> Addresses<P> {
+    pub fn tcp_bind_address(&self) -> Option<SocketAddr> {
+        self.tcp_bind_address
+    }
+
+    pub fn uds_path(&self) -> Option<&PathBuf> {
+        self.uds_path.as_ref()
+    }
+}
+
 #[derive(Default)]
 pub struct Listeners<P: ListenerPort> {
     tcp_listener: Option<TcpListener>,