feat(status): add TryFrom for BGP Dataplane status section

sergeymatov · sergeymatov · commit 8978fb7f2bc6 · 2026-01-12T20:23:52.000+04:00
Signed-off-by: Sergey Matov &lt;sergey.matov@githedgehog.com&gt;
diff --git a/config/src/converters/k8s/status/bgp.rs b/config/src/converters/k8s/status/bgp.rs
@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+use std::collections::BTreeMap;
+
+use k8s_intf::gateway_agent_crd::{
+    GatewayAgentStatusStateBgp, GatewayAgentStatusStateBgpVrfs,
+    GatewayAgentStatusStateBgpVrfsNeighbors,
+    GatewayAgentStatusStateBgpVrfsNeighborsIpv4UnicastPrefixes,
+    GatewayAgentStatusStateBgpVrfsNeighborsIpv6UnicastPrefixes,
+    GatewayAgentStatusStateBgpVrfsNeighborsL2VpnevpnPrefixes,
+    GatewayAgentStatusStateBgpVrfsNeighborsMessages,
+    GatewayAgentStatusStateBgpVrfsNeighborsMessagesReceived,
+    GatewayAgentStatusStateBgpVrfsNeighborsMessagesSent,
+    GatewayAgentStatusStateBgpVrfsNeighborsSessionState,
+};
+
+use crate::converters::k8s::ToK8sConversionError;
+use crate::internal::status::{
+    BgpMessageCounters, BgpMessages, BgpNeighborPrefixes, BgpNeighborSessionState,
+    BgpNeighborStatus, BgpStatus, BgpVrfStatus,
+};
+
+fn u64_to_i64_sat(v: u64) -> i64 {
+    i64::try_from(v).unwrap_or(i64::MAX)
+}
+
+fn u32_to_i32_sat(v: u32) -> i32 {
+    i32::try_from(v).unwrap_or(i32::MAX)
+}
+
+impl TryFrom<&BgpStatus> for GatewayAgentStatusStateBgp {
+    type Error = ToK8sConversionError;
+
+    fn try_from(status: &BgpStatus) -> Result<Self, Self::Error> {
+        let vrfs = status
+            .vrfs
+            .iter()
+            .map(|(k, v)| Ok((k.clone(), GatewayAgentStatusStateBgpVrfs::try_from(v)?)))
+            .collect::<Result<BTreeMap<_, _>, _>>()?;
+
+        Ok(GatewayAgentStatusStateBgp {
+            vrfs: Some(vrfs).filter(|m| !m.is_empty()),
+        })
+    }
+}
+
+impl TryFrom<&BgpVrfStatus> for GatewayAgentStatusStateBgpVrfs {
+    type Error = ToK8sConversionError;
+
+    fn try_from(status: &BgpVrfStatus) -> Result<Self, Self::Error> {
+        let neighbors = status
+            .neighbors
+            .iter()
+            .map(|(k, v)| {
+                Ok((
+                    k.clone(),
+                    GatewayAgentStatusStateBgpVrfsNeighbors::try_from(v)?,
+                ))
+            })
+            .collect::<Result<BTreeMap<_, _>, _>>()?;
+
+        Ok(GatewayAgentStatusStateBgpVrfs {
+            neighbors: Some(neighbors).filter(|m| !m.is_empty()),
+        })
+    }
+}
+
+impl TryFrom<&BgpNeighborStatus> for GatewayAgentStatusStateBgpVrfsNeighbors {
+    type Error = ToK8sConversionError;
+
+    fn try_from(status: &BgpNeighborStatus) -> Result<Self, Self::Error> {
+        let session_state = match status.session_state {
+            BgpNeighborSessionState::Unset => {
+                GatewayAgentStatusStateBgpVrfsNeighborsSessionState::Unset
+            }
+            BgpNeighborSessionState::Idle => {
+                GatewayAgentStatusStateBgpVrfsNeighborsSessionState::Idle
+            }
+            BgpNeighborSessionState::Connect => {
+                GatewayAgentStatusStateBgpVrfsNeighborsSessionState::Connect
+            }
+            BgpNeighborSessionState::Active => {
+                GatewayAgentStatusStateBgpVrfsNeighborsSessionState::Active
+            }
+            BgpNeighborSessionState::Open => {
+                GatewayAgentStatusStateBgpVrfsNeighborsSessionState::Open
+            }
+            BgpNeighborSessionState::Established => {
+                GatewayAgentStatusStateBgpVrfsNeighborsSessionState::Established
+            }
+        };
+
+        Ok(GatewayAgentStatusStateBgpVrfsNeighbors {
+            enabled: Some(status.enabled),
+            local_as: Some(u32_to_i32_sat(status.local_as)),
+            peer_as: Some(u32_to_i32_sat(status.peer_as)),
+            remote_router_id: Some(status.remote_router_id.clone()),
+            session_state: Some(session_state),
+
+            connections_dropped: Some(status.connections_dropped),
+            // NOTE: generated CRD uses i64 here
+            established_transitions: Some(u64_to_i64_sat(status.established_transitions)),
+            last_reset_reason: Some(status.last_reset_reason.clone()),
+
+            messages: status
+                .messages
+                .as_ref()
+                .map(GatewayAgentStatusStateBgpVrfsNeighborsMessages::try_from)
+                .transpose()?,
+
+            ipv4_unicast_prefixes: status
+                .ipv4_unicast_prefixes
+                .as_ref()
+                .map(GatewayAgentStatusStateBgpVrfsNeighborsIpv4UnicastPrefixes::try_from)
+                .transpose()?,
+
+            ipv6_unicast_prefixes: status
+                .ipv6_unicast_prefixes
+                .as_ref()
+                .map(GatewayAgentStatusStateBgpVrfsNeighborsIpv6UnicastPrefixes::try_from)
+                .transpose()?,
+
+            l2_vpnevpn_prefixes: status
+                .l2vpn_evpn_prefixes
+                .as_ref()
+                .map(GatewayAgentStatusStateBgpVrfsNeighborsL2VpnevpnPrefixes::try_from)
+                .transpose()?,
+        })
+    }
+}
+
+impl TryFrom<&BgpNeighborPrefixes> for GatewayAgentStatusStateBgpVrfsNeighborsIpv4UnicastPrefixes {
+    type Error = ToK8sConversionError;
+
+    fn try_from(p: &BgpNeighborPrefixes) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStateBgpVrfsNeighborsIpv4UnicastPrefixes {
+            received: Some(u32_to_i32_sat(p.received)),
+            received_pre_policy: Some(u32_to_i32_sat(p.received_pre_policy)),
+            sent: Some(u32_to_i32_sat(p.sent)),
+        })
+    }
+}
+
+impl TryFrom<&BgpNeighborPrefixes> for GatewayAgentStatusStateBgpVrfsNeighborsIpv6UnicastPrefixes {
+    type Error = ToK8sConversionError;
+
+    fn try_from(p: &BgpNeighborPrefixes) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStateBgpVrfsNeighborsIpv6UnicastPrefixes {
+            received: Some(u32_to_i32_sat(p.received)),
+            received_pre_policy: Some(u32_to_i32_sat(p.received_pre_policy)),
+            sent: Some(u32_to_i32_sat(p.sent)),
+        })
+    }
+}
+
+impl TryFrom<&BgpNeighborPrefixes> for GatewayAgentStatusStateBgpVrfsNeighborsL2VpnevpnPrefixes {
+    type Error = ToK8sConversionError;
+
+    fn try_from(p: &BgpNeighborPrefixes) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStateBgpVrfsNeighborsL2VpnevpnPrefixes {
+            received: Some(u32_to_i32_sat(p.received)),
+            received_pre_policy: Some(u32_to_i32_sat(p.received_pre_policy)),
+            sent: Some(u32_to_i32_sat(p.sent)),
+        })
+    }
+}
+
+impl TryFrom<&BgpMessages> for GatewayAgentStatusStateBgpVrfsNeighborsMessages {
+    type Error = ToK8sConversionError;
+
+    fn try_from(m: &BgpMessages) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStateBgpVrfsNeighborsMessages {
+            received: m
+                .received
+                .as_ref()
+                .map(GatewayAgentStatusStateBgpVrfsNeighborsMessagesReceived::try_from)
+                .transpose()?,
+            sent: m
+                .sent
+                .as_ref()
+                .map(GatewayAgentStatusStateBgpVrfsNeighborsMessagesSent::try_from)
+                .transpose()?,
+        })
+    }
+}
+
+impl TryFrom<&BgpMessageCounters> for GatewayAgentStatusStateBgpVrfsNeighborsMessagesReceived {
+    type Error = ToK8sConversionError;
+
+    fn try_from(c: &BgpMessageCounters) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStateBgpVrfsNeighborsMessagesReceived {
+            capability: Some(u64_to_i64_sat(c.capability)),
+            keepalive: Some(u64_to_i64_sat(c.keepalive)),
+            notification: Some(u64_to_i64_sat(c.notification)),
+            open: Some(u64_to_i64_sat(c.open)),
+            route_refresh: Some(u64_to_i64_sat(c.route_refresh)),
+            update: Some(u64_to_i64_sat(c.update)),
+        })
+    }
+}
+
+impl TryFrom<&BgpMessageCounters> for GatewayAgentStatusStateBgpVrfsNeighborsMessagesSent {
+    type Error = ToK8sConversionError;
+
+    fn try_from(c: &BgpMessageCounters) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStateBgpVrfsNeighborsMessagesSent {
+            capability: Some(u64_to_i64_sat(c.capability)),
+            keepalive: Some(u64_to_i64_sat(c.keepalive)),
+            notification: Some(u64_to_i64_sat(c.notification)),
+            open: Some(u64_to_i64_sat(c.open)),
+            route_refresh: Some(u64_to_i64_sat(c.route_refresh)),
+            update: Some(u64_to_i64_sat(c.update)),
+        })
+    }
+}
diff --git a/config/src/converters/k8s/status/dataplane_status.rs b/config/src/converters/k8s/status/dataplane_status.rs
@@ -6,8 +6,9 @@ use std::collections::BTreeMap;
 use chrono::{DateTime, Utc};
 
 use k8s_intf::gateway_agent_crd::{
-    GatewayAgentStatus, GatewayAgentStatusState, GatewayAgentStatusStateDataplane,
-    GatewayAgentStatusStateFrr, GatewayAgentStatusStatePeerings, GatewayAgentStatusStateVpcs,
+    GatewayAgentStatus, GatewayAgentStatusState, GatewayAgentStatusStateBgp,
+    GatewayAgentStatusStateDataplane, GatewayAgentStatusStateFrr, GatewayAgentStatusStatePeerings,
+    GatewayAgentStatusStateVpcs,
 };
 
 use crate::converters::k8s::ToK8sConversionError;
