all lists on lists.proxmox.com
 help / color / mirror / Atom feed
From: Gabriel Goller <g.goller@proxmox.com>
To: pve-devel@lists.proxmox.com
Subject: [PATCH proxmox-perl-rs v3 11/32] pve-rs: fabrics: include VRF routes in aggregate status
Date: Mon, 16 Nov 2026 17:11:31 +0100	[thread overview]
Message-ID: <20261116161154.343743-12-g.goller@proxmox.com> (raw)
In-Reply-To: <20261116161154.343743-1-g.goller@proxmox.com>

Collect OSPF and BGP routes from every VRF used by a fabric on the
local node, in addition to routes from the default routing table. Run
the related commands in one vtysh process and merge their JSON output,
including entries which share the same prefix.

Match routes by VRF when deciding whether a fabric has active routes.
This prevents routes from another routing table from affecting its
status. Add a parser test for duplicate prefixes across VRFs.

Signed-off-by: Gabriel Goller <g.goller@proxmox.com>
---
 pve-rs/src/bindings/sdn/fabrics.rs | 211 ++++++++++++++++++-----------
 pve-rs/src/sdn/status.rs           | 149 ++++++++++++++++----
 2 files changed, 251 insertions(+), 109 deletions(-)

diff --git a/pve-rs/src/bindings/sdn/fabrics.rs b/pve-rs/src/bindings/sdn/fabrics.rs
index 381de692acfc..669bca6d2492 100644
--- a/pve-rs/src/bindings/sdn/fabrics.rs
+++ b/pve-rs/src/bindings/sdn/fabrics.rs
@@ -5,7 +5,7 @@ pub mod pve_rs_sdn_fabrics {
     //! This provides the configuration for the SDN fabrics, as well as helper methods for reading
     //! / writing the configuration, as well as for generating ifupdown2 and FRR configuration.
 
-    use std::collections::{BTreeMap, HashMap, HashSet};
+    use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
     use std::fmt::Write;
     use std::net::IpAddr;
     use std::ops::Deref;
@@ -977,13 +977,15 @@ pub mod pve_rs_sdn_fabrics {
                 };
                 let ospf_neighbors_string =
                     String::from_utf8(Command::new("sh").args(["-c", &command]).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")?
-                    };
+                let ospf_neighbors = if ospf_neighbors_string.is_empty() {
+                    proxmox_frr::de::ospf::Neighbors::default()
+                } else {
+                    let output = serde_json::from_str(&ospf_neighbors_string)
+                        .with_context(|| "error parsing ospf neighbors")?;
+                    let output = status::extract_vrf_status(output, vrf.as_deref())?;
+                    serde_json::from_value(output)
+                        .with_context(|| "error parsing ospf neighbors")?
+                };
 
                 status::get_neighbors_ospf(
                     fabric_id,
@@ -1060,13 +1062,15 @@ pub mod pve_rs_sdn_fabrics {
                 };
                 let ospf_interfaces_string =
                     String::from_utf8(Command::new("sh").args(["-c", &command]).output()?.stdout)?;
-                let ospf_interfaces: proxmox_frr::de::ospf::Interfaces =
-                    if ospf_interfaces_string.is_empty() {
-                        proxmox_frr::de::ospf::Interfaces::default()
-                    } else {
-                        serde_json::from_str(&ospf_interfaces_string)
-                            .with_context(|| "error parsing ospf interfaces")?
-                    };
+                let ospf_interfaces = if ospf_interfaces_string.is_empty() {
+                    proxmox_frr::de::ospf::Interfaces::default()
+                } else {
+                    let output = serde_json::from_str(&ospf_interfaces_string)
+                        .with_context(|| "error parsing ospf interfaces")?;
+                    let output = status::extract_vrf_status(output, vrf.as_deref())?;
+                    serde_json::from_value(output)
+                        .with_context(|| "error parsing ospf interfaces")?
+                };
 
                 status::get_interfaces_ospf(
                     fabric_id,
@@ -1102,6 +1106,78 @@ pub mod pve_rs_sdn_fabrics {
         }
     }
 
+    fn extend_routes(destination: &mut proxmox_frr::de::Routes, source: proxmox_frr::de::Routes) {
+        for (prefix, routes) in source.0 {
+            destination.0.entry(prefix).or_default().extend(routes);
+        }
+    }
+
+    /// Query and merge routes from multiple FRR commands in a single `vtysh` process.
+    ///
+    /// The exit status is ignored, like in the single-command queries: if FRR is not running,
+    /// `vtysh` fails without printing anything to stdout, which yields no routes. This is polled
+    /// by pvestatd, so an error here would be logged on every cycle.
+    fn query_routes(
+        commands: impl IntoIterator<Item = String>,
+        protocol: &str,
+    ) -> Result<proxmox_frr::de::Routes, Error> {
+        let mut command = Command::new("vtysh");
+        command.env("VTYSH_HISTFILE", "/dev/null");
+        for query in commands {
+            command.args(["-c", &query]);
+        }
+
+        let output = match command.output() {
+            Ok(output) => output,
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                return Ok(proxmox_frr::de::Routes::default());
+            }
+            Err(err) => return Err(err.into()),
+        };
+
+        parse_routes(&output.stdout, protocol)
+    }
+
+    fn parse_routes(raw: &[u8], protocol: &str) -> Result<proxmox_frr::de::Routes, Error> {
+        let mut routes = proxmox_frr::de::Routes::default();
+        let route_stream =
+            serde_json::Deserializer::from_slice(raw).into_iter::<proxmox_frr::de::Routes>();
+        for queried_routes in route_stream {
+            extend_routes(
+                &mut routes,
+                queried_routes.with_context(|| format!("error parsing {protocol} routes"))?,
+            );
+        }
+
+        Ok(routes)
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::parse_routes;
+
+        #[test]
+        fn parses_batched_routes_with_duplicate_prefixes() {
+            let raw = br#"
+                {"10.0.0.0/24":[{"nexthops":[],"metric":10,"protocol":"bgp","vrfName":"vrf_a"}]}
+                {"10.0.0.0/24":[{"nexthops":[],"metric":10,"protocol":"bgp","vrfName":"vrf_b"}]}
+            "#;
+
+            let routes = parse_routes(raw, "BGP").expect("batched routes should parse");
+            let routes = routes.0.values().next().expect("route should exist");
+
+            assert_eq!(routes.len(), 2);
+            assert_eq!(routes[0].vrf_name, "vrf_a");
+            assert_eq!(routes[1].vrf_name, "vrf_b");
+        }
+
+        #[test]
+        fn parses_empty_output() {
+            let routes = parse_routes(b"", "BGP").expect("empty output should parse");
+            assert!(routes.0.is_empty());
+        }
+    }
+
     /// 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.
@@ -1117,76 +1193,47 @@ pub mod pve_rs_sdn_fabrics {
             return Ok(HashMap::new());
         };
 
-        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 openfabric_routes = query_routes(
+            [
+                "show ip route openfabric json".to_string(),
+                "show ipv6 route openfabric json".to_string(),
+            ],
+            "OpenFabric",
         )?;
 
-        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 bgp_ipv4_routes_string = String::from_utf8(
-            Command::new("sh")
-                .env("VTYSH_HISTFILE", "/dev/null")
-                .args(["-c", "vtysh -c 'show ip route bgp json'"])
-                .output()?
-                .stdout,
-        )?;
-
-        let bgp_ipv6_routes_string = String::from_utf8(
-            Command::new("sh")
-                .env("VTYSH_HISTFILE", "/dev/null")
-                .args(["-c", "vtysh -c 'show ipv6 route bgp json'"])
-                .output()?
-                .stdout,
-        )?;
-
-        let mut bgp_routes: proxmox_frr::de::Routes = if bgp_ipv4_routes_string.is_empty() {
-            proxmox_frr::de::Routes::default()
-        } else {
-            serde_json::from_str(&bgp_ipv4_routes_string)
-                .with_context(|| "error parsing bgp ipv4 routes")?
-        };
-        if !bgp_ipv6_routes_string.is_empty() {
-            let bgp_ipv6_routes: proxmox_frr::de::Routes =
-                serde_json::from_str(&bgp_ipv6_routes_string)
-                    .with_context(|| "error parsing bgp ipv6 routes")?;
-            bgp_routes.0.extend(bgp_ipv6_routes.0);
+        let node_id = NodeId::from_string(proxmox_sys::nodename().to_string())?;
+        let ospf_vrfs: BTreeSet<_> = config
+            .values()
+            .filter(|entry| {
+                matches!(entry, FabricEntry::Ospf(_)) && entry.get_node(&node_id).is_ok()
+            })
+            .filter_map(FabricEntry::fabric_vrf_name)
+            .collect();
+        let mut ospf_commands = vec!["show ip route ospf json".to_string()];
+        ospf_commands.extend(
+            ospf_vrfs
+                .iter()
+                .map(|vrf| format!("show ip route vrf {vrf} ospf json")),
+        );
+        let ospf_routes = query_routes(ospf_commands, "OSPF")?;
+
+        let bgp_vrfs: BTreeSet<_> = config
+            .values()
+            .filter(|entry| {
+                matches!(entry, FabricEntry::Bgp(_)) && entry.get_node(&node_id).is_ok()
+            })
+            .filter_map(FabricEntry::fabric_vrf_name)
+            .collect();
+        let mut bgp_commands = vec![
+            "show ip route bgp json".to_string(),
+            "show ipv6 route bgp json".to_string(),
+        ];
+        for vrf in bgp_vrfs {
+            bgp_commands.extend(
+                ["ip", "ipv6"].map(|family| format!("show {family} route vrf {vrf} bgp json")),
+            );
         }
+        let bgp_routes = query_routes(bgp_commands, "BGP")?;
 
         let route_status = status::RoutesParsed {
             openfabric: openfabric_routes,
diff --git a/pve-rs/src/sdn/status.rs b/pve-rs/src/sdn/status.rs
index 7a1334d20804..369fe3a982b2 100644
--- a/pve-rs/src/sdn/status.rs
+++ b/pve-rs/src/sdn/status.rs
@@ -355,6 +355,20 @@ pub fn get_neighbors_openfabric(
     Ok(stats)
 }
 
+/// Extract status output nested under a VRF name, or return non-VRF output unchanged.
+pub fn extract_vrf_status(
+    mut output: serde_json::Value,
+    vrf: Option<&str>,
+) -> Result<serde_json::Value, anyhow::Error> {
+    match vrf {
+        Some(vrf) => output
+            .get_mut(vrf)
+            .map(serde_json::Value::take)
+            .ok_or_else(|| anyhow::anyhow!("missing status for VRF '{vrf}'")),
+        None => Ok(output),
+    }
+}
+
 /// 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
@@ -535,6 +549,10 @@ pub fn get_status(
             continue;
         }
         let fabric_id = node.id().fabric_id();
+        let vrf_name = config
+            .get_fabric(fabric_id)?
+            .fabric_vrf_name()
+            .unwrap_or_else(|| "default".to_string());
 
         let (current_protocol, all_routes) = match &node {
             ConfigNode::Openfabric(_) => (Protocol::Openfabric, &routes.openfabric.0),
@@ -565,13 +583,14 @@ pub fn get_status(
         // 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
-                    }
-                })
+                route.vrf_name == vrf_name
+                    && route.nexthops.iter().any(|nexthop| {
+                        if let Some(iface_name) = &nexthop.interface_name {
+                            interface_names.contains(iface_name.as_str())
+                        } else {
+                            false
+                        }
+                    })
             })
         });
 
