fix: wip

Author: conblem

src/config.rs renamed to src/config/listener.rs

@@ -1,11 +1,6 @@
-use anyhow::Result;
 use serde::de::{SeqAccess, Visitor};
 use serde::{Deserialize, Deserializer};
-use std::collections::HashMap;
 use std::fmt::Formatter;
-use std::fs::File;
-use std::io::Read;
-use tracing::{debug, info, info_span};
 
 #[derive(Debug, Copy, Clone)]
 pub enum ProxyProtocol {
@@ -15,12 +10,12 @@ pub enum ProxyProtocol {
 
 impl<'de> Deserialize<'de> for ProxyProtocol {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
+    where
+        D: Deserializer<'de>,
     {
         match bool::deserialize(deserializer)? {
             true => Ok(ProxyProtocol::Enabled),
-            false => Ok(ProxyProtocol::Disabled)
+            false => Ok(ProxyProtocol::Disabled),
         }
     }
 }
@@ -77,55 +72,3 @@ impl<'de> Deserialize<'de> for Listener {
         deserializer.deserialize_any(ListenerVisitor)
     }
 }
-
-#[derive(Deserialize, Debug)]
-pub struct Api {
-    pub http: Listener,
-    pub https: Listener,
-    pub prom: Listener,
-}
-
-fn default_acme() -> String {
-    "https://acme-v02.api.letsencrypt.org/directory".to_string()
-}
-
-#[derive(Deserialize, Debug)]
-pub struct General {
-    pub dns: String,
-    pub db: String,
-    #[serde(default = "default_acme")]
-    pub acme: String,
-    pub name: String,
-}
-
-#[derive(Deserialize, Debug)]
-pub struct Config {
-    pub general: General,
-    pub api: Api,
-    #[serde(default)]
-    pub records: HashMap<String, Vec<Vec<String>>>,
-}
-
-const DEFAULT_CONFIG_PATH: &str = "config.toml";
-
-// is not async so we can use it to load settings for tokio runtime
-pub fn load_config(config_path: Option<String>) -> Result<Config> {
-    let config_path = config_path.as_deref().unwrap_or(DEFAULT_CONFIG_PATH);
-
-    let span = info_span!("load_config", config_path);
-    let _enter = span.enter();
-
-    let mut file = File::open(config_path)?;
-    debug!(?file, "Opened file");
-
-    let mut bytes = vec![];
-    file.read_to_end(&mut bytes)?;
-    debug!(file_length = bytes.len(), "Read file");
-
-    let config = toml::de::from_slice::<Config>(&bytes)?;
-    // redact db information
-    let config_str = format!("{:?}", config).replace(&config.general.db, "******");
-    info!(config = %config_str, "Deserialized config");
-
-    Ok(config)
-}

src/config/mod.rs

@@ -0,0 +1,63 @@
+use anyhow::Result;
+use serde::Deserialize;
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::Read;
+use tracing::{debug, info, info_span};
+
+pub use listener::{Listener, ProxyProtocol};
+
+mod listener;
+mod records;
+
+#[derive(Deserialize, Debug)]
+pub struct Api {
+    pub http: Listener,
+    pub https: Listener,
+    pub prom: Listener,
+}
+
+fn default_acme() -> String {
+    "https://acme-v02.api.letsencrypt.org/directory".to_string()
+}
+
+#[derive(Deserialize, Debug)]
+pub struct General {
+    pub dns: String,
+    pub db: String,
+    #[serde(default = "default_acme")]
+    pub acme: String,
+    pub name: String,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct Config {
+    pub general: General,
+    pub api: Api,
+    #[serde(default)]
+    pub records: HashMap<String, Vec<Vec<String>>>,
+}
+
+const DEFAULT_CONFIG_PATH: &str = "config.toml";
+
+// is not async so we can use it to load settings for tokio runtime
+pub fn load_config(config_path: Option<String>) -> Result<Config> {
+    let config_path = config_path.as_deref().unwrap_or(DEFAULT_CONFIG_PATH);
+
+    let span = info_span!("load_config", config_path);
+    let _enter = span.enter();
+
+    let mut file = File::open(config_path)?;
+    debug!(?file, "Opened file");
+
+    let mut bytes = vec![];
+    file.read_to_end(&mut bytes)?;
+    debug!(file_length = bytes.len(), "Read file");
+
+    let config = toml::de::from_slice::<Config>(&bytes)?;
+    // redact db information
+    let config_str = format!("{:?}", config).replace(&config.general.db, "******");
+    info!(config = %config_str, "Deserialized config");
+
+    Ok(config)
+}

src/config/records.rs

@@ -0,0 +1,89 @@
+use serde::de::{DeserializeSeed, Error as DeError, MapAccess, SeqAccess, Visitor};
+use serde::{Deserialize, Deserializer};
+use std::collections::HashMap;
+use std::fmt::Formatter;
+use std::str::FromStr;
+use std::sync::Arc;
+use trust_dns_server::proto::rr::{Name, RecordSet, RecordType};
+
+#[derive(Default)]
+struct PreconfiguredRecords(HashMap<Name, HashMap<&str, Arc<RecordSet>>>);
+
+impl<'de> Deserialize<'de> for PreconfiguredRecords {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct PreconfiguredRecordsVisitor;
+        impl<'de> Visitor<'de> for PreconfiguredRecordsVisitor {
+            type Value = PreconfiguredRecords;
+
+            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+                formatter.write_str("PreconfiguredRecords")
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: MapAccess<'de>,
+            {
+                let mut res = HashMap::new();
+                while let Some(key) = map.next_key::<&str>()? {
+                    let name = match Name::from_str(key) {
+                        Err(e) => return Err(DeError::custom(e)),
+                        Ok(name) => name,
+                    };
+
+                    let (record_type, record_set) =
+                        map.next_value_seed(RecordDataSeed(name.clone()))?;
+
+                    res.insert(record_type, record_set);
+                }
+
+                Ok(PreconfiguredRecords(res))
+            }
+        }
+
+        deserializer.deserialize_map(PreconfiguredRecordsVisitor)
+    }
+}
+
+struct RecordDataSeed(Name);
+
+impl<'de> DeserializeSeed<'de> for RecordDataSeed {
+    type Value = (RecordType, Arc<RecordSet>);
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct RecordDataVisitor(Name);
+        impl<'de> Visitor<'de> for RecordDataVisitor {
+            type Value = (RecordType, Arc<RecordSet>);
+
+            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+                formatter.write_str("RecordData")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                let record_type = match seq.next_element::<&str>()? {
+                    Some(record_type) => record_type,
+                    None => return Err(DeError::custom("Could not find RecordType")),
+                };
+
+                let ttl = match seq.next_element::<u32>()? {
+                    Some(ttl) => ttl,
+                    None => return Err(DeError::custom("Could not find TTL")),
+                };
+
+                let record_set = Arc::new(RecordSet::with_ttl(self.0, record_type, ttl));
+
+                Ok((record_type, record_set))
+            }
+        }
+
+        deserializer.deserialize_seq(RecordDataVisitor(self.0))
+    }
+}