feat(status): style fixes and formatting

Signed-off-by: Sergey Matov <[email protected]>

Author: sergeymatov

args/src/lib.rs

@@ -575,7 +575,7 @@ pub struct BmpConfigSection {
 /// 3. **Transfer**: Passed via sealed memfd to the worker process
 /// 4. **Worker Process**: Calls [`LaunchConfiguration::inherit()`] to access the config
 ///
-/// // TODO: implement bytecheck::Validate in addition to CheckBytes on all components of the launch config.
+/// TODO: implement bytecheck::Validate in addition to CheckBytes on all components of the launch config.
 #[derive(
     Debug,
     PartialEq,
@@ -1278,12 +1278,10 @@ E.g. default=error,all=info,nat=debug will set the default target to error, and
     )]
     tracing: Option<String>,
 
-    // ===== BMP ARGS =====
-    /// Enable BMP server
+    /// Enable BMP server, addres and interval
     #[arg(long, default_value_t = false, help = "Enable BMP server")]
     bmp_enable: bool,
 
-    /// BMP bind address
     #[arg(
         long,
         value_name = "IP:PORT",
@@ -1292,7 +1290,6 @@ E.g. default=error,all=info,nat=debug will set the default target to error, and
     )]
     bmp_address: SocketAddr,
 
-    /// BMP periodic interval for housekeeping/flush (ms)
     #[arg(
         long,
         value_name = "MILLISECONDS",

config/src/internal/routing/bgp.rs

@@ -68,7 +68,7 @@ pub struct BgpNeighCapabilities {
     pub ext_nhop: bool,
     pub fqdn: bool,
     pub software_ver: bool,
-    // TODO: ORF
+    // ORF
 }
 
 #[derive(Clone, Debug)]
@@ -350,6 +350,7 @@ impl AfIpv4Ucast {
     pub fn set_vrf_imports(&mut self, imports: VrfImports) {
         self.imports = Some(imports);
     }
+    // redistribution is configured by adding one or more redistribute objects
     pub fn redistribute(&mut self, redistribute: Redistribute) {
         self.redistribute.push(redistribute);
     }

mgmt/src/processor/confbuild/internal.rs

@@ -181,12 +181,8 @@ impl VpcRoutingConfigIpv4 {
     }
 }
 