@@ -1400,11 +1419,8 @@ mod tests {
             }
             "#;
 
-            let neighbors: de::ospf::Neighbors = if json_output.is_empty() {
-                de::ospf::Neighbors::default()
-            } else {
-                serde_json::from_str(json_output).expect("error parsing json output")
-            };
+            let neighbors: de::ospf::Neighbors =
+                serde_json::from_str(json_output).expect("error parsing json output");
 
             let fabric_config = sample_one_fabric_config();
 
@@ -1436,6 +1452,94 @@ mod tests {
             assert_eq!(reference, output);
         }
 
+        #[test]
+        fn neighbors_vrf() {
+            let json_output = r#"
+            {
+              "vrf_vrf": {
+                "vrfName": "vrf_vrf",
+                "vrfId": 6,
+                "neighbors": {
+                  "4.4.4.3": [{
+                    "nbrState": "Full\/-",
+                    "upTime": "13m35s",
+                    "ifaceAddress": "4.4.4.3",
+                    "ifaceName": "nic1:4.4.4.1"
+                  }],
+                  "4.4.4.2": [{
+                    "nbrState": "Full\/-",
+                    "upTime": "13m35s",
+                    "ifaceAddress": "4.4.4.2",
+                    "ifaceName": "nic2:4.4.4.1"
+                  }]
+                }
+              },
+              "other_vrf": { "neighbors": {} }
+            }
+            "#;
+
+            let output = serde_json::from_str(json_output).unwrap();
+            let output = extract_vrf_status(output, Some("vrf_vrf")).unwrap();
+            let neighbors: de::ospf::Neighbors = serde_json::from_value(output).unwrap();
+            assert_eq!(neighbors.neighbors.len(), 2);
+            for (address, interface) in [("4.4.4.3", "nic1"), ("4.4.4.2", "nic2")] {
+                let neighbor = &neighbors.neighbors[address];
+                assert_eq!(neighbor.len(), 1);
+                assert_eq!(neighbor[0].interface_address, address);
+                assert_eq!(neighbor[0].interface_name, format!("{interface}:4.4.4.1"));
+                assert_eq!(neighbor[0].neighbor_state, "Full/-");
+                assert_eq!(neighbor[0].up_time, "13m35s");
+            }
+        }
+
+        #[test]
+        fn interfaces_vrf() {
+            let json_output = r#"
+            {
+              "vrf_vrf": {
+                "vrfName": "vrf_vrf",
+                "vrfId": 6,
+                "interfaces": {
+                  "dummy_fabric": { "ifUp": true, "networkType": "BROADCAST" },
+                  "nic1": { "ifUp": true, "networkType": "POINTOPOINT" },
+                  "nic2": { "ifUp": true, "networkType": "POINTOPOINT" }
+                }
+              },
+              "other_vrf": { "interfaces": {} }
+            }
+            "#;
+
+            let output = serde_json::from_str(json_output).unwrap();
+            let output = extract_vrf_status(output, Some("vrf_vrf")).unwrap();
+            let interfaces: de::ospf::Interfaces = serde_json::from_value(output).unwrap();
+            assert_eq!(interfaces.interfaces.len(), 3);
+            for (name, ty) in [
+                ("dummy_fabric", de::ospf::NetworkType::Broadcast),
+                ("nic1", de::ospf::NetworkType::PointToPoint),
+                ("nic2", de::ospf::NetworkType::PointToPoint),
+            ] {
+                let interface = &interfaces.interfaces[name];
+                assert!(interface.if_up);
+                assert_eq!(interface.network_type, ty);
+            }
+        }
+
+        #[test]
+        fn extract_non_vrf_status() {
+            for output in [
+                serde_json::json!({ "neighbors": {} }),
+                serde_json::json!({ "interfaces": {} }),
+            ] {
+                assert_eq!(extract_vrf_status(output.clone(), None).unwrap(), output);
+            }
+        }
+
+        #[test]
+        fn extract_missing_vrf_status() {
+            let output = serde_json::json!({ "other_vrf": { "neighbors": {} } });
+            assert!(extract_vrf_status(output, Some("vrf_vrf")).is_err());
+        }
+
         #[test]
         fn neighbors_multiple_areas() {
             let json_output = r#"
@@ -1509,11 +1613,8 @@ mod tests {
             }
             "#;
 
-            let neighbors: de::ospf::Neighbors = if json_output.is_empty() {
-                de::ospf::Neighbors::default()
-            } else {
-                serde_json::from_str(json_output).expect("error parsing json output")
-            };
+            let neighbors: de::ospf::Neighbors =
+                serde_json::from_str(json_output).expect("error parsing json output");
 
             let fabric_config = sample_two_fabric_config();
 
@@ -1672,11 +1773,8 @@ mod tests {
             }
             "#;
 
-            let interfaces: de::ospf::Interfaces = if json_output.is_empty() {
-                de::ospf::Interfaces::default()
-            } else {
-                serde_json::from_str(json_output).expect("error parsing json output")
-            };
+            let interfaces: de::ospf::Interfaces =
+                serde_json::from_str(json_output).expect("error parsing json output");
 
             let fabric_config = sample_one_fabric_config();
 
@@ -1904,11 +2002,8 @@ mod tests {
             }
             "#;
 
-            let interfaces: de::ospf::Interfaces = if json_output.is_empty() {
-                de::ospf::Interfaces::default()
-            } else {
-                serde_json::from_str(json_output).expect("error parsing json output")
-            };
+            let interfaces: de::ospf::Interfaces =
+                serde_json::from_str(json_output).expect("error parsing json output");
 
             let fabric_config = sample_two_fabric_config();
 
-- 
2.47.3





  parent reply	other threads:[~2026-11-16 16:16 UTC|newest]

Thread overview: 65+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-16 16:11 [PATCH common/manager/network/proxmox{-ve-rs,-perl-rs,-widget-toolkit} v3 00/32] SDN VRF support Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-common v3 01/32] interfaces: preserve VRF membership across address family changes Gabriel Goller
2026-11-18 14:13   ` Stefan Hanreich
2026-11-18 15:41     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-ve-rs v3 02/32] frr: add VRF-aware OSPF rendering Gabriel Goller
2026-11-18 14:41   ` Stefan Hanreich
2026-11-18 16:21     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-ve-rs v3 03/32] sdn: add zone references to OSPF and BGP fabrics Gabriel Goller
2026-11-18 14:10   ` Stefan Hanreich
2026-11-18 16:55     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-ve-rs v3 04/32] sdn: generate fabric routing configuration in zone VRFs Gabriel Goller
2026-11-18 14:53   ` Stefan Hanreich
2026-11-18 17:26     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-ve-rs v3 05/32] sdn: fix VRF route-map scoping and zone ID validation Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-ve-rs v3 06/32] tests: fabrics: add test for fabrics in VRFs Gabriel Goller
2026-11-18 15:01   ` Stefan Hanreich
2026-11-18 17:33     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-ve-rs v3 07/32] sdn: allow static routes in simple zone VRFs Gabriel Goller
2026-11-18 15:29   ` Stefan Hanreich
2026-11-18 18:10     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-ve-rs v3 08/32] sdn: support static routes in EVPN " Gabriel Goller
2026-11-18 15:32   ` Stefan Hanreich
2026-11-19 13:12     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-perl-rs v3 09/32] pve-rs: fabrics: assign network interfaces to configured VRFs Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-perl-rs v3 10/32] pve-rs: fabrics: make per-fabric status queries VRF-aware Gabriel Goller
2026-11-18 15:42   ` Stefan Hanreich
2026-11-19 13:30     ` Gabriel Goller
2026-11-16 16:11 ` Gabriel Goller [this message]
2026-11-16 16:11 ` [PATCH proxmox-perl-rs v3 12/32] pve-rs: fabrics: expose host interface membership Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-perl-rs v3 13/32] sdn: expose static routes for simple zone uplinks Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 14/32] sdn: evpn: add unreachable IPv6 default route to zone VRFs Gabriel Goller
2026-11-18 16:08   ` Stefan Hanreich
2026-11-18 16:39     ` Stefan Hanreich
2026-11-19 13:38       ` Gabriel Goller
2026-11-19 15:51         ` Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 15/32] sdn: add optional VRFs for simple zones Gabriel Goller
2026-11-18 16:18   ` Stefan Hanreich
2026-11-19 13:44     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 16/32] sdn: allow fabrics to use simple zone VRFs Gabriel Goller
2026-11-18 16:27   ` Stefan Hanreich
2026-11-19 14:14     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 17/32] sdn: require underlay fabrics to use the default VRF Gabriel Goller
2026-11-18 16:30   ` Stefan Hanreich
2026-11-19 14:33     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 18/32] sdn: always generate EVPN zone VRFs Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 19/32] api: sdn: allow EVPN zones as fabric VRFs Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 20/32] api: sdn: disallow BGP fabrics in EVPN zone VRFs Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 21/32] sdn: simple: support static routes in zone routing tables Gabriel Goller
2026-11-18 16:49   ` Stefan Hanreich
2026-11-19 14:53     ` Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 22/32] sdn: evpn: allow static routes Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 23/32] sdn: zones: SNAT via dedicated uplinks in zone VRFs Gabriel Goller
2026-11-18 18:07   ` Stefan Hanreich
2026-11-16 16:11 ` [PATCH pve-network v3 24/32] sdn: dhcp: only configure DHCP for zones on the local node Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-network v3 25/32] sdn: dhcp: run dnsmasq in the zone VRF Gabriel Goller
2026-11-16 16:11 ` [PATCH proxmox-widget-toolkit v3 26/32] ui: network: allow selecting a VRF for host interfaces Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-manager v3 27/32] ui: sdn: add VRF zone selection for fabrics Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-manager v3 28/32] ui: sdn: expose EVPN zones as fabric VRFs Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-manager v3 29/32] network: allow setting the VRF of host interfaces Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-manager v3 30/32] ui: sdn: allow static routes for Simple zone VRFs Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-manager v3 31/32] ui: sdn: allow static routes in EVPN zones Gabriel Goller
2026-11-16 16:11 ` [PATCH pve-manager v3 32/32] network: generate SDN DHCP config after ifreload Gabriel Goller
2026-11-18 18:27 ` [PATCH common/manager/network/proxmox{-ve-rs,-perl-rs,-widget-toolkit} v3 00/32] SDN VRF support Stefan Hanreich
2026-11-19 15:33   ` Gabriel Goller
2026-11-19 20:10 ` Gabriel Goller

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261116161154.343743-12-g.goller@proxmox.com \
    --to=g.goller@proxmox.com \
    --cc=pve-devel@lists.proxmox.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.
Service provided by Proxmox Server Solutions GmbH | Privacy | Legal