use std::path::{Path, PathBuf};
use serde::Deserialize;
#[derive(Debug, Clone, Deserialize)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct Config {
pub serial: SerialConfig,
#[serde(default)]
pub mqtt: MqttConfig,
#[serde(default)]
pub homeassistant: HomeAssistantConfig,
#[serde(default)]
pub network: NetworkConfig,
#[serde(default)]
pub join: JoinConfig,
#[serde(default)]
pub data: DataConfig,
#[serde(default)]
pub ota: OtaConfig,
}
#[derive(Debug, Clone, Default, Deserialize)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct OtaConfig {
pub dir: Option<PathBuf>,
}
#[derive(Debug, Clone, Deserialize)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct SerialConfig {
pub port: String,
#[serde(default = "default_baud")]
pub baud: u32,
#[serde(default)]
pub flow_control: FlowControl,
#[serde(default)]
pub adapter: AdapterChoice,
}
#[derive(Debug, Clone, Copy, Default, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(rename_all = "lowercase")]
pub enum AdapterChoice {
#[default]
Auto,
Ezsp,
Znp,
Deconz,
}
#[derive(Debug, Clone, Copy, Default, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(rename_all = "lowercase")]
pub enum FlowControl {
#[default]
None,
Hardware,
Software,
}
fn default_baud() -> u32 {
115_200
}
#[derive(Debug, Clone, Deserialize)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(deny_unknown_fields, default)]
pub struct MqttConfig {
pub host: String,
pub port: u16,
pub username: Option<String>,
pub password_file: Option<PathBuf>,
pub client_id: String,
pub base_topic: String,
pub keepalive: u64,
pub retain_state: bool,
}
impl Default for MqttConfig {
fn default() -> Self {
MqttConfig {
host: "localhost".into(),
port: 1883,
username: None,
password_file: None,
client_id: "zigbee-bridge".into(),
base_topic: "zigbee".into(),
keepalive: 30,
retain_state: true,
}
}
}
#[derive(Debug, Clone, Deserialize)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(deny_unknown_fields, default)]
pub struct HomeAssistantConfig {
pub enabled: bool,
pub discovery_prefix: String,
pub status_topic: String,
}
impl Default for HomeAssistantConfig {
fn default() -> Self {
HomeAssistantConfig {
enabled: true,
discovery_prefix: "homeassistant".into(),
status_topic: "homeassistant/status".into(),
}
}
}
#[derive(Debug, Clone, Deserialize)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(deny_unknown_fields, default)]
pub struct NetworkConfig {
pub channel: u8,
pub tx_power: Option<i8>,
pub replace_other: bool,
}
impl Default for NetworkConfig {
fn default() -> Self {
NetworkConfig {
channel: 15,
tx_power: None,
replace_other: false,
}
}
}
#[derive(Debug, Clone, Deserialize)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(deny_unknown_fields, default)]
pub struct JoinConfig {
pub install_code_only: bool,
pub allow_legacy: bool,
}
impl Default for JoinConfig {
fn default() -> Self {
JoinConfig {
install_code_only: false,
allow_legacy: true,
}
}
}
#[derive(Debug, Clone, Deserialize)]
#[cfg_attr(feature = "schema", derive(serde::Serialize, schemars::JsonSchema))]
#[serde(deny_unknown_fields, default)]
pub struct DataConfig {
pub dir: PathBuf,
}
impl Default for DataConfig {
fn default() -> Self {
DataConfig {
dir: PathBuf::from("/var/lib/zigbee-bridge"),
}
}
}
#[derive(Debug, thiserror::Error)]
pub enum ConfigError {
#[error("reading {path}: {source}")]
Read {
path: PathBuf,
source: std::io::Error,
},
#[error("{path}: {message}")]
Parse {
path: PathBuf,
message: String,
},
}
impl Config {
pub fn from_toml(text: &str) -> Result<Config, String> {
let config: Config = toml::from_str(text).map_err(|e| e.to_string())?;
if !(11..=26).contains(&config.network.channel) {
return Err(format!(
"network.channel {} is not 11 to 26",
config.network.channel
));
}
if config.mqtt.base_topic.is_empty() || config.mqtt.base_topic.contains(['+', '#']) {
return Err("mqtt.base_topic must be a plain topic prefix".into());
}
Ok(config)
}
pub fn load(path: &Path) -> Result<Config, ConfigError> {
let text = std::fs::read_to_string(path).map_err(|source| ConfigError::Read {
path: path.into(),
source,
})?;
Config::from_toml(&text).map_err(|message| ConfigError::Parse {
path: path.into(),
message,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn minimal_and_full_configs_parse() {
let c = Config::from_toml("[serial]\nport = \"/dev/ttyUSB0\"\n").unwrap();
assert_eq!(c.serial.baud, 115_200);
assert_eq!(c.mqtt.base_topic, "zigbee");
assert!(c.homeassistant.enabled);
let c = Config::from_toml(
"[serial]\nport = \"tcp://10.0.0.5:6638\"\nflow_control = \"hardware\"\n[mqtt]\nhost = \"broker\"\nusername = \"z\"\n[network]\nchannel = 25\n[join]\ninstall_code_only = true\n[data]\ndir = \"/tmp/z\"\n",
)
.unwrap();
assert_eq!(c.serial.flow_control, FlowControl::Hardware);
assert_eq!(c.network.channel, 25);
assert!(Config::from_toml("[serial]\nport = \"x\"\n[network]\nchannel = 5\n").is_err());
assert!(Config::from_toml("[serial]\nport = \"x\"\nbogus = 1\n").is_err());
}
}