feat(status): Move BMP into separate config file

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

Author: sergeymatov

config/src/internal/routing/bmp.rs

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+//! Dataplane configuration model: BMP (BGP Monitoring Protocol)
+
+#![allow(unused)]
+
+use std::net::IpAddr;
+
+#[derive(Clone, Debug)]
+pub enum BmpSource {
+    Address(IpAddr),
+    Interface(String),
+}
+
+#[derive(Clone, Debug)]
+pub struct BmpOptions {
+    /// Name for `bmp targets <name>`
+    pub target_name: String,
+    /// Collector host/IP in `bmp connect`
+    pub connect_host: String,
+    /// Collector TCP port
+    pub port: u16,
+    /// Optional local source (address or interface)
+    pub source: Option<BmpSource>,
+    /// Optional reconnect backoff (ms)
+    pub min_retry_ms: Option<u64>,
+    pub max_retry_ms: Option<u64>,
+    /// `bmp stats interval` (ms)
+    pub stats_interval_ms: u64,
+    /// Monitoring toggles
+    pub monitor_ipv4_pre: bool,
+    pub monitor_ipv4_post: bool,
+    pub monitor_ipv6_pre: bool,
+    pub monitor_ipv6_post: bool,
+
+    /// VRFs/views to import into the default BMP instance:
+    /// renders as multiple `bmp import-vrf-view <vrf>`
+    pub import_vrf_views: Vec<String>,
+}
+
+impl Default for BmpOptions {
+    fn default() -> Self {
+        Self {
+            target_name: "bmp1".to_string(),
+            connect_host: "127.0.0.1".to_string(),
+            port: 5000,
+            source: None,
+            min_retry_ms: Some(1_000),
+            max_retry_ms: Some(20_000),
+            stats_interval_ms: 60_000,
+            monitor_ipv4_pre: true,
+            monitor_ipv4_post: true,
+            monitor_ipv6_pre: false,
+            monitor_ipv6_post: false,
+            import_vrf_views: Vec::new(),
+        }
+    }
+}
+
+impl BmpOptions {
+    #[must_use]
+    pub fn new<T: Into<String>, H: Into<String>>(
+        target_name: T,
+        connect_host: H,
+        port: u16,
+    ) -> Self {
+        Self {
+            target_name: target_name.into(),
+            connect_host: connect_host.into(),
+            port,
+            ..Default::default()
+        }
+    }
+
+    #[must_use]
+    pub fn set_source_addr(mut self, ip: IpAddr) -> Self {
+        self.source = Some(BmpSource::Address(ip));
+        self
+    }
+
+    #[must_use]
+    pub fn set_source_interface<S: Into<String>>(mut self, ifname: S) -> Self {
+        self.source = Some(BmpSource::Interface(ifname.into()));
+        self
+    }
+
+    #[must_use]
+    pub fn set_retry_ms(mut self, min_ms: u64, max_ms: u64) -> Self {
+        self.min_retry_ms = Some(min_ms);
+        self.max_retry_ms = Some(max_ms);
+        self
+    }
+
+    #[must_use]
+    pub fn set_stats_interval_ms(mut self, ms: u64) -> Self {
+        self.stats_interval_ms = ms;
+        self
+    }
+
+    #[must_use]
+    pub fn monitor_ipv4(mut self, pre: bool, post: bool) -> Self {
+        self.monitor_ipv4_pre = pre;
+        self.monitor_ipv4_post = post;
+        self
+    }
+
+    #[must_use]
+    pub fn monitor_ipv6(mut self, pre: bool, post: bool) -> Self {
+        self.monitor_ipv6_pre = pre;
+        self.monitor_ipv6_post = post;
+        self
+    }
+
+    #[must_use]
+    pub fn add_import_vrf_view<S: Into<String>>(mut self, vrf: S) -> Self {
+        self.import_vrf_views.push(vrf.into());
+        self
+    }
+
+    pub fn push_import_vrf_view<S: Into<String>>(&mut self, vrf: S) {
+        self.import_vrf_views.push(vrf.into());
+    }
+
+    #[must_use]
+    pub fn set_import_vrf_views<I, S>(mut self, vrfs: I) -> Self
+    where
+        I: IntoIterator<Item = S>,
+        S: Into<String>,
+    {
+        self.import_vrf_views = vrfs.into_iter().map(Into::into).collect();
+        self
+    }
+}

