[pve-devel] [PATCH proxmox-perl-rs 2/2] pve-rs: sdn: add functions to retrieve the Zone/Vnet routes

[Gabriel Goller <g.goller@proxmox.com>]

To show the routes of the Zones (L3VPN) and Vnets (L2VPN) query FRR with
different commands and parse the output. To correctly filter the Vnet
routes by Vnet we also need to read the sdn config to get the VNI. We
can use the VNI to filter the FRR output.

Signed-off-by: Gabriel Goller <g.goller@proxmox.com>
---
 pve-rs/src/bindings/sdn/fabrics.rs | 57 +++++++++++++++++++
 pve-rs/src/sdn/status.rs           | 89 +++++++++++++++++++++++++++++-
 2 files changed, 145 insertions(+), 1 deletion(-)

diff --git a/pve-rs/src/bindings/sdn/fabrics.rs b/pve-rs/src/bindings/sdn/fabrics.rs
index 079a58c27d32..88e25366ee40 100644
--- a/pve-rs/src/bindings/sdn/fabrics.rs
+++ b/pve-rs/src/bindings/sdn/fabrics.rs
@@ -23,6 +23,7 @@ pub mod pve_rs_sdn_fabrics {
     use proxmox_section_config::typed::SectionConfigData;
     use proxmox_ve_config::common::valid::Validatable;
 
+    use proxmox_ve_config::sdn::config::{RunningConfig, SdnConfig};
     use proxmox_ve_config::sdn::fabric::section_config::Section;
     use proxmox_ve_config::sdn::fabric::section_config::fabric::{
         Fabric as ConfigFabric, FabricId,
@@ -739,4 +740,60 @@ pub mod pve_rs_sdn_fabrics {
 
         status::get_status(route_status)
     }
+
+    /// Get all the L3 routes for the passed zone.
+    ///
+    /// Every zone has a vrf named `vrf_{zone}`. Show all the L3 (IP) routes on the VRF of the
+    /// zone.
+    #[export]
+    fn l3vpn_routes(zone: String) -> Result<status::L3VPNRoutes, Error> {
+        let command = format!("vtysh -c 'show ip route vrf vrf_{zone} json'");
+        let l3vpn_routes_string =
+            String::from_utf8(Command::new("sh").args(["-c", &command]).output()?.stdout)?;
+        let l3vpn_routes: proxmox_frr::de::Routes = if l3vpn_routes_string.is_empty() {
+            proxmox_frr::de::Routes::default()
+        } else {
+            serde_json::from_str(&l3vpn_routes_string)
+                .with_context(|| "error parsing l3vpn routes")?
+        };
+
+        status::get_l3vpn_routes(&format!("vrf_{zone}"), l3vpn_routes)
+    }
+
+    /// Get all the L2 routes for the passed vnet.
+    ///
+    /// When using VXLAN the vnet "stores" the L2 routes in it's FDB. The best way to retrieve them
+    /// with additional metadata is to query FRR. Use the `show bgp l2vpn evpn route` command.
+    /// To filter by vnet, get the VNI of the vnet from the config and use it in the command.
+    #[export]
+    fn l2vpn_routes(vnet: String) -> Result<status::L2VPNRoutes, Error> {
+        // read config to get the vni of the vnet
+        let raw_config = std::fs::read_to_string("/etc/pve/sdn/.running-config")?;
+        let running_config: RunningConfig = serde_json::from_str(&raw_config)?;
+        let parsed_config = SdnConfig::try_from(running_config)?;
+
+        let Some(vni) = parsed_config.zones().find_map(|zone| {
+            zone.vnets().find_map(|vnet_config| {
+                if vnet_config.name().as_ref() == vnet {
+                    *vnet_config.tag()
+                } else {
+                    None
+                }
+            })
+        }) else {
+            anyhow::bail!("vnet does not have a vni");
+        };
+
+        let command = format!("vtysh -c 'show bgp l2vpn evpn route vni {vni} json'");
+        let l2vpn_routes_string =
+            String::from_utf8(Command::new("sh").args(["-c", &command]).output()?.stdout)?;
+        let l2vpn_routes: proxmox_frr::de::evpn::Routes = if l2vpn_routes_string.is_empty() {
+            proxmox_frr::de::evpn::Routes::default()
+        } else {
+            serde_json::from_str(&l2vpn_routes_string)
+                .with_context(|| "error parsing l2vpn routes")?
+        };
+
+        status::get_l2vpn_routes(l2vpn_routes)
+    }
 }
diff --git a/pve-rs/src/sdn/status.rs b/pve-rs/src/sdn/status.rs
index 81253732472e..198ef7037683 100644
--- a/pve-rs/src/sdn/status.rs
+++ b/pve-rs/src/sdn/status.rs
@@ -1,6 +1,10 @@
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::{
+    collections::{BTreeMap, HashMap, HashSet},
+    net::IpAddr,
+};
 
 use anyhow::Context;
+use proxmox_network_types::{ip_address::Cidr, mac_address::MacAddress};
 use proxmox_section_config::typed::SectionConfigData;
 use serde::{Deserialize, Serialize};
 
@@ -346,3 +350,86 @@ pub fn get_status(routes: RoutesParsed) -> Result<HashMap<FabricId, Status>, any
 
     Ok(stats)
 }
