[pve-devel] [PATCH proxmox-perl-rs 10/10] pve-rs: fabrics: add function to get the neighbors for a fabric

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

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

Add a function that takes a fabricId and returns all routing protocol
neighbors (OpenFabric or OSPF) identified by FRR. For OpenFabric, the
fabric name is used as the area identifier, so we can filter easily. For
OSPF, the fabric configuration is read/parsed to extract interfaces,
which are then matched against the FRR neighbor output. The fabric
configuration is always read first to verify that a fabric exists before
querying FRR, as configuration parsing is (probably) faster than vtysh
execution.

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 |  49 +++++++++++
 pve-rs/src/sdn/status.rs           | 131 +++++++++++++++++++++++++++++
 2 files changed, 180 insertions(+)

diff --git a/pve-rs/src/bindings/sdn/fabrics.rs b/pve-rs/src/bindings/sdn/fabrics.rs
index 150b7fa..5230aa3 100644
--- a/pve-rs/src/bindings/sdn/fabrics.rs
+++ b/pve-rs/src/bindings/sdn/fabrics.rs
@@ -666,6 +666,55 @@ pub mod pve_rs_sdn_fabrics {
         }
     }
 
+    /// Get the neighbors for this specific fabric on this node
+    ///
+    /// Read and parse the fabric config to get the fabric protocol and the interfaces (ospf).
+    /// Parse the frr output of the neighbor commands and return a common format.
+    #[export]
+    fn neighbors(fabric_id: FabricId) -> Result<status::NeighborStatus, Error> {
+        // Read fabric config to get protocol of fabric
+        let config = get_fabrics_config()?;
+
+        let fabric = config.get_fabric(&fabric_id)?;
+
+        match fabric {
+            FabricEntry::Openfabric(_) => {
+                let openfabric_neighbors_string = String::from_utf8(
+                    Command::new("sh")
+                        .args(["-c", "vtysh -c 'show openfabric neighbor detail json'"])
+                        .output()?
+                        .stdout,
+                )?;
+                let openfabric_neighbors: proxmox_frr::de::openfabric::Neighbors =
+                    if openfabric_neighbors_string.is_empty() {
+                        proxmox_frr::de::openfabric::Neighbors::default()
+                    } else {
+                        serde_json::from_str(&openfabric_neighbors_string)
+                            .with_context(|| "error parsing openfabric neighbors")?
+                    };
+
+                status::get_neighbors_openfabric(fabric_id, openfabric_neighbors).map(|v| v.into())
+            }
+            FabricEntry::Ospf(fabric) => {
+                let ospf_neighbors_string = String::from_utf8(
+                    Command::new("sh")
+                        .args(["-c", "vtysh -c 'show ip ospf neighbor json'"])
+                        .output()?
+                        .stdout,
+                )?;
+                let ospf_neighbors: proxmox_frr::de::ospf::Neighbors =
+                    if ospf_neighbors_string.is_empty() {
+                        proxmox_frr::de::ospf::Neighbors::default()
+                    } else {
+                        serde_json::from_str(&ospf_neighbors_string)
+                            .with_context(|| "error parsing ospf neighbors")?
+                    };
+
+                status::get_neighbors_ospf(fabric_id, fabric, ospf_neighbors).map(|v| v.into())
+            }
+        }
+    }
+
     /// Get the interfaces for this specific fabric on this node
     ///
     /// Read and parse the fabric config to get the protocol of the fabric and retrieve the
