[PATCH proxmox-ve-rs v4 05/47] 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 configuration as well as
proxmox-ve-config for utilizing them in the section config types.

For some values in route maps FRR supports specifying either an
absolute value or a value relative to the existing value. When
modifying the metric of a  route via a route map, '123' would set the
value to 123, whereas '+/-123' would add/subtract 123 from the
existing value. ModifyNumber can be used to represent such a value
in the section config.

Signed-off-by: Stefan Hanreich <s.hanreich@proxmox.com>
---
 proxmox-sdn-types/src/bgp.rs |  62 ++++++++++++++++++++
 proxmox-sdn-types/src/lib.rs | 107 +++++++++++++++++++++++++++++++++++
 2 files changed, 169 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..2e4d894
--- /dev/null
+++ b/proxmox-sdn-types/src/bgp.rs
@@ -0,0 +1,62 @@
+use serde::{Deserialize, Serialize};
+
+use crate::ModifyNumber;
+
+/// 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(ModifyNumber),
+}
+
+impl<T: Into<ModifyNumber>> From<T> for SetMetricValue {
+    fn from(value: T) -> Self {
+        Self::Numeric(value.into())
+    }
+}
+
+/// 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),
+}
+
+impl SetTagValue {
+    pub fn new(value: u32) -> Self {
+        SetTagValue::Numeric(value)
+    }
+}
diff --git a/proxmox-sdn-types/src/lib.rs b/proxmox-sdn-types/src/lib.rs
index 1656f1d..7254593 100644
--- a/proxmox-sdn-types/src/lib.rs
+++ b/proxmox-sdn-types/src/lib.rs
@@ -1,3 +1,110 @@
 pub mod area;
+pub mod bgp;
 pub mod net;
 pub mod openfabric;
+
+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 absolute or relative integer value.
+///
+/// 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 enum ModifyNumber {
+    Absolute(u32),
+    Relative(i32),
+}
+
+impl std::fmt::Display for ModifyNumber {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Absolute(n) => n.fmt(f),
+            Self::Relative(n) => {
+                if n.is_negative() {
+                    n.fmt(f)
+                } else {
+                    write!(f, "+{n}")
+                }
+            }
+        }
+    }
+}
+
+impl std::str::FromStr for ModifyNumber {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.starts_with(&['+', '-']) {
+            return Ok(Self::Relative(s.parse()?));
+        }
+
+        Ok(Self::Absolute(s.parse()?))
+    }
+}
+proxmox_serde::forward_deserialize_to_from_str!(ModifyNumber);
+proxmox_serde::forward_serialize_to_display!(ModifyNumber);
+
+#[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
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::str::FromStr;
+
+    #[test]
+    fn test_parse_modify_number() {
+        assert_eq!(
+            ModifyNumber::from_str("+32").expect("valid ModifyNumber"),
+            ModifyNumber::Relative(32),
+        );
+
+        assert_eq!(
+            ModifyNumber::from_str("-31322").expect("valid ModifyNumber"),
+            ModifyNumber::Relative(-31322),
+        );
+
+        assert_eq!(
+            ModifyNumber::from_str("32").expect("valid ModifyNumber"),
+            ModifyNumber::Absolute(32),
+        );
+    }
+
+    #[test]
+    fn test_display_modify_number() {
+        for s in &["+32", "-1234", "43344"] {
+            let integer_with_sign: ModifyNumber = s.parse().expect("is a valid ModifyNumber");
+            assert_eq!(&integer_with_sign.to_string(), s)
+        }
+    }
+}
-- 
2.47.3