use std::default::Default; use std::path::{PathBuf}; use std::collections::HashMap; use serde::{Serialize, Deserialize}; mod dhall; pub use dhall::read_config_file as read; use crate::authorization::permissions::{PrivilegesBuf}; use crate::authorization::roles::Role; use crate::capnp::{Listen, TlsListen}; use crate::logging::LogConfig; #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] /// A description of a machine /// /// This is the struct that a machine is serialized to/from. /// Combining this with the actual state of the system will return a machine pub struct MachineDescription { /// The name of the machine. Doesn't need to be unique but is what humans will be presented. pub name: String, /// An optional description of the Machine. #[serde(default, skip_serializing_if = "Option::is_none", deserialize_with = "deser_option")] pub description: Option, #[serde(default, skip_serializing_if = "Option::is_none", deserialize_with = "deser_option")] pub wiki: Option, #[serde(default, skip_serializing_if = "Option::is_none", deserialize_with = "deser_option")] pub category: Option, /// The permission required #[serde(flatten)] pub privs: PrivilegesBuf, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Config { /// A list of address/port pairs to listen on. pub listens: Vec, /// Machine descriptions to load pub machines: HashMap, /// Actors to load and their configuration options pub actors: HashMap, /// Initiators to load and their configuration options pub initiators: HashMap, pub mqtt_url: String, pub actor_connections: Vec<(String, String)>, pub init_connections: Vec<(String, String)>, pub db_path: PathBuf, pub auditlog_path: PathBuf, pub roles: HashMap, #[serde(flatten)] pub tlsconfig: TlsListen, #[serde(default, skip_serializing_if = "Option::is_none")] pub tlskeylog: Option, #[serde(default, skip)] pub verbosity: isize, #[serde(default, skip)] pub logging: LogConfig, } impl Config { pub fn is_quiet(&self) -> bool { self.verbosity < 0 } } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ModuleConfig { pub module: String, pub params: HashMap } pub(crate) fn deser_option<'de, D, T>(d: D) -> std::result::Result, D::Error> where D: serde::Deserializer<'de>, T: serde::Deserialize<'de>, { Ok(T::deserialize(d).ok()) } impl Default for Config { fn default() -> Self { let mut actors: HashMap:: = HashMap::new(); let mut initiators: HashMap:: = HashMap::new(); let machines = HashMap::new(); actors.insert("Actor".to_string(), ModuleConfig { module: "Shelly".to_string(), params: HashMap::new(), }); initiators.insert("Initiator".to_string(), ModuleConfig { module: "TCP-Listen".to_string(), params: HashMap::new(), }); Config { listens: vec![ Listen { address: "127.0.0.1".to_string(), port: None, } ], actors, initiators, machines, mqtt_url: "tcp://localhost:1883".to_string(), actor_connections: vec![ ("Testmachine".to_string(), "Actor".to_string()), ], init_connections: vec![ ("Initiator".to_string(), "Testmachine".to_string()), ], db_path: PathBuf::from("/run/bffh/database"), auditlog_path: PathBuf::from("/var/log/bffh/audit.log"), roles: HashMap::new(), tlsconfig: TlsListen { certfile: PathBuf::from("./bffh.crt"), keyfile: PathBuf::from("./bffh.key"), .. Default::default() }, tlskeylog: None, verbosity: 0, logging: LogConfig::default(), } } }