+/// Common for nexthops, they can be either a interface name or a ip addr
+#[derive(Debug, Serialize)]
+#[serde(untagged)]
+pub enum IpAddrOrInterfaceName {
+    /// IpAddr
+    IpAddr(IpAddr),
+    /// Interface Name
+    InterfaceName(String),
+}
+
+/// One L3VPN route
+#[derive(Debug, Serialize)]
+pub struct L3VPNRoute {
+    ip: Cidr,
+    next_hop: Vec<IpAddrOrInterfaceName>,
+}
+
+/// All L3VPN routes of a zone
+#[derive(Debug, Serialize)]
+pub struct L3VPNRoutes(Vec<L3VPNRoute>);
+
+/// Convert parsed routes from frr into l3vpn routes, this means we need to match against the vrf
+/// name of the zone.
+pub fn get_l3vpn_routes(vrf: &str, routes: de::Routes) -> Result<L3VPNRoutes, anyhow::Error> {
+    let mut result = Vec::new();
+    for (prefix, routes) in routes.0 {
+        for route in routes {
+            if route.vrf_name == vrf {
+                result.push(L3VPNRoute {
+                    ip: prefix,
+                    next_hop: route
+                        .nexthops
+                        .into_iter()
+                        .filter_map(|nh| {
+                            if let Some(ip) = nh.ip {
+                                Some(IpAddrOrInterfaceName::IpAddr(ip))
+                            } else {
+                                nh.interface_name.map(IpAddrOrInterfaceName::InterfaceName)
+                            }
+                        })
+                        .collect(),
+                });
+            }
+        }
+    }
+    Ok(L3VPNRoutes(result))
+}
+
+/// One L2VPN route
+#[derive(Debug, Serialize)]
+pub struct L2VPNRoute {
+    mac: MacAddress,
+    ip: IpAddr,
+    ip_nexthop: IpAddr,
+}
+
+/// All L2VPN routes of a specific vnet
+#[derive(Debug, Serialize)]
+pub struct L2VPNRoutes(Vec<L2VPNRoute>);
+
+/// Convert the parsed frr evpn struct into an array of structured L2VPN routes
+pub fn get_l2vpn_routes(routes: de::evpn::Routes) -> Result<L2VPNRoutes, anyhow::Error> {
+    let mut result = Vec::new();
+    for route in routes.0.values().filter_map(|entry| match entry {
+        de::evpn::Entry::Route(r) => Some(r),
+        de::evpn::Entry::Metadata(_) => None,
+    }) {
+        route.paths.iter().flatten().for_each(|path| {
+            if path.bestpath {
+                if let (Some(mac), Some(ip), Some(nh)) = (path.mac, path.ip, path.nexthops.first())
+                {
+                    result.push(L2VPNRoute {
+                        mac,
+                        ip,
+                        ip_nexthop: nh.ip,
+                    });
+                }
+            }
+        });
+    }
+
+    Ok(L2VPNRoutes(result))
+}
-- 
2.47.2



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