From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from firstgate.proxmox.com (firstgate.proxmox.com [IPv6:2a01:7e0:0:424::9]) by lore.proxmox.com (Postfix) with ESMTPS id E37D61FF17E for ; Thu, 30 Oct 2025 16:49:38 +0100 (CET) Received: from firstgate.proxmox.com (localhost [127.0.0.1]) by firstgate.proxmox.com (Proxmox) with ESMTP id 4061627385; Thu, 30 Oct 2025 16:49:08 +0100 (CET) From: Stefan Hanreich To: pve-devel@lists.proxmox.com Date: Thu, 30 Oct 2025 16:48:21 +0100 Message-ID: <20251030154851.540408-15-s.hanreich@proxmox.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251030154851.540408-1-s.hanreich@proxmox.com> References: <20251030154851.540408-1-s.hanreich@proxmox.com> MIME-Version: 1.0 X-SPAM-LEVEL: Spam detection results: 0 AWL -0.184 Adjusted score from AWL reputation of From: address BAYES_00 -1.9 Bayes spam probability is 0 to 1% DMARC_MISSING 0.1 Missing DMARC policy KAM_DMARC_STATUS 0.01 Test Rule for DKIM or SPF Failure with Strict Alignment KAM_LAZY_DOMAIN_SECURITY 1 Sending domain does not have any anti-forgery methods RDNS_NONE 0.793 Delivered to internal network by a host with no rDNS SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_NONE 0.001 SPF: sender does not publish an SPF Record Subject: [pve-devel] [PATCH proxmox-perl-rs 06/10] pve-rs: fabrics: add function to get status of fabric X-BeenThere: pve-devel@lists.proxmox.com X-Mailman-Version: 2.1.29 Precedence: list List-Id: Proxmox VE development discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Proxmox VE development discussion Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: pve-devel-bounces@lists.proxmox.com Sender: "pve-devel" From: Gabriel Goller 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 Signed-off-by: Stefan Hanreich --- 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, 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, 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 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, +} + +/// 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, + routes: RoutesParsed, +) -> Result, anyhow::Error> { + let hostname = proxmox_sys::nodename(); + + let mut stats: HashMap = 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