[PATCH proxmox-ve-rs 1/9] sdn-types: add common route-map helper types

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

The reason for including those types here is that they are used in
proxmox-frr for generating the FRR configuratiobn as well as
proxmox-ve-config for saving them inside a section config.

For some values in route maps FRR supports specifying either an
absolute value or a value relative to the existing value when
modifying a route via a route map. E.g. 123 would set the value to
123, whereas +/-123 would add/subtract 123 from the existing value.
IntegerWithSign can be used to represent such a value in the section
config.
Metric supports this notation as well as some magical values (e.g.
subtracting the round-trip-time).

Signed-off-by: Stefan Hanreich <s.hanreich@proxmox.com>
---
 proxmox-sdn-types/src/bgp.rs |  50 +++++++++++++
 proxmox-sdn-types/src/lib.rs | 135 +++++++++++++++++++++++++++++++++++
 2 files changed, 185 insertions(+)
 create mode 100644 proxmox-sdn-types/src/bgp.rs

diff --git a/proxmox-sdn-types/src/bgp.rs b/proxmox-sdn-types/src/bgp.rs
new file mode 100644
index 0000000..168bc1a
--- /dev/null
+++ b/proxmox-sdn-types/src/bgp.rs
@@ -0,0 +1,50 @@
+use serde::{Deserialize, Serialize};
+
+use crate::IntegerWithSign;
+
+/// Represents a BGP metric value, as used in FRR.
+///
+/// A metric can either be a numeric value, or certain 'magic' values. For more information see the
+/// respective enum variants.
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub enum SetMetricValue {
+    /// Set the metric to the round-trip-time.
+    #[serde(rename = "rtt")]
+    Rtt,
+    /// Add the round-trip-time to the metric.
+    #[serde(rename = "+rtt")]
+    AddRtt,
+    /// Subtract the round-trip-time from the metric.
+    #[serde(rename = "-rtt")]
+    SubtractRtt,
+    /// Use the IGP value when importing from another IGP.
+    #[serde(rename = "igp")]
+    Igp,
+    /// Use the accumulated IGP value when importing from another IGP.
+    #[serde(rename = "aigp")]
+    Aigp,
+    /// Set the metric to a fixed numeric value.
+    #[serde(untagged)]
+    Numeric(IntegerWithSign),
+}
+
+/// An EVPN route-type, as used in the FRR route maps.
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum EvpnRouteType {
+    Ead,
+    MacIp,
+    Multicast,
+    #[serde(rename = "es")]
+    EthernetSegment,
+    Prefix,
+}
+
+/// An tag value, as used in the FRR route maps.
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum SetTagValue {
+    Untagged,
+    #[serde(untagged)]
+    Numeric(#[serde(deserialize_with = "proxmox_serde::perl::deserialize_u32")] u32),
+}
diff --git a/proxmox-sdn-types/src/lib.rs b/proxmox-sdn-types/src/lib.rs
index 1656f1d..fe4c641 100644
--- a/proxmox-sdn-types/src/lib.rs
+++ b/proxmox-sdn-types/src/lib.rs
@@ -1,3 +1,138 @@
 pub mod area;
+pub mod bgp;
 pub mod net;
 pub mod openfabric;
+
+use serde::de::{Error, Visitor};
+use serde::{Deserialize, Serialize};
+
+use proxmox_schema::api;
+
+/// Enum for representing signedness of Integer in [`IntegerWithSign`].
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub enum Sign {
+    #[serde(rename = "-")]
+    Negative,
+    #[serde(rename = "+")]
+    Positive,
+}
+
+proxmox_serde::forward_display_to_serialize!(Sign);
+proxmox_serde::forward_from_str_to_deserialize!(Sign);
+
+/// An Integer with an optional [`Sign`].
+///
+/// This is used for representing certain keys in the FRR route maps (e.g. metric). They can be set
+/// to either a static value (no sign) or to a value relative to the existing value (with sign).
+/// For instance, a value of 50 would set the metric to 50, but a value of +50 would add 50 to the
+/// existing metric value.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct IntegerWithSign {
+    pub(crate) sign: Option<Sign>,
+    pub(crate) n: u32,
+}
+
+impl std::fmt::Display for IntegerWithSign {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if let Some(sign) = self.sign.as_ref() {
+            write!(f, "{}{}", sign, self.n)
+        } else {
+            self.n.fmt(f)
+        }
+    }
+}
+
+impl std::str::FromStr for IntegerWithSign {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
+        if let Some(n) = s.strip_prefix("+") {
+            return Ok(Self {
+                sign: Some(Sign::Positive),
+                n: n.parse()?,
+            });
+        }
+
+        if let Some(n) = s.strip_prefix("-") {
+            return Ok(Self {
+                sign: Some(Sign::Negative),
+                n: n.parse()?,
+            });
+        }
+
+        Ok(Self {
+            sign: None,
+            n: s.parse()?,
+        })
+    }
+}
+
+impl<'de> Deserialize<'de> for IntegerWithSign {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct V;
+
+        impl<'de> Visitor<'de> for V {
+            type Value = IntegerWithSign;
+
+            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                f.write_str("An integer with an optional leading sign")
+            }
+
+            fn visit_i128<E: serde::de::Error>(self, value: i128) -> Result<Self::Value, E> {
+                Ok(IntegerWithSign {
+                    sign: None,
+                    n: u32::try_from(value).map_err(E::custom)?,
+                })
+            }
+
+            fn visit_i64<E: serde::de::Error>(self, value: i64) -> Result<Self::Value, E> {
+                Ok(IntegerWithSign {
+                    sign: None,
+                    n: u32::try_from(value).map_err(E::custom)?,
+                })
+            }
+
+            fn visit_u64<E: serde::de::Error>(self, value: u64) -> Result<Self::Value, E> {
+                Ok(IntegerWithSign {
+                    sign: None,
+                    n: u32::try_from(value).map_err(E::custom)?,
+                })
+            }
+
+            fn visit_u128<E: serde::de::Error>(self, value: u128) -> Result<Self::Value, E> {
+                Ok(IntegerWithSign {
+                    sign: None,
+                    n: u32::try_from(value).map_err(E::custom)?,
+                })
+            }
+
+            fn visit_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
+                v.parse().map_err(E::custom)
+            }
+        }
+
+        deserializer.deserialize_any(V)
+    }
+}
+
+proxmox_serde::forward_serialize_to_display!(IntegerWithSign);
+
+#[api(
+    type: Integer,
+    minimum: 1,
+    maximum: 16_777_215,
+)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
+#[repr(transparent)]
+/// Represents a VXLAN VNI (24-bit unsigned integer).
+pub struct Vni(#[serde(deserialize_with = "proxmox_serde::perl::deserialize_u32")] u32);
+
+impl Vni {
+    /// Returns the VNI as u32.
+    pub fn as_u32(&self) -> u32 {
+        self.0
+    }
+}
-- 
2.47.3