pub mod admin;
pub mod cluster;
pub mod logging;
pub mod otel;
pub mod reload;
pub mod server;
use std::collections::{HashMap, HashSet};
use std::path::Path;
use serde::Deserialize;
use crate::errors;
#[derive(Debug, Deserialize)]
pub struct Config {
#[serde(default)]
pub server: server::ServerConfig,
#[serde(default)]
pub logging: logging::LoggingConfig,
#[serde(default)]
pub admin: admin::AdminConfig,
#[serde(default)]
pub otel: otel::OtelConfig,
#[serde(default)]
pub cluster: HashMap<String, cluster::ClusterConfig>,
}
impl Config {
pub fn load(path: &Path) -> Result<Self, errors::ConfigError> {
let content = std::fs::read_to_string(path)?;
Self::parse(&content)
}
pub fn parse(s: &str) -> Result<Self, errors::ConfigError> {
let config: Config = toml::from_str(s)?;
config.validate()?;
Ok(config)
}
pub fn find_pool(
&self,
database: &str,
) -> Option<(&str, &cluster::ClusterConfig, &cluster::pool::PoolConfig)> {
for (name, cluster) in &self.cluster {
if let Some(pool) = cluster.pool.get(database) {
return Some((name, cluster, pool));
}
}
None
}
pub fn is_user_allowed(&self, database: &str, user: &str) -> bool {
self.find_user(database, user).is_some()
}
pub fn find_user(
&self,
database: &str,
user: &str,
) -> Option<&cluster::pool::user::UserConfig> {
let (_, _, pool) = self.find_pool(database)?;
pool.user.get(user)
}
fn validate(&self) -> Result<(), errors::ConfigError> {
self.server.validate()?;
let mut seen_databases = HashSet::new();
for cluster in self.cluster.values() {
for db_name in cluster.pool.keys() {
if !seen_databases.insert(db_name) {
return Err(errors::ConfigError::Validation(format!(
"database {db_name:?} appears in multiple clusters"
)));
}
}
}
for (cluster_name, cluster) in &self.cluster {
cluster.validate(cluster_name)?;
}
Ok(())
}
}