use serde::Deserialize;
use std::collections::HashMap;
use std::fs;
use std::path::Path;
fn default_defaults() -> DefaultsConfig {
DefaultsConfig {
timeout_ms: default_timeout(),
retry_max: default_retry_max(),
retry_strategy: default_retry_strategy(),
health_check_interval_s: default_health_interval(),
circuit_breaker_threshold: default_cb_threshold(),
circuit_breaker_cooldown_s: default_cb_cooldown(),
}
}
#[derive(Debug, Clone, Deserialize)]
pub struct ConfigFile {
#[serde(default)]
pub devices: HashMap<String, DeviceConfigRaw>,
#[serde(default = "default_defaults")]
pub defaults: DefaultsConfig,
}
#[derive(Debug, Clone, Deserialize)]
pub struct DeviceConfigRaw {
pub protocol: String,
#[serde(default)]
pub variant: String,
pub host: Option<String>,
pub port: Option<u16>,
pub serial_port: Option<String>,
pub baud_rate: Option<u32>,
pub timeout_ms: Option<u64>,
pub unit_id: Option<u16>,
pub retry: Option<RetryConfigRaw>,
pub connection_strategy: Option<ConnectionStrategyConfig>,
pub health_check: Option<bool>,
#[serde(flatten)]
pub extras: HashMap<String, toml::Value>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct RetryConfigRaw {
pub max: u32,
pub strategy: String,
#[serde(default)]
pub base_ms: u64,
#[serde(default)]
pub max_ms: u64,
#[serde(default)]
pub step_ms: u64,
}
#[derive(Debug, Clone, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ConnectionStrategyConfig {
Simple,
Persistent,
Pooled {
min: usize,
max: usize,
timeout_ms: u64,
},
}
#[derive(Debug, Clone, Deserialize, Default)]
pub struct DefaultsConfig {
#[serde(default = "default_timeout")]
pub timeout_ms: u64,
#[serde(default = "default_retry_max")]
pub retry_max: u32,
#[serde(default = "default_retry_strategy")]
pub retry_strategy: String,
#[serde(default = "default_health_interval")]
pub health_check_interval_s: u64,
#[serde(default = "default_cb_threshold")]
pub circuit_breaker_threshold: u32,
#[serde(default = "default_cb_cooldown")]
pub circuit_breaker_cooldown_s: u64,
}
fn default_timeout() -> u64 {
5000
}
fn default_retry_max() -> u32 {
3
}
fn default_retry_strategy() -> String {
"exponential".into()
}
fn default_health_interval() -> u64 {
30
}
fn default_cb_threshold() -> u32 {
5
}
fn default_cb_cooldown() -> u64 {
30
}
#[derive(Debug, Clone)]
pub struct DeviceConfig {
pub protocol: String,
pub variant: String,
pub host: Option<String>,
pub port: Option<u16>,
pub serial_port: Option<String>,
pub baud_rate: Option<u32>,
pub timeout_ms: u64,
pub unit_id: u16,
pub retry: RetryConfigResolved,
pub connection_strategy: ConnectionStrategyConfig,
pub health_check: bool,
pub extras: HashMap<String, toml::Value>,
}
#[derive(Debug, Clone)]
pub struct RetryConfigResolved {
pub max: u32,
pub strategy: String,
pub base_ms: u64,
pub max_ms: u64,
pub step_ms: u64,
}
pub struct ConfigRepository {
raw: ConfigFile,
overrides: HashMap<String, HashMap<String, toml::Value>>,
}
impl ConfigRepository {
pub fn load(path: impl AsRef<Path>) -> std::io::Result<Self> {
let content = fs::read_to_string(path)?;
let raw: ConfigFile = toml::from_str(&content)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
Ok(ConfigRepository {
raw,
overrides: HashMap::new(),
})
}
pub fn parse(toml_str: &str) -> std::io::Result<Self> {
let raw: ConfigFile = toml::from_str(toml_str)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
Ok(ConfigRepository {
raw,
overrides: HashMap::new(),
})
}
pub fn get_device(&self, id: &str) -> Option<DeviceConfig> {
let raw = self.raw.devices.get(id)?;
let overrides = self.overrides.get(id);
let timeout_ms = overrides
.and_then(|o| o.get("timeout_ms"))
.and_then(|v| v.as_integer())
.map(|v| v as u64)
.unwrap_or(raw.timeout_ms.unwrap_or(self.raw.defaults.timeout_ms));
let retry = raw.retry.clone().unwrap_or(RetryConfigRaw {
max: self.raw.defaults.retry_max,
strategy: self.raw.defaults.retry_strategy.clone(),
base_ms: 100,
max_ms: 5000,
step_ms: 50,
});
Some(DeviceConfig {
protocol: raw.protocol.clone(),
variant: raw.variant.clone(),
host: raw.host.clone(),
port: raw.port,
serial_port: raw.serial_port.clone(),
baud_rate: raw.baud_rate,
timeout_ms,
unit_id: overrides
.and_then(|o| o.get("unit_id"))
.and_then(|v| v.as_integer())
.map(|v| v as u16)
.unwrap_or(raw.unit_id.unwrap_or(1)),
retry: RetryConfigResolved {
max: retry.max,
strategy: retry.strategy,
base_ms: retry.base_ms,
max_ms: retry.max_ms,
step_ms: retry.step_ms,
},
connection_strategy: raw
.connection_strategy
.clone()
.unwrap_or(ConnectionStrategyConfig::Persistent),
health_check: raw.health_check.unwrap_or(true),
extras: raw.extras.clone(),
})
}
pub fn device_ids(&self) -> Vec<String> {
self.raw.devices.keys().cloned().collect()
}
pub fn defaults(&self) -> &DefaultsConfig {
&self.raw.defaults
}
pub fn set_override(&mut self, device_id: &str, key: &str, value: toml::Value) {
self.overrides
.entry(device_id.to_string())
.or_default()
.insert(key.to_string(), value);
}
pub fn clear_overrides(&mut self, device_id: &str) {
self.overrides.remove(device_id);
}
}