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 937B81FF13A for ; Wed, 01 Apr 2026 16:42:08 +0200 (CEST) Received: from firstgate.proxmox.com (localhost [127.0.0.1]) by firstgate.proxmox.com (Proxmox) with ESMTP id 1A31131E3F; Wed, 1 Apr 2026 16:40:56 +0200 (CEST) From: Stefan Hanreich To: pve-devel@lists.proxmox.com Subject: [PATCH proxmox-ve-rs v2 14/34] ve-config: frr: implement frr config generation for route maps Date: Wed, 1 Apr 2026 16:39:23 +0200 Message-ID: <20260401143957.386809-15-s.hanreich@proxmox.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260401143957.386809-1-s.hanreich@proxmox.com> References: <20260401143957.386809-1-s.hanreich@proxmox.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Bm-Milter-Handled: 55990f41-d878-4baa-be0a-ee34c49e34d2 X-Bm-Transport-Timestamp: 1775054348812 X-SPAM-LEVEL: Spam detection results: 0 AWL 0.707 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 SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_PASS -0.001 SPF: sender matches SPF record Message-ID-Hash: 7GX73OWIJK5WNGWHCXD4C3YHI6SPQ6R2 X-Message-ID-Hash: 7GX73OWIJK5WNGWHCXD4C3YHI6SPQ6R2 X-MailFrom: s.hanreich@proxmox.com X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; loop; banned-address; emergency; member-moderation; nonmember-moderation; administrivia; implicit-dest; max-recipients; max-size; news-moderation; no-subject; digests; suspicious-header X-Mailman-Version: 3.3.10 Precedence: list List-Id: Proxmox VE development discussion List-Help: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: Implements conversion traits for all the section config types, so they can be converted into their respective FRR template counterpart. This module contains a helper for adding all route map entries to an existing FRR configuration. If the pre-existing FRR configuration contains a route map that has the same name as at least one entry in the configuration, then the *whole* route map will get overwritten by the route map defined in the section config. The helper also automatically re-orders route map entries according to their ordering number. This allows for deterministic FRR configuration output, which is required for stable tests and convenient for human readability. Signed-off-by: Stefan Hanreich --- proxmox-ve-config/src/sdn/route_map.rs | 147 +++++++++++++++++++++++++ 1 file changed, 147 insertions(+) diff --git a/proxmox-ve-config/src/sdn/route_map.rs b/proxmox-ve-config/src/sdn/route_map.rs index 61607d7..8f9c17c 100644 --- a/proxmox-ve-config/src/sdn/route_map.rs +++ b/proxmox-ve-config/src/sdn/route_map.rs @@ -441,6 +441,153 @@ impl ApiType for MatchAction { .schema(); } +#[cfg(feature = "frr")] +pub mod frr { + //! Route Map Entry FRR types + //! + //! This module contains implementations of conversion traits for the section config types, so + //! they can be converted to the respective proxmox-frr types. This enables easy conversion to + //! the proxmox-frr types and makes it possible to generate the FRR configuration for the Route + //! Map entries. + + use super::*; + + use std::collections::HashMap; + + use proxmox_frr::ser::{ + route_map::{ + RouteMapEntry as FrrRouteMapEntry, RouteMapExitAction as FrrRouteMapExitAction, + RouteMapMatch as FrrRouteMapMatch, RouteMapName as FrrRouteMapName, + RouteMapSet as FrrRouteMapSet, + }, + FrrConfig, + }; + + use crate::sdn::route_map::RouteMapAction; + + impl From for FrrRouteMapMatch { + fn from(value: MatchAction) -> Self { + match value { + MatchAction::RouteType(evpn_route_type) => Self::RouteType(evpn_route_type), + MatchAction::Vni(vni) => Self::Vni(vni), + MatchAction::IpAddressPrefixList(prefix_list_name) => { + Self::IpAddressPrefixList(prefix_list_name.into()) + } + MatchAction::Ip6AddressPrefixList(prefix_list_name) => { + Self::Ip6AddressPrefixList(prefix_list_name.into()) + } + MatchAction::IpNextHopPrefixList(prefix_list_name) => { + Self::IpNextHopPrefixList(prefix_list_name.into()) + } + MatchAction::Ip6NextHopPrefixList(prefix_list_name) => { + Self::Ip6NextHopPrefixList(prefix_list_name.into()) + } + MatchAction::IpNextHopAddress(ipv4_addr) => Self::IpNextHopAddress(*ipv4_addr), + MatchAction::Ip6NextHopAddress(ipv6_addr) => Self::Ip6NextHopAddress(*ipv6_addr), + MatchAction::Metric(metric) => Self::Metric(metric), + MatchAction::LocalPreference(local_preference) => { + Self::LocalPreference(local_preference) + } + MatchAction::Peer(ip_addr) => Self::Peer(ip_addr), + MatchAction::Tag(tag) => Self::Tag(tag), + } + } + } + + impl From for FrrRouteMapSet { + fn from(value: SetAction) -> Self { + match value { + SetAction::IpNextHopPeerAddress => Self::IpNextHopPeerAddress, + SetAction::IpNextHopUnchanged => Self::IpNextHopUnchanged, + SetAction::IpNextHop(ipv4_addr) => Self::IpNextHop(*ipv4_addr), + SetAction::Ip6NextHopPeerAddress => Self::Ip6NextHopPeerAddress, + SetAction::Ip6NextHopPreferGlobal => Self::Ip6NextHopPreferGlobal, + SetAction::Ip6NextHop(ipv6_addr) => Self::Ip6NextHop(*ipv6_addr), + SetAction::LocalPreference(local_preference) => { + Self::LocalPreference(local_preference) + } + SetAction::Tag(tag) => Self::Tag(tag), + SetAction::Weight(weight) => Self::Weight(weight), + SetAction::Metric(metric) => Self::Metric(metric), + SetAction::Src(src) => Self::Src(src), + } + } + } + + impl From for FrrRouteMapExitAction { + fn from(value: ExitAction) -> Self { + match value { + ExitAction::OnMatchNext => FrrRouteMapExitAction::OnMatchNext, + ExitAction::OnMatchGoto(n) => FrrRouteMapExitAction::OnMatchGoto(n), + ExitAction::Continue(n) => FrrRouteMapExitAction::Continue(n), + } + } + } + + impl From for FrrRouteMapName { + fn from(value: RouteMapId) -> Self { + FrrRouteMapName::new(value.0) + } + } + + impl From for FrrRouteMapEntry { + fn from(value: RouteMapEntry) -> FrrRouteMapEntry { + FrrRouteMapEntry { + seq: value.id.order, + action: match value.action { + RouteMapAction::Permit => proxmox_frr::ser::route_map::AccessAction::Permit, + RouteMapAction::Deny => proxmox_frr::ser::route_map::AccessAction::Deny, + }, + matches: value + .match_actions + .into_iter() + .map(|match_action| match_action.into_inner().into()) + .collect(), + sets: value + .set_actions + .into_iter() + .map(|set_action| set_action.into_inner().into()) + .collect(), + call: value.call.map(FrrRouteMapName::from), + exit_action: value.exit_action.map(|value| value.into_inner().into()), + custom_frr_config: Default::default(), + } + } + } + + /// Add a list of Route Map Entries to a [`FrrConfig`]. + /// + /// This method takes a list of Route Map Entries and adds them to given FRR configuration. + /// If a route map with the same name as at least one entry in the config exists in the FRR + /// configuration, then the *whole* route map will get overwritten with the route map from the + /// configuration. + pub fn build_frr_route_maps( + config: impl IntoIterator, + frr_config: &mut FrrConfig, + ) -> Result<(), anyhow::Error> { + let mut config_route_map: HashMap> = HashMap::new(); + + for route_map in config.into_iter() { + let RouteMap::RouteMapEntry(route_map) = route_map; + let route_map_name = FrrRouteMapName::new(route_map.id.route_map_id.to_string()); + + if let Some(frr_route_map) = config_route_map.get_mut(&route_map_name) { + let idx = + frr_route_map.partition_point(|element| element.seq <= route_map.id().order()); + frr_route_map.insert(idx, route_map.into()); + } else { + config_route_map.insert(route_map_name, vec![route_map.into()]); + } + } + + for (name, entries) in config_route_map { + frr_config.routemaps.insert(name, entries); + } + + Ok(()) + } +} + pub mod api { //! API type for Route Map Entries. //! -- 2.47.3