basic netns management

src/config/mod.rs

@@ -0,0 +1,109 @@
+mod destination;
+mod name;
+mod source;
+
+pub use crate::config::destination::ForwardDestination;
+pub use crate::config::name::NamespaceName;
+pub use crate::config::source::ForwardSource;
+use serde::Deserialize;
+use std::collections::HashSet;
+use std::fs::read_to_string;
+use std::path::{Path, PathBuf};
+use thiserror::Error;
+use toml::from_str;
+
+#[derive(Debug)]
+pub struct Config {
+    path: PathBuf,
+    pub namespaces: Vec<NamespaceConfig>,
+}
+
+impl Config {
+    pub fn load<P: AsRef<Path>>(path: P) -> Result<Config, ConfigError> {
+        let path = path.as_ref();
+        let raw = read_to_string(path).map_err(|error| ConfigError::Read {
+            error,
+            path: path.to_owned(),
+        })?;
+        let config: RawConfig = from_str(&raw).map_err(|error| ConfigError::Parse {
+            error,
+            path: path.to_owned(),
+        })?;
+        Ok(config
+            .validate(path)
+            .map_err(|error| ConfigError::Validation {
+                error,
+                path: path.to_owned(),
+            })?)
+    }
+    
+    pub fn reload(&self) -> Result<Config, ConfigError> {
+        Self::load(&self.path)
+    }
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+struct RawConfig {
+    #[serde(default, rename = "namespace")]
+    pub namespaces: Vec<NamespaceConfig>,
+}
+
+impl RawConfig {
+    fn validate(self, path: &Path) -> Result<Config, ValidationError> {
+        let mut sources = HashSet::new();
+        for source in self
+            .namespaces
+            .iter()
+            .flat_map(|namespace| namespace.forward.iter())
+            .map(|forward| &forward.source)
+        {
+            if !sources.insert(source.clone()) {
+                return Err(ValidationError::DuplicateSource {
+                    forward_source: source.clone(),
+                });
+            }
+        }
+        Ok(Config {
+            path: path.into(),
+            namespaces: self.namespaces,
+        })
+    }
+}
+
+#[derive(Deserialize, Debug)]
+pub struct NamespaceConfig {
+    pub name: NamespaceName,
+    pub forward: Vec<ForwardConfig>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct ForwardConfig {
+    pub source: ForwardSource,
+    pub destination: ForwardDestination,
+}
+
+#[derive(Debug, Error)]
+pub enum ConfigError {
+    #[error("Error while reading config from {}: {error:#}", path.display())]
+    Read {
+        error: std::io::Error,
+        path: PathBuf,
+    },
+    #[error("Error while parsing config from {}: {error:#}", path.display())]
+    Parse {
+        error: toml::de::Error,
+        path: PathBuf,
+    },
+    #[error("Error while validating config from {}: {error:#}", path.display())]
+    Validation {
+        error: ValidationError,
+        path: PathBuf,
+    },
+}
+
+#[derive(Debug, Error)]
+pub enum ValidationError {
+    #[error("Duplicate source in forwards: {forward_source}")]
+    DuplicateSource { forward_source: ForwardSource },
+}