feat: finish config parsing

Author: bitfl0wer

Cargo.lock

@@ -24,6 +24,7 @@ poem = { version = "3.1.11", features = ["rustls", "hex", "compression"] }
 polyproto = { version = "0.10.0", features = ["serde"] }
 rand = "0.9.1"
 env_logger = { version = "0.11.8" }
+serde_with = "3.13.0"
 
 # We use `opt-level = "s"` as it significantly reduces binary size.
 # We could then use the `#[optimize(speed)]` attribute for spot optimizations.

Cargo.toml

@@ -3,8 +3,21 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use std::ops::Deref;
+use std::sync::OnceLock;
 
 use serde::Deserialize;
+use serde_with::{DisplayFromStr, serde_as};
+
+use crate::{StdError, StdResult};
+
+static CONFIG: OnceLock<SonataConfig> = OnceLock::new();
+
+const TLS_CONFIG_DISABLE: &str = "disable";
+const TLS_CONFIG_ALLOW: &str = "allow";
+const TLS_CONFIG_PREFER: &str = "prefer";
+const TLS_CONFIG_REQUIRE: &str = "require";
+const TLS_CONFIG_VERIFY_CA: &str = "verify_ca";
+const TLS_CONFIG_VERIFY_FULL: &str = "verify_full";
 
 #[derive(Deserialize, Debug)]
 pub struct SonataConfig {
@@ -47,8 +60,19 @@ pub struct GeneralConfig {
     pub database: DatabaseConfig,
 }
 
+#[serde_as]
 #[derive(Deserialize, Debug)]
-pub struct DatabaseConfig;
+pub struct DatabaseConfig {
+    pub max_connections: u16,
+    pub database: String,
+    pub username: String,
+    pub password: String,
+    pub port: u16,
+    pub host: String,
+    #[serde(default)]
+    #[serde_as(as = "DisplayFromStr")]
+    pub tls: TlsConfig,
+}
 
 #[derive(Deserialize, Debug)]
 pub struct ComponentConfig {
@@ -57,3 +81,79 @@ pub struct ComponentConfig {
     pub host: String,
     pub tls: bool,
 }
+
+impl SonataConfig {
+    pub fn init(input: &str) -> StdResult<()> {
+        let cfg = toml::from_str::<Self>(input)?;
+        CONFIG.set(cfg).map_err(|_| String::from("config global was already set"))?;
+        Ok(())
+    }
+
+    #[allow(clippy::expect_used)]
+    /// Gets a static reference to the parsed configuration file. Will panic, if [Self] has not been initialized using [Self::init()].
+    pub fn get_or_panic() -> &'static Self {
+        CONFIG.get().expect("config has not been initialized yet")
+    }
+}
+
+#[derive(Debug, Deserialize, Default)]
+/// TLS configuration modes. Also called `sslconfig` by PostgreSQL. See <https://www.postgresql.org/docs/current/libpq-ssl.html#:~:text=32.1.%C2%A0SSL%20Mode-,descriptions,-sslmode>
+/// for the security implications of this choice.
+pub enum TlsConfig {
+    /// I don't care about security, and I don't want to pay the overhead of
+    /// encryption.
+    Disable,
+    /// I don't care about security, but I will pay the overhead of encryption
+    /// if the server insists on it.
+    Allow,
+    /// I don't care about encryption, but I wish to pay the overhead of
+    /// encryption if the server supports it.
+    Prefer,
+    /// I want my data to be encrypted, and I accept the overhead. I trust that
+    /// the network will make sure I always connect to the server I want.
+    #[default]
+    Require,
+    /// I want my data encrypted, and I accept the overhead. I want to be sure
+    /// that I connect to a server that I trust.
+    VerifyCa,
+    /// I want my data encrypted, and I accept the overhead. I want to be sure
+    /// that I connect to a server I trust, and that it's the one I specify.
+    VerifyFull,
+}
+
+impl TryFrom<&str> for TlsConfig {
+    type Error = StdError;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value.to_lowercase().as_str() {
+            TLS_CONFIG_DISABLE => Ok(Self::Disable),
+            TLS_CONFIG_ALLOW => Ok(Self::Disable),
+            TLS_CONFIG_PREFER => Ok(Self::Disable),
+            TLS_CONFIG_REQUIRE => Ok(Self::Disable),
+            "verifyca" | TLS_CONFIG_VERIFY_CA | "verify-ca" => Ok(Self::Disable),
+            "verifyfull" | TLS_CONFIG_VERIFY_FULL | "verify-full" => Ok(Self::Disable),
+            other => Err(format!("{other} is not a valid TLS configuration value").into()),
+        }
+    }
+}
+
+impl std::fmt::Display for TlsConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            TlsConfig::Disable => TLS_CONFIG_DISABLE,
+            TlsConfig::Allow => TLS_CONFIG_ALLOW,
+            TlsConfig::Prefer => TLS_CONFIG_PREFER,
+            TlsConfig::Require => TLS_CONFIG_REQUIRE,
+            TlsConfig::VerifyCa => TLS_CONFIG_VERIFY_CA,
+            TlsConfig::VerifyFull => TLS_CONFIG_VERIFY_FULL,
+        })
+    }
+}
+
+impl std::str::FromStr for TlsConfig {
+    type Err = Box<dyn std::error::Error + 'static>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        TlsConfig::try_from(s)
+    }
+}

src/config/mod.rs

@@ -20,10 +20,14 @@ pub(crate) type StdResult<T> = Result<T, StdError>;
 #[tokio::main]
 #[cfg(not(tarpaulin))]
 async fn main() -> StdResult<()> {
+    use std::path::PathBuf;
+    use std::str::FromStr;
+
     use clap::Parser;
-    use log::{LevelFilter, debug};
+    use log::{LevelFilter, debug, trace};
 
     use crate::cli::Args;
+    use crate::config::SonataConfig;
     _ = Args::parse(); // Has to be done, else clap doesn't work correctly.
     Args::init_global()?;
     let verbose_level = match Args::get_or_panic().verbose {
@@ -54,5 +58,15 @@ async fn main() -> StdResult<()> {
         .filter(Some("sonata"), log_level)
         .try_init()?;
     debug!("Hello, world!");
+    let config_location = match &Args::get_or_panic().config {
+        Some(path) => path,
+        None => &PathBuf::from_str("sonata.toml")?,
+    };
+
+    debug!("Parsing config at {config_location:?}...");
+    SonataConfig::init(&std::fs::read_to_string(config_location)?)?;
+    debug!("Parsed config!");
+    trace!("Read config {:#?}", SonataConfig::get_or_panic());
+
     Ok(())
 }