@@ -69,6 +70,16 @@ impl TryFrom<&DataplaneStatusForK8sConversion<'_>> for GatewayAgentStatus {
             })
             .transpose()?;
 
+        let bgp = status
+            .status
+            .and_then(|status| {
+                status
+                    .bgp
+                    .as_ref()
+                    .map(GatewayAgentStatusStateBgp::try_from)
+            })
+            .transpose()?;
+
         Ok(GatewayAgentStatus {
             agent_version: None,
             last_applied_gen: status.last_applied_gen,
@@ -79,6 +90,7 @@ impl TryFrom<&DataplaneStatusForK8sConversion<'_>> for GatewayAgentStatus {
                 .last_heartbeat
                 .map(|lhb| lhb.to_rfc3339_opts(chrono::SecondsFormat::Nanos, true)),
             state: status.status.map(|_| GatewayAgentStatusState {
+                bgp,
                 dataplane: Some(GatewayAgentStatusStateDataplane {
                     version: Some(option_env!("VERSION").unwrap_or("dev").to_string()),
                 }),
diff --git a/config/src/converters/k8s/status/mod.rs b/config/src/converters/k8s/status/mod.rs
@@ -3,6 +3,7 @@
 
 //! Converter for gateway-schema k8s objects from internal status
 
+pub mod bgp;
 pub mod dataplane_status;
 pub mod frr;
 pub mod peerings;
diff --git a/mgmt/src/processor/k8s_client.rs b/mgmt/src/processor/k8s_client.rs
@@ -12,7 +12,7 @@ use config::converters::k8s::ToK8sConversionError;
 use config::converters::k8s::status::dataplane_status::DataplaneStatusForK8sConversion;
 use config::{ExternalConfig, GwConfig};
 use k8s_intf::client::{
-    ReplaceStatusError, WatchError, replace_gateway_status, watch_gateway_agent_crd,
+    replace_gateway_status, watch_gateway_agent_crd, ReplaceStatusError, WatchError,
 };
 use k8s_intf::gateway_agent_crd::{
     GatewayAgentStatus, GatewayAgentStatusState, GatewayAgentStatusStateDataplane,
@@ -41,9 +41,7 @@ fn to_datetime(opt_time: Option<&SystemTime>) -> chrono::DateTime<Utc> {
 }
 
 /// Main function to create a `GatewayAgentStatus` object
-pub(crate) async fn build_gateway_status(
-    config_client: &ConfigClient,
-) -> Option<GatewayAgentStatus> {
+pub(crate) async fn build_gateway_status(config_client: &ConfigClient) -> Option<GatewayAgentStatus> {
     let status = config_client.get_status().await;
     let status = match status {
         Ok(status) => status,
@@ -109,6 +107,7 @@ impl K8sClient {
                     chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Nanos, true),
                 ),
                 state: Some(GatewayAgentStatusState {
+                    bgp: None,
                     dataplane: Some(GatewayAgentStatusStateDataplane {
                         version: Some(option_env!("VERSION").unwrap_or("dev").to_string()),
                     }),
@@ -162,7 +161,7 @@ impl K8sClient {
                         Ok(()) => {
                             info!("Config for generation {genid} was successfully applied. Updating status...");
                             k8s_client.update_gateway_status().await;
-                        },
+                        }
                         Err(e) => error!("Failed to apply the config for generation {genid}: {e}"),
                     }
                 }
diff --git a/routing/src/bmp/bmp_render.rs b/routing/src/bmp/bmp_render.rs
@@ -106,7 +106,10 @@ fn on_peer_up(status: &mut DataplaneStatus, pu: &PeerUpNotificationMessage) {
 
     let peer_as = peer.peer_as();
     let bgp_id = peer.bgp_id().to_string();
-    let peer_addr = peer.address().map(|a| a.to_string()).unwrap_or_else(|| "none".to_string());
+    let peer_addr = peer
+        .address()
+        .map(|a| a.to_string())
+        .unwrap_or_else(|| "none".to_string());
     let peer_port = pu.remote_port().unwrap_or_default() as u32;
 
     let bgp = ensure_bgp(status);
@@ -181,13 +184,19 @@ fn on_peer_down(status: &mut DataplaneStatus, pd: &PeerDownNotificationMessage)
                     neigh.connections_dropped
                 );
             } else {
-                debug!("BMP: peer-down for unknown neighbor: vrf={} key={}", vrf, key);
+                debug!(
+                    "BMP: peer-down for unknown neighbor: vrf={} key={}",
+                    vrf, key
+                );
             }
         } else {
             debug!("BMP: peer-down for unknown vrf: vrf={} key={}", vrf, key);
         }
     } else {
-        debug!("BMP: peer-down but DataplaneStatus.bgp is None (vrf={} key={})", vrf, key);
+        debug!(
+            "BMP: peer-down but DataplaneStatus.bgp is None (vrf={} key={})",
+            vrf, key
+        );
     }
 }
 
diff --git a/routing/src/bmp/mod.rs b/routing/src/bmp/mod.rs
@@ -12,7 +12,7 @@ use concurrency::sync::{Arc, RwLock};
 use config::internal::status::DataplaneStatus;
 use netgauze_bmp_pkt::BmpMessage;
 use tokio::task::JoinHandle;
-use tracing::{error, info, debug};
+use tracing::{debug, error, info};
 
 /// Background BMP server runner that updates shared dataplane status.
 pub struct StatusHandler {
diff --git a/routing/src/bmp/server.rs b/routing/src/bmp/server.rs
@@ -16,8 +16,8 @@ use tokio::net::{TcpListener, TcpStream};
 use tokio::task::JoinSet;
 use tokio_util::codec::FramedRead;
 
-use tracing::debug;
 use crate::bmp::handler::BmpHandler;
+use tracing::debug;
 
 #[derive(Clone, Debug)]
 pub struct BmpServerConfig {