mgmt/src/tests/mgmt.rs

@@ -367,11 +367,15 @@ pub mod test {
         /* build a gw config from a sample external config */
         let config = GwConfig::new(external);
 
+        let dp_status_r: Arc<RwLock<DataplaneStatus>> =
+            Arc::new(RwLock::new(DataplaneStatus::new()));
+
         /* build router config */
         let router_params = RouterParamsBuilder::default()
             .cpi_sock_path("/tmp/cpi.sock")
             .cli_sock_path("/tmp/cli.sock")
             .frr_agent_path("/tmp/frr-agent.sock")
+            .dp_status(dp_status_r.clone())
             .build()
             .expect("Should succeed due to defaults");
 
@@ -401,9 +405,6 @@ pub mod test {
         /* VPC stats store (Arc) */
         let vpc_stats_store = VpcStatsStore::new();
 
-        let dp_status_r: Arc<RwLock<DataplaneStatus>> =
-            Arc::new(RwLock::new(DataplaneStatus::new()));
-
         /* build configuration of mgmt config processor */
         let processor_config = ConfigProcessorParams {
             router_ctl,

routing/src/frr/renderer/bgp.rs

@@ -12,7 +12,7 @@ use config::internal::routing::bgp::Redistribute;
 use config::internal::routing::bgp::VrfImports;
 use config::internal::routing::bgp::{AfIpv4Ucast, AfIpv6Ucast, AfL2vpnEvpn};
 use config::internal::routing::bgp::{BgpNeighCapabilities, Protocol};
-use config::internal::routing::bgp::{BmpOptions, BmpSource};
+use config::internal::routing::bmp::{BmpOptions, BmpSource};
 
 /* impl Display */
 impl Rendered for BgpNeighType {
@@ -551,6 +551,7 @@ pub mod tests {
         AfL2vpnEvpn, BgpConfig, BgpNeighbor, NeighSendCommunities, Protocol, Redistribute,
         VrfImports,
     };
+    use config::internal::routing::bmp::{BmpOptions, BmpSource};
     use lpm::prefix::Prefix;
     use std::net::{IpAddr, Ipv4Addr};
     use std::str::FromStr;
@@ -573,6 +574,19 @@ pub mod tests {
 
         bgp.set_bgp_options(options);
 
+        let bmp = BmpOptions::new("bmp1", "127.0.0.1", 5000)
+            .set_retry_ms(1_000, 20_000)
+            .set_stats_interval_ms(60_000)
+            .monitor_ipv4(true, true)
+            .monitor_ipv6(false, false);
+        let bmp = BmpOptions {
+            source: Some(BmpSource::Interface("lo".to_string())),
+            ..bmp
+        }
+        .add_import_vrf_view("VPC-2")
+        .add_import_vrf_view("VPC-3");
+        bgp.set_bmp_options(bmp);
+
         let n1 = BgpNeighbor::new_host(IpAddr::from_str("7.0.0.3").expect("Bad address"))
             .set_remote_as(65001)
             .set_description("A neighbor that does not belong to a peer group")

routing/src/frr/test.rs

@@ -124,23 +124,23 @@ pub mod tests {
     use super::fake_frr_agent::*;
     use crate::config::RouterConfig;
     use crate::{Router, RouterParamsBuilder};
-    use std::time::Duration;
-    use tracing_test::traced_test;
-
+    use concurrency::sync::{Arc, RwLock};
     use config::internal::status::DataplaneStatus;
+    use std::time::Duration;
     use tokio::sync::watch;
+    use tracing_test::traced_test;
 
     #[traced_test]
     #[tokio::test]
     async fn test_fake_frr_agent() {
-        let (_dp_status_tx, dp_status_rx) = watch::channel(DataplaneStatus::default());
+        let dp_status: Arc<RwLock<DataplaneStatus>> = Arc::new(RwLock::new(DataplaneStatus::new()));
 
         /* set router params */
         let router_params = RouterParamsBuilder::default()
             .cpi_sock_path("/tmp/cpi.sock")
             .cli_sock_path("/tmp/cli.sock")
             .frr_agent_path("/tmp/frr-agent.sock")
-            .dp_status(dp_status_rx)
+            .dp_status(dp_status)
             .build()
             .expect("Should succeed due to defaults");