-/// Build BGP config for a VPC VRF (no BMP attached here!)
-fn vpc_vrf_bgp_config(
-    vpc: &Vpc,
-    asn: u32,
-    router_id: Option<Ipv4Addr>,
-) -> BgpConfig {
+/// Build BGP config for a VPC VRF (bmp is applied elsewhere)
+fn vpc_vrf_bgp_config(vpc: &Vpc, asn: u32, router_id: Option<Ipv4Addr>) -> BgpConfig {
     let mut bgp = BgpConfig::new(asn).set_vrf_name(vpc.vrf_name());
     if let Some(router_id) = router_id {
         bgp.set_router_id(router_id);
@@ -233,7 +229,7 @@ fn build_vpc_internal_config(
     /* build VRF config */
     let mut vrf_cfg = vpc_vrf_config(vpc)?;
 
-    /* build bgp config (no BMP here) */
+    /* build bgp config */
     let mut bgp = vpc_vrf_bgp_config(vpc, asn, router_id);
 
     if vpc.num_peerings() > 0 {
@@ -269,7 +265,7 @@ fn build_internal_overlay_config(
     Ok(())
 }
 
-/// Public entry — build without BMP
+/// without BMP
 pub fn build_internal_config(config: &GwConfig) -> Result<InternalConfig, ConfigError> {
     build_internal_config_with_bmp(config, None)
 }
@@ -307,12 +303,7 @@ pub fn build_internal_config_with_bmp(
         let asn = bgp.asn;
         let router_id = bgp.router_id;
         if !external.overlay.vpc_table.is_empty() {
-            build_internal_overlay_config(
-                &external.overlay,
-                asn,
-                router_id,
-                &mut internal,
-            )?;
+            build_internal_overlay_config(&external.overlay, asn, router_id, &mut internal)?;
         } else {
             debug!("The configuration does not specify any VPCs...");
         }

mgmt/src/processor/proc.rs

@@ -280,7 +280,6 @@ impl ConfigProcessor {
 
     /// RPC handler: get dataplane status
     async fn handle_get_dataplane_status(&mut self) -> ConfigResponse {
-        // std::sync::RwLock::read() -> Result<Guard, PoisonError>. Unwrap then clone.
         let mut status: DataplaneStatus = {
             let guard = self
                 .proc_params
@@ -675,10 +674,6 @@ async fn apply_gw_config(
     let pairs = update_stats_vpc_mappings(config, vpcmapw);
     drop(pairs); // pairs used by caller
 
-    // NOTE: If we need to inject/override BMP per-VRF here, prefer adding a helper once
-    // InternalConfig exposes a mutable VRF accessor. For now, BMP config is built in
-    // the internal build stage and applied by the routing layer.
-
     /* apply config in router */
     apply_router_config(&kernel_vrfs, config, router_ctl).await?;
 

routing/src/bmp/bmp_render.rs

@@ -1,26 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright Open Network Fabric Authors
 
-//! Minimal & safe renderer for NetGauze BMP messages into DataplaneStatus.
-//! Keeps API usage conservative and aligned with the code you pasted.
+//! BMP message handlers to update internal DataplaneStatus model.
 
 use netgauze_bgp_pkt::BgpMessage;
-use netgauze_bmp_pkt::{BmpMessage, BmpPeerType};
 use netgauze_bmp_pkt::v3::{
     BmpMessageValue, PeerDownNotificationMessage, PeerUpNotificationMessage,
     RouteMonitoringMessage, StatisticsReportMessage,
 };
+use netgauze_bmp_pkt::{BmpMessage, BmpPeerType};
 
 use config::internal::status::{
     BgpMessageCounters, BgpMessages, BgpNeighborPrefixes, BgpNeighborSessionState,
     BgpNeighborStatus, BgpStatus, BgpVrfStatus, DataplaneStatus,
 };
 
-// -----------------------------------------------------------------------------
-// Public entry points
-// -----------------------------------------------------------------------------
-
-/// Backward-compat shim for older callers (typo in earlier drafts).
 #[inline]
 pub fn hande_bmp_message(status: &mut DataplaneStatus, msg: &BmpMessage) {
     handle_bmp_message(status, msg)
@@ -41,11 +35,6 @@ pub fn handle_bmp_message(status: &mut DataplaneStatus, msg: &BmpMessage) {
         BmpMessage::V4(_) => {}
     }
 }
-
-// -----------------------------------------------------------------------------
-// Helpers: mapping / extraction
-// -----------------------------------------------------------------------------
-
 fn key_from_peer_header(peer: &netgauze_bmp_pkt::PeerHeader) -> String {
     // Build a stable-ish key: "<bgp_id>-<peer_as>-<ip|-none>-<rd?>"
     let id = peer.bgp_id();
@@ -84,10 +73,7 @@ fn ensure_vrf<'a>(bgp: &'a mut BgpStatus, vrf: &str) -> &'a mut BgpVrfStatus {
     bgp.vrfs.entry(vrf.to_string()).or_default()
 }
 
-fn ensure_neighbor<'a>(
-    vrf: &'a mut BgpVrfStatus,
-    neigh_key: &str,
-) -> &'a mut BgpNeighborStatus {
+fn ensure_neighbor<'a>(vrf: &'a mut BgpVrfStatus, neigh_key: &str) -> &'a mut BgpNeighborStatus {
     vrf.neighbors
         .entry(neigh_key.to_string())
         .or_insert_with(|| BgpNeighborStatus {
@@ -109,10 +95,6 @@ fn post_policy_from_peer_type(pt: BmpPeerType) -> bool {
     }
 }
 
-// -----------------------------------------------------------------------------
-// Handlers
-// -----------------------------------------------------------------------------
-
 fn on_peer_up(status: &mut DataplaneStatus, pu: &PeerUpNotificationMessage) {
     let peer = pu.peer_header();
     let vrf = get_vrf_from_peer_header(peer);
@@ -127,13 +109,10 @@ fn on_peer_up(status: &mut DataplaneStatus, pu: &PeerUpNotificationMessage) {
     neigh.remote_router_id = peer.bgp_id().to_string();
     neigh.peer_port = pu.remote_port().unwrap_or_default() as u32;
     set_neighbor_session_state(neigh, BgpNeighborSessionState::Established);
-
-    // Optional: try to infer local_as from the OPEN we sent (kept simple)
     if let BgpMessage::Open(open) = pu.sent_message() {
         neigh.local_as = open.my_as() as u32;
     }
 
-    // Initialize empty message counters on establishment
     if neigh.messages.is_none() {
         neigh.messages = Some(BgpMessages {
             received: Some(BgpMessageCounters::new()),
@@ -187,9 +166,7 @@ fn on_route_monitoring(status: &mut DataplaneStatus, rm: &RouteMonitoringMessage
 
     // We don't parse NLRI depth here; increment by 1 as a placeholder per RM message
     if post {
-        pref.received_pre_policy = pref
-            .received_pre_policy
-            .saturating_add(0); // post-policy => don't bump pre
+        pref.received_pre_policy = pref.received_pre_policy.saturating_add(0); // post-policy => don't bump pre
         pref.received = pref.received.saturating_add(1);
     } else {
         pref.received_pre_policy = pref.received_pre_policy.saturating_add(1);
@@ -212,6 +189,5 @@ fn on_statistics(status: &mut DataplaneStatus, sr: &StatisticsReportMessage) {
         sent: Some(BgpMessageCounters::new()),
     });
 
-    // You can walk `sr.counters()` and map specific statistics to your model later.
-    // For now, we keep StatisticsReport as a no-op for counters.
+    //TODO: smatov: add more later
 }

routing/src/bmp/server.rs

@@ -103,16 +103,14 @@ async fn handle_peer<H: BmpHandler>(
     if cfg.tcp_nodelay {
         let _ = sock.set_nodelay(true);
     }
-    // NOTE: cfg.tcp_recv_buf kept for future tuning; Tokio has no stable API to set recv buf.
-
     // Frame the stream as BMP
     let codec = BmpCodec::default();
     let mut reader = FramedRead::new(sock, codec);
 
     while let Some(frame) = reader.next().await {
         match frame {
             Ok(msg) => {
-                // netgauze_bmp_pkt::BmpMessage for both v3 and v4
+                // netgauze_bmp_pkt::BmpMessage for both v3 and v4. TODO: smatov: v4 handling
                 handler.on_message(peer, msg).await;
             }
             Err(e) => {

routing/src/frr/renderer/bgp.rs

@@ -326,6 +326,7 @@ impl Render for AfIpv4Ucast {
         cfg += MARKER;
         cfg += "address-family ipv4 unicast";
 
+        /* activate neighbors in AF */
         bgp.neighbors
             .iter()
             .filter(|neigh| neigh.ipv4_unicast)
@@ -361,6 +362,7 @@ impl Render for AfIpv6Ucast {
         cfg += MARKER;
         cfg += "address-family ipv6 unicast";
 
+        /* activate neighbors in AF */
         bgp.neighbors
             .iter()
             .filter(|neigh| neigh.ipv6_unicast)
@@ -396,6 +398,7 @@ impl Render for AfL2vpnEvpn {
         cfg += MARKER;
         cfg += "address-family l2vpn evpn";
 
+        /* activate neighbors in AF */
         bgp.neighbors
             .iter()
             .filter(|neigh| neigh.l2vpn_evpn)
@@ -506,7 +509,7 @@ impl Render for BgpConfig {
             config += format!(" bgp router-id {router_id}");
         }
 
-        /* BGP options */
+        /* BGP options: todo */
         config += self.options.render(&());
 
         /* BGP neighbors */

routing/src/router/mod.rs

@@ -173,8 +173,8 @@ impl Router {
         Ok(router)
     }
 
-    /// Stop this router. This stops the router IO task and drops the interface table, adjacency table,
-    /// VRF table and the FIB table.
+    /// Stop this router. This stops the router IO thread and drops the interface table, adjacency table
+    /// vrf table and the fib table.
     pub fn stop(&mut self) {
         if let Err(e) = self.rio_handle.finish() {
             error!("Failed to stop IO for router '{}': {e}", self.name);