use std::io::Read;
use std::net::SocketAddr;
use std::path::PathBuf;
use serde::{de, Deserialize};
use crate::error::Error;
#[derive(Deserialize, Debug, Clone)]
pub struct Config {
pub metadata_dir: PathBuf,
pub data_dir: PathBuf,
#[serde(default = "default_block_size")]
pub block_size: usize,
pub replication_mode: String,
#[serde(
deserialize_with = "deserialize_compression",
default = "default_compression"
)]
pub compression_level: Option<i32>,
pub rpc_secret: String,
pub rpc_bind_addr: SocketAddr,
pub rpc_public_addr: Option<String>,
pub rpc_ping_timeout_msec: Option<u64>,
pub rpc_timeout_msec: Option<u64>,
#[serde(default)]
pub bootstrap_peers: Vec<String>,
#[serde(default)]
pub consul_discovery: Option<ConsulDiscoveryConfig>,
#[serde(default)]
pub kubernetes_discovery: Option<KubernetesDiscoveryConfig>,
#[serde(default = "default_db_engine")]
pub db_engine: String,
#[serde(default = "default_sled_cache_capacity")]
pub sled_cache_capacity: u64,
#[serde(default = "default_sled_flush_every_ms")]
pub sled_flush_every_ms: u64,
pub s3_api: S3ApiConfig,
pub k2v_api: Option<K2VApiConfig>,
pub s3_web: Option<WebConfig>,
#[serde(default = "Default::default")]
pub admin: AdminConfig,
}
#[derive(Deserialize, Debug, Clone)]
pub struct S3ApiConfig {
pub api_bind_addr: Option<SocketAddr>,
pub s3_region: String,
pub root_domain: Option<String>,
}
#[derive(Deserialize, Debug, Clone)]
pub struct K2VApiConfig {
pub api_bind_addr: SocketAddr,
}
#[derive(Deserialize, Debug, Clone)]
pub struct WebConfig {
pub bind_addr: SocketAddr,
pub root_domain: String,
}
#[derive(Deserialize, Debug, Clone, Default)]
pub struct AdminConfig {
pub api_bind_addr: Option<SocketAddr>,
pub metrics_token: Option<String>,
pub admin_token: Option<String>,
pub trace_sink: Option<String>,
}
#[derive(Deserialize, Debug, Clone)]
pub struct ConsulDiscoveryConfig {
pub consul_http_addr: String,
pub service_name: String,
pub ca_cert: Option<String>,
pub client_cert: Option<String>,
pub client_key: Option<String>,
#[serde(default)]
pub tls_skip_verify: bool,
}
#[derive(Deserialize, Debug, Clone)]
pub struct KubernetesDiscoveryConfig {
pub namespace: String,
pub service_name: String,
#[serde(default)]
pub skip_crd: bool,
}
fn default_db_engine() -> String {
"sled".into()
}
fn default_sled_cache_capacity() -> u64 {
128 * 1024 * 1024
}
fn default_sled_flush_every_ms() -> u64 {
2000
}
fn default_block_size() -> usize {
1048576
}
pub fn read_config(config_file: PathBuf) -> Result<Config, Error> {
let mut file = std::fs::OpenOptions::new()
.read(true)
.open(config_file.as_path())?;
let mut config = String::new();
file.read_to_string(&mut config)?;
Ok(toml::from_str(&config)?)
}
fn default_compression() -> Option<i32> {
Some(1)
}
fn deserialize_compression<'de, D>(deserializer: D) -> Result<Option<i32>, D::Error>
where
D: de::Deserializer<'de>,
{
use std::convert::TryFrom;
struct OptionVisitor;
impl<'de> serde::de::Visitor<'de> for OptionVisitor {
type Value = Option<i32>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("int or 'none'")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
if value.eq_ignore_ascii_case("none") {
Ok(None)
} else {
Err(E::custom(format!(
"Invalid compression level: '{}', should be a number, or 'none'",
value
)))
}
}
fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
i32::try_from(v)
.map(Some)
.map_err(|_| E::custom("Compression level out of bound".to_owned()))
}
fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
i32::try_from(v)
.map(Some)
.map_err(|_| E::custom("Compression level out of bound".to_owned()))
}
}
deserializer.deserialize_any(OptionVisitor)
}