[pve-devel] [PATCH proxmox-ve-rs v5 04/22] frr: add common frr types

[Gabriel Goller]

Add common FRR configuration types such as FrrWord,
CommonInterfaceName, etc. These are some common types that are used by
both openfabric and ospf and the generic types that span the two
protocols. The FrrWord is a simple primitive in FRR, which is a
ascii-string that doesn't contain whitespaces.

Signed-off-by: Gabriel Goller <g.goller at proxmox.com>
---
 proxmox-frr/src/lib.rs | 121 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 121 insertions(+)

diff --git a/proxmox-frr/src/lib.rs b/proxmox-frr/src/lib.rs
index e69de29bb2d1..3a66fea63e63 100644
--- a/proxmox-frr/src/lib.rs
+++ b/proxmox-frr/src/lib.rs
@@ -0,0 +1,121 @@
+use std::{fmt::Display, str::FromStr};
+
+use thiserror::Error;
+
+/// The interface name is the same on ospf and openfabric, but it is an enum so that we can have
+/// two different entries in the btreemap. This allows us to have an interface in a ospf and
+/// openfabric fabric.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum InterfaceName {
+    Openfabric(CommonInterfaceName),
+    Ospf(CommonInterfaceName),
+}
+
+impl Display for InterfaceName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InterfaceName::Openfabric(frr_word) => frr_word.fmt(f),
+            InterfaceName::Ospf(frr_word) => frr_word.fmt(f),
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum FrrWordError {
+    #[error("word is empty")]
+    IsEmpty,
+    #[error("word contains invalid character")]
+    InvalidCharacter,
+}
+
+/// A simple FRR Word.
+///
+/// Every string argument or value in FRR is an FrrWord. FrrWords must only contain ascii
+/// characters and must not have a whitespace.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct FrrWord(String);
+
+impl FrrWord {
+    pub fn new<T: AsRef<str> + Into<String>>(name: T) -> Result<Self, FrrWordError> {
+        if name.as_ref().is_empty() {
+            return Err(FrrWordError::IsEmpty);
+        }
+
+        if name
+            .as_ref()
+            .as_bytes()
+            .iter()
+            .any(|c| !c.is_ascii() || c.is_ascii_whitespace())
+        {
+            eprintln!("invalid char in: \"{}\"", name.as_ref());
+            return Err(FrrWordError::InvalidCharacter);
+        }
+
+        Ok(Self(name.into()))
+    }
+}
+
+impl FromStr for FrrWord {
+    type Err = FrrWordError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::new(s)
+    }
+}
+
+impl Display for FrrWord {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl AsRef<str> for FrrWord {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum CommonInterfaceNameError {
+    #[error("interface name too long")]
+    TooLong,
+}
+
+/// Name of a interface, which is common between all protocols.
+///
+/// FRR itself doesn't enforce any limits, but the kernel does. Linux only allows interface names
+/// to be a maximum of 16 bytes. This is enforced by this struct.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct CommonInterfaceName(String);
+
+impl TryFrom<&str> for CommonInterfaceName {
+    type Error = CommonInterfaceNameError;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        Self::new(value)
+    }
+}
+
+impl TryFrom<String> for CommonInterfaceName {
+    type Error = CommonInterfaceNameError;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::new(value)
+    }
+}
+
+impl CommonInterfaceName {
+    pub fn new<T: AsRef<str> + Into<String>>(s: T) -> Result<Self, CommonInterfaceNameError> {
+        if s.as_ref().len() <= 15 {
+            Ok(Self(s.into()))
+        } else {
+            Err(CommonInterfaceNameError::TooLong)
+        }
+    }
+}
+
+impl Display for CommonInterfaceName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
-- 
2.39.5