[pve-devel] [PATCH proxmox-perl-rs v3 2/4] fabrics: add function to get status of fabric

[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>
---
 pve-rs/src/bindings/sdn/fabrics.rs |  61 +++++++++++++++
 pve-rs/src/lib.rs                  |   2 +
 pve-rs/src/sdn/mod.rs              |   3 +
 pve-rs/src/sdn/status.rs           | 121 +++++++++++++++++++++++++++++
 4 files changed, 187 insertions(+)
 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 1dc8bf4320e6..ef18ee80b0e1 100644
--- a/pve-rs/src/bindings/sdn/fabrics.rs
+++ b/pve-rs/src/bindings/sdn/fabrics.rs
@@ -9,8 +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::Context;
     use anyhow::Error;
     use openssl::hash::{MessageDigest, hash};
     use serde::{Deserialize, Serialize};
@@ -34,6 +36,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;
+
     /// A SDN Fabric config instance.
     #[derive(Serialize, Deserialize)]
     pub struct PerlFabricConfig {
@@ -578,4 +582,61 @@ pub mod pve_rs_sdn_fabrics {
 
         Ok(interfaces)
     }
+
+    /// 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 route_status = status::RoutesParsed {
+            openfabric: openfabric_routes,
+            ospf: ospf_routes,
+        };
+
+        status::get_status(route_status)
+    }
 }
diff --git a/pve-rs/src/lib.rs b/pve-rs/src/lib.rs
index b2fcaae9fe22..b32b061b1d25 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 000000000000..f4a42faa407b
--- /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 000000000000..5502ed3a10f5
--- /dev/null
+++ b/pve-rs/src/sdn/status.rs
@@ -0,0 +1,121 @@
+use std::collections::{HashMap, HashSet};
+
+use serde::Serialize;
+
+use proxmox_frr::de::{self};
+use proxmox_ve_config::sdn::fabric::{
+    FabricConfig,
+    section_config::{fabric::FabricId, node::Node as ConfigNode},
+};
+
+/// Protocol
+#[derive(Debug, Serialize, Clone, Copy)]
+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,
+    sdn: FabricId,
+    sdn_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,
+}
+/// 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(routes: RoutesParsed) -> Result<HashMap<FabricId, Status>, anyhow::Error> {
+    let hostname = proxmox_sys::nodename();
+
+    // to associate a route to a fabric, we get all the interfaces which are associated
+    // with a fabric on this node and compare them with the interfaces on the route.
+    let raw_config = std::fs::read_to_string("/etc/pve/sdn/fabrics.cfg")?;
+    let config = FabricConfig::parse_section_config(&raw_config)?;
+
+    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| interface_names.contains(&nexthop.interface_name.as_str()))
+            })
+        });
+
+        let fabric = Status {
+            ty: "sdn".to_owned(),
+            status: if has_routes {
+                FabricStatus::Ok
+            } else {
+                FabricStatus::NotOk
+            },
+            sdn_type: "fabric".to_string(),
+            protocol: current_protocol,
+            sdn: fabric_id.clone(),
+        };
+        stats.insert(fabric_id.clone(), fabric);
+    }
+
+    Ok(stats)
+}
-- 
2.47.2



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