add toml parser to configuration file system

Author: 0x7d8

Cargo.lock

@@ -83,6 +83,7 @@ positioned-io = "0.3.5"
 rmp-serde = "1.3.1"
 accept-header = "0.2.3"
 mime = "0.3.17"
+toml = { version = "0.9.11", features = ["preserve_order"] }
 
 [target.'cfg(unix)'.dependencies]
 users = "0.11.0"

application/Cargo.toml

@@ -9,6 +9,7 @@ mod ini;
 mod json;
 mod plain;
 mod properties;
+mod toml;
 mod xml;
 mod yaml;
 
@@ -27,6 +28,7 @@ pub enum ServerConfigurationFileParser {
     Ini,
     Json,
     Xml,
+    Toml,
 }
 
 #[derive(ToSchema, Deserialize, Clone, Debug)]
@@ -386,6 +388,9 @@ impl ProcessConfiguration {
                 ServerConfigurationFileParser::File => {
                     plain::PlainFileParser::process_file(&file_content, config, server).await?
                 }
+                ServerConfigurationFileParser::Toml => {
+                    toml::TomlFileParser::process_file(&file_content, config, server).await?
+                }
             };
 
             server

application/src/server/configuration/process/mod.rs

@@ -0,0 +1,91 @@
+use super::ServerConfigurationFile;
+use serde::Deserialize;
+
+pub struct TomlFileParser;
+
+#[async_trait::async_trait]
+impl super::ProcessConfigurationFileParser for TomlFileParser {
+    async fn process_file(
+        content: &str,
+        config: &ServerConfigurationFile,
+        server: &crate::server::Server,
+    ) -> Result<Vec<u8>, anyhow::Error> {
+        tracing::debug!(
+            server = %server.uuid,
+            "processing toml file"
+        );
+
+        let mut toml = if content.trim().is_empty() {
+            toml::Value::Table(toml::map::Map::new())
+        } else {
+            toml::from_str(content).unwrap_or_else(|_| toml::Value::Table(toml::map::Map::new()))
+        };
+
+        for replacement in &config.replace {
+            let value = match &replacement.replace_with {
+                serde_json::Value::String(_) => {
+                    let resolved = ServerConfigurationFile::replace_all_placeholders(
+                        server,
+                        &replacement.replace_with,
+                    )
+                    .await?;
+
+                    toml::de::ValueDeserializer::parse(&resolved).map_or_else(
+                        |_| toml::Value::String(resolved.to_string()),
+                        |v| {
+                            toml::Value::deserialize(v)
+                                .unwrap_or_else(|_| toml::Value::String(resolved.to_string()))
+                        },
+                    )
+                }
+                other => toml::Value::try_from(other.clone())
+                    .unwrap_or_else(|_| toml::Value::String(other.to_string())),
+            };
+
+            let path: Vec<&str> = replacement.r#match.split('.').collect();
+            set_nested_value(
+                &mut toml,
+                &path,
+                value,
+                replacement.insert_new.unwrap_or(true),
+                replacement.update_existing,
+            );
+        }
+
+        Ok(toml::to_string_pretty(&toml)?.into_bytes())
+    }
+}
+
+pub fn set_nested_value(
+    toml: &mut toml::Value,
+    path: &[&str],
+    value: toml::Value,
+    insert_new: bool,
+    update_existing: bool,
+) {
+    if path.is_empty() {
+        return;
+    }
+
+    if !toml.is_table() {
+        *toml = toml::Value::Table(toml::map::Map::new());
+    }
+
+    let map = toml.as_table_mut().unwrap();
+
+    if path.len() == 1 {
+        let key = path[0].to_string();
+        let exists = map.contains_key(&key);
+
+        if (exists && update_existing) || (!exists && insert_new) {
+            map.insert(key, value);
+        }
+        return;
+    }
+
+    let child = map
+        .entry(path[0].to_string())
+        .or_insert_with(|| toml::Value::Table(toml::map::Map::new()));
+
+    set_nested_value(child, &path[1..], value, insert_new, update_existing);
+}