diff --git a/pve-rs/src/sdn/status.rs b/pve-rs/src/sdn/status.rs
index 450bb6c..881fb2d 100644
--- a/pve-rs/src/sdn/status.rs
+++ b/pve-rs/src/sdn/status.rs
@@ -31,6 +31,16 @@ mod ospf {
     use proxmox_frr::de;
     use serde::Serialize;
 
+    /// The status of a neighbor.
+    ///
+    /// Contains the neighbor name and the neighbor status.
+    #[derive(Debug, Serialize)]
+    pub struct NeighborStatus {
+        pub neighbor: String,
+        pub status: String,
+        pub uptime: String,
+    }
+
     /// The status of a fabric interface
     ///
     /// Contains the interface name, the interface state (so if the interface is up/down) and the type
@@ -47,6 +57,16 @@ mod openfabric {
     use proxmox_frr::de;
     use serde::Serialize;
 
+    /// The status of a neighbor.
+    ///
+    /// Contains the neighbor name and the neighbor status.
+    #[derive(Debug, Serialize)]
+    pub struct NeighborStatus {
+        pub neighbor: String,
+        pub status: de::openfabric::AdjacencyState,
+        pub uptime: String,
+    }
+
     /// The status of a fabric interface
     ///
     /// Contains the interface name, the interface state (so if the interface is up/down) and the type
@@ -60,6 +80,25 @@ mod openfabric {
     }
 }
 
+/// Common NeighborStatus that contains either OSPF or Openfabric neighbors
+#[derive(Debug, Serialize)]
+#[serde(untagged)]
+pub enum NeighborStatus {
+    Openfabric(Vec<openfabric::NeighborStatus>),
+    Ospf(Vec<ospf::NeighborStatus>),
+}
+
+impl From<Vec<openfabric::NeighborStatus>> for NeighborStatus {
+    fn from(value: Vec<openfabric::NeighborStatus>) -> Self {
+        NeighborStatus::Openfabric(value)
+    }
+}
+impl From<Vec<ospf::NeighborStatus>> for NeighborStatus {
+    fn from(value: Vec<ospf::NeighborStatus>) -> Self {
+        NeighborStatus::Ospf(value)
+    }
+}
+
 /// Common InterfaceStatus that contains either OSPF or Openfabric interfaces
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
@@ -230,6 +269,98 @@ pub fn get_routes(
     Ok(stats)
 }
 
+/// Convert the parsed openfabric neighbor neighbor information into a list of
+/// [`openfabric::NeighborStatus`].
+///
+/// OpenFabric uses the name of the fabric as an "area", so simply match that to the fabric_id.
+pub fn get_neighbors_openfabric(
+    fabric_id: FabricId,
+    neighbors: de::openfabric::Neighbors,
+) -> Result<Vec<openfabric::NeighborStatus>, anyhow::Error> {
+    let mut stats: Vec<openfabric::NeighborStatus> = Vec::new();
+
+    for area in &neighbors.areas {
+        if area.area != fabric_id.as_str() {
+            continue;
+        }
+        for circuit in &area.circuits {
+            let (Some(adj), Some(interface)) = (&circuit.adj, &circuit.interface) else {
+                continue;
+            };
+            let Some(state) = interface.state else {
+                continue;
+            };
+            stats.push(openfabric::NeighborStatus {
+                neighbor: adj.clone(),
+                status: state,
+                uptime: interface.last_ago.clone(),
+            });
+        }
+    }
+
+    Ok(stats)
+}
+
+/// Convert the parsed ospf neighbor neighbor information into a list of [`ospf::NeighborStatus`].
+///
+/// Ospf does not use the name of the fabric at all, so we again need to retrieve the interfaces of
+/// the fabric on this specific node and then match the neighbors to the fabric using the
+/// interfaces.
+pub fn get_neighbors_ospf(
+    fabric_id: FabricId,
+    fabric: &Entry<OspfProperties, OspfNodeProperties>,
+    neighbors: de::ospf::Neighbors,
+) -> Result<Vec<ospf::NeighborStatus>, anyhow::Error> {
+    let hostname = proxmox_sys::nodename();
+
+    let mut stats: Vec<ospf::NeighborStatus> = Vec::new();
+
+    if let Ok(node) = fabric.node_section(&NodeId::from_string(hostname.to_string())?) {
+        let mut interface_names: HashSet<&str> = node
+            .properties()
+            .interfaces()
+            .map(|i| i.name().as_str())
+            .collect();
+
+        let dummy_interface = format!("dummy_{}", fabric_id.as_str());
+        interface_names.insert(&dummy_interface);
+
+        for (neighbor_key, neighbor_list) in &neighbors.neighbors {
+            let mut has_matching_neighbor = false;
+            for neighbor in neighbor_list {
+                match neighbor.interface_name.split_once(":") {
+                    Some((interface_name, _)) => {
+                        if interface_names.contains(interface_name) {
+                            has_matching_neighbor = true;
+                            break;
+                        }
+                    }
+                    _ => {
+                        continue;
+                    }
+                }
+            }
+            if has_matching_neighbor {
+                let status = neighbor_list
+                    .first()
+                    .map(|n| n.neighbor_state.clone())
+                    .unwrap_or_default();
+                let uptime = neighbor_list
+                    .first()
+                    .map(|n| n.up_time.clone())
+                    .unwrap_or_default();
+                stats.push(ospf::NeighborStatus {
+                    neighbor: neighbor_key.clone(),
+                    status,
+                    uptime,
+                });
+            }
+        }
+    }
+
+    Ok(stats)
+}
+
 /// Conver the `show openfabric interface` output into a list of [`openfabric::InterfaceStatus`].
 ///
 /// Openfabric uses the name of the fabric as an "area", so simply match that to the fabric_id.
-- 
2.47.3


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