[pve-devel] [PATCH proxmox-perl-rs 06/10] pve-rs: fabrics: add function to get status of fabric

[Stefan Hanreich <s.hanreich@proxmox.com>]

From: Gabriel Goller <g.goller@proxmox.com>

Add a function to get the status of a fabric. This is the status which
will then be inserted into the pvestatd daemon and returned through the
resources api. In order the generate the HashMap of statuses for all
fabrics we need to read the fabric config and execute a vtysh (frr)
command to get the routes of the corresponding fabric. If there is at
least one route which is related to the fabric, the fabric is considered
"ok".

Signed-off-by: Gabriel Goller <g.goller@proxmox.com>
Signed-off-by: Stefan Hanreich <s.hanreich@proxmox.com>
---
 pve-rs/src/bindings/sdn/fabrics.rs |  79 +++++++++++++++-
 pve-rs/src/lib.rs                  |   2 +
 pve-rs/src/sdn/mod.rs              |   3 +
 pve-rs/src/sdn/status.rs           | 140 +++++++++++++++++++++++++++++
 4 files changed, 222 insertions(+), 2 deletions(-)
 create mode 100644 pve-rs/src/sdn/mod.rs
 create mode 100644 pve-rs/src/sdn/status.rs

diff --git a/pve-rs/src/bindings/sdn/fabrics.rs b/pve-rs/src/bindings/sdn/fabrics.rs
index c85c411..dcd5bcc 100644
--- a/pve-rs/src/bindings/sdn/fabrics.rs
+++ b/pve-rs/src/bindings/sdn/fabrics.rs
@@ -9,9 +9,10 @@ pub mod pve_rs_sdn_fabrics {
     use std::fmt::Write;
     use std::net::IpAddr;
     use std::ops::Deref;
+    use std::process::Command;
     use std::sync::Mutex;
 
-    use anyhow::Error;
+    use anyhow::{Context, Error};
     use openssl::hash::{MessageDigest, hash};
     use serde::{Deserialize, Serialize};
 
@@ -19,7 +20,7 @@ pub mod pve_rs_sdn_fabrics {
     use proxmox_frr::ser::serializer::to_raw_config;
     use proxmox_network_types::ip_address::{Cidr, Ipv4Cidr, Ipv6Cidr};
     use proxmox_section_config::typed::SectionConfigData;
-    use proxmox_ve_config::common::valid::Validatable;
+    use proxmox_ve_config::common::valid::{Valid, Validatable};
 
     use proxmox_ve_config::sdn::fabric::section_config::Section;
     use proxmox_ve_config::sdn::fabric::section_config::fabric::{
@@ -34,6 +35,8 @@ pub mod pve_rs_sdn_fabrics {
     use proxmox_ve_config::sdn::fabric::{FabricConfig, FabricEntry};
     use proxmox_ve_config::sdn::frr::FrrConfigBuilder;
 
+    use crate::sdn::status::{self, RunningConfig};
+
     /// A SDN Fabric config instance.
     #[derive(Serialize, Deserialize)]
     pub struct PerlFabricConfig {
@@ -587,4 +590,76 @@ pub mod pve_rs_sdn_fabrics {
 
         Ok(interfaces)
     }
+
+    /// Read and parse the running-config and get the fabrics section
+    ///
+    /// This will return a valid FabricConfig. Note that we read the file manually and not through
+    /// the cluster filesystem as with perl, so this will be slower.
+    fn get_fabrics_config() -> Result<Valid<FabricConfig>, anyhow::Error> {
+        let raw_config = std::fs::read_to_string("/etc/pve/sdn/.running-config")?;
+        let running_config: RunningConfig =
+            serde_json::from_str(&raw_config).with_context(|| "error parsing running-config")?;
+        let section_config = SectionConfigData::from_iter(running_config.fabrics.ids);
+        FabricConfig::from_section_config(section_config)
+            .with_context(|| "error converting section config to fabricconfig")
+    }
+
+    /// Return the status of all fabrics on this node.
+    ///
+    /// Go through all fabrics in the config, then filter out the ones that exist on this node.
+    /// Check if there are any routes in the routing table that use the interface specified in the
+    /// config. If there are, show "ok" as status, otherwise "not ok".
+    #[export]
+    fn status() -> Result<HashMap<FabricId, status::Status>, Error> {
+        let openfabric_ipv4_routes_string = String::from_utf8(
+            Command::new("sh")
+                .args(["-c", "vtysh -c 'show ip route openfabric json'"])
+                .output()?
+                .stdout,
+        )?;
+
+        let openfabric_ipv6_routes_string = String::from_utf8(
+            Command::new("sh")
+                .args(["-c", "vtysh -c 'show ipv6 route openfabric json'"])
+                .output()?
+                .stdout,
+        )?;
+
+        let ospf_routes_string = String::from_utf8(
+            Command::new("sh")
+                .args(["-c", "vtysh -c 'show ip route ospf json'"])
+                .output()?
+                .stdout,
+        )?;
+
+        let mut openfabric_routes: proxmox_frr::de::Routes =
+            if openfabric_ipv4_routes_string.is_empty() {
+                proxmox_frr::de::Routes::default()
+            } else {
+                serde_json::from_str(&openfabric_ipv4_routes_string)
+                    .with_context(|| "error parsing openfabric ipv4 routes")?
+            };
+        if !openfabric_ipv6_routes_string.is_empty() {
+            let openfabric_ipv6_routes: proxmox_frr::de::Routes =
+                serde_json::from_str(&openfabric_ipv6_routes_string)
+                    .with_context(|| "error parsing openfabric ipv6 routes")?;
+            openfabric_routes.0.extend(openfabric_ipv6_routes.0);
+        }
+
+        let ospf_routes: proxmox_frr::de::Routes = if ospf_routes_string.is_empty() {
+            proxmox_frr::de::Routes::default()
+        } else {
+            serde_json::from_str(&ospf_routes_string)
+                .with_context(|| "error parsing ospf routes")?
+        };
+
+        let config = get_fabrics_config()?;
+
+        let route_status = status::RoutesParsed {
+            openfabric: openfabric_routes,
+            ospf: ospf_routes,
+        };
+
+        status::get_status(config, route_status)
+    }
 }
diff --git a/pve-rs/src/lib.rs b/pve-rs/src/lib.rs
index b2fcaae..b32b061 100644
--- a/pve-rs/src/lib.rs
+++ b/pve-rs/src/lib.rs
@@ -13,6 +13,8 @@ use proxmox_notify::{Config, Notification, Severity};
 #[path = "../common/src/mod.rs"]
 mod common;
 
+mod sdn;
+
 pub mod bindings;
 
 fn send_notification(notification: &Notification) -> Result<(), Error> {
diff --git a/pve-rs/src/sdn/mod.rs b/pve-rs/src/sdn/mod.rs
new file mode 100644
index 0000000..f4a42fa
--- /dev/null
+++ b/pve-rs/src/sdn/mod.rs
@@ -0,0 +1,3 @@
+/// This module contains status-related structs that represent Routes, Neighbors and general Status
+/// for all Protocols and SDN Objects
+pub mod status;
diff --git a/pve-rs/src/sdn/status.rs b/pve-rs/src/sdn/status.rs
new file mode 100644
index 0000000..c04a0c1
--- /dev/null
+++ b/pve-rs/src/sdn/status.rs
@@ -0,0 +1,140 @@
+use std::collections::{BTreeMap, HashMap, HashSet};
+
+use proxmox_section_config::typed::SectionConfigData;
+use serde::{Deserialize, Serialize};
+
+use proxmox_frr::de::{self};
+use proxmox_ve_config::{
+    common::valid::Valid,
+    sdn::fabric::{
+        FabricConfig,
+        section_config::{Section, fabric::FabricId, node::Node as ConfigNode},
+    },
+};
+
+/// Protocol
+#[derive(Debug, Serialize, Clone, Copy)]
+#[serde(rename_all = "lowercase")]
+pub enum Protocol {
+    /// Openfabric
+    Openfabric,
+    /// OSPF
+    Ospf,
+}
+
+/// The status of a fabric.
+#[derive(Debug, Serialize)]
+pub enum FabricStatus {
+    /// The fabric exists and has a route
+    #[serde(rename = "ok")]
+    Ok,
+    /// The fabric does not exist or doesn't distribute any routes
+    #[serde(rename = "not ok")]
+    NotOk,
+}
+
+/// Status of a fabric.
+///
+/// Models the current state of the fabric, the status is determined by checking if any
+/// routes are propagated. This will be inserted into the PVE resources.
+#[derive(Debug, Serialize)]
+pub struct Status {
+    #[serde(rename = "type")]
+    ty: String,
+    status: FabricStatus,
+    protocol: Protocol,
+    network: FabricId,
+    network_type: String,
+}
+
+/// Parsed routes for all protocols
+///
+/// These are the routes parsed from the json output of:
+/// `vtysh -c 'show ip route <protocol> json'`.
+#[derive(Debug, Serialize)]
+pub struct RoutesParsed {
+    /// All openfabric routes in FRR
+    pub openfabric: de::Routes,
+    /// All ospf routes in FRR
+    pub ospf: de::Routes,
+}
+
+/// Config used to parse the fabric part of the running-config
+#[derive(Deserialize)]
+pub struct RunningConfig {
+    pub fabrics: FabricsRunningConfig,
+}
+
+/// Map of ids for all the fabrics in the running-config
+#[derive(Deserialize)]
+pub struct FabricsRunningConfig {
+    pub ids: BTreeMap<String, Section>,
+}
+
+/// Get the status for each fabric using the parsed routes from frr
+///
+/// Using the parsed routes we get from frr, filter and map them to a HashMap mapping every
+/// fabric to a status struct containing basic info about the fabric and the status (if it
+/// propagates a route).
+pub fn get_status(
+    config: Valid<FabricConfig>,
+    routes: RoutesParsed,
+) -> Result<HashMap<FabricId, Status>, anyhow::Error> {
+    let hostname = proxmox_sys::nodename();
+
+    let mut stats: HashMap<FabricId, Status> = HashMap::new();
+
+    for (nodeid, node) in config.all_nodes() {
+        if nodeid.as_str() != hostname {
+            continue;
+        }
+        let fabric_id = node.id().fabric_id();
+
+        let (current_protocol, all_routes) = match &node {
+            ConfigNode::Openfabric(_) => (Protocol::Openfabric, &routes.openfabric.0),
+            ConfigNode::Ospf(_) => (Protocol::Ospf, &routes.ospf.0),
+        };
+
+        // get interfaces
+        let interface_names: HashSet<&str> = match node {
+            ConfigNode::Openfabric(n) => n
+                .properties()
+                .interfaces()
+                .map(|i| i.name().as_str())
+                .collect(),
+            ConfigNode::Ospf(n) => n
+                .properties()
+                .interfaces()
+                .map(|i| i.name().as_str())
+                .collect(),
+        };
+
+        // determine status by checking if any routes exist for our interfaces
+        let has_routes = all_routes.values().any(|v| {
+            v.iter().any(|route| {
+                route.nexthops.iter().any(|nexthop| {
+                    if let Some(iface_name) = &nexthop.interface_name {
+                        interface_names.contains(iface_name.as_str())
+                    } else {
+                        false
+                    }
+                })
+            })
+        });
+
+        let fabric = Status {
+            ty: "network".to_owned(),
+            status: if has_routes {
+                FabricStatus::Ok
+            } else {
+                FabricStatus::NotOk
+            },
+            protocol: current_protocol,
+            network: fabric_id.clone(),
+            network_type: "fabric".to_string(),
+        };
+        stats.insert(fabric_id.clone(), fabric);
+    }
+
+    Ok(stats)
+}
-- 
2.47.3


_______________________________________________
pve-devel mailing list
pve-devel@lists.proxmox.com
https://lists.proxmox.com/cgi-bin/mailman/listinfo/pve-devel