use crate::error::Error;
use crate::providers::ConfigProvider;
use crate::types::{ConfigUnit, ResolvedValue, ResolverNode};
use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
#[derive(Default)]
pub struct ConfigRegistry {
providers: HashMap<String, Box<dyn ConfigProvider>>,
}
impl ConfigRegistry {
pub fn new() -> Self {
Self {
providers: HashMap::new(),
}
}
pub fn register(&mut self, provider: Box<dyn ConfigProvider>) {
self.providers.insert(provider.name().to_string(), provider);
}
pub async fn resolve<T: ConfigUnit>(&self, spec: &str) -> Result<T, Error> {
let node = self.parse(spec)?;
let val = self.resolve_node(&node).await?;
T::from_resolved(val).ok_or(Error::TypeMismatch)
}
pub fn resolve_sync<T: ConfigUnit>(&self, spec: &str) -> Result<T, Error> {
let node = self.parse(spec)?;
let val = self.resolve_node_sync(&node)?;
T::from_resolved(val).ok_or(Error::TypeMismatch)
}
pub fn parse(&self, spec: &str) -> Result<ResolverNode, Error> {
if spec.starts_with("CALC(") && spec.ends_with(')') {
let inner = &spec[5..spec.len() - 1];
if let Some(plus_idx) = inner.find('+') {
let base_str = inner[..plus_idx].trim();
let offset_str = inner[plus_idx + 1..].trim();
let base = self.parse(base_str)?;
let offset = offset_str
.parse::<i64>()
.map_err(|e| Error::ParseError(e.to_string()))?;
return Ok(ResolverNode::Calc {
base: Box::new(base),
offset,
});
}
}
if let Some(colon_idx) = spec.find(':') {
if !spec.contains('[') {
let ip_str = &spec[..colon_idx];
let port_str = &spec[colon_idx + 1..];
let ip = self.parse(ip_str)?;
let port = self.parse(port_str)?;
return Ok(ResolverNode::Socket {
ip: Box::new(ip),
port: Box::new(port),
});
}
}
if let Ok(ip) = spec.parse::<IpAddr>() {
return Ok(ResolverNode::Static(ResolvedValue::Ip(ip)));
}
if let Ok(u) = spec.parse::<u32>() {
return Ok(ResolverNode::Static(ResolvedValue::U32(u)));
}
if let Ok(u) = spec.parse::<u64>() {
return Ok(ResolverNode::Static(ResolvedValue::U64(u)));
}
if let Ok(sa) = spec.parse::<SocketAddr>() {
return Ok(ResolverNode::Static(ResolvedValue::SocketAddr(sa)));
}
Ok(ResolverNode::Provider(spec.to_string()))
}
#[async_recursion::async_recursion]
pub async fn resolve_node(&self, node: &ResolverNode) -> Result<ResolvedValue, Error> {
match node {
ResolverNode::Static(v) => Ok(v.clone()),
ResolverNode::Provider(name) => {
if let Some(provider) = self.providers.get(name) {
provider.resolve().await
} else {
Err(Error::ProviderNotFound(name.clone()))
}
}
ResolverNode::Socket { ip, port } => {
let ip_val = self
.resolve_node(ip)
.await?
.as_ip()
.ok_or(Error::TypeMismatch)?;
let port_val = socket_port(
self.resolve_node(port)
.await?
.as_u32()
.ok_or(Error::TypeMismatch)?,
)?;
Ok(ResolvedValue::SocketAddr(SocketAddr::new(ip_val, port_val)))
}
ResolverNode::Calc { base, offset } => {
let base_val = self
.resolve_node(base)
.await?
.as_u64()
.ok_or(Error::TypeMismatch)?;
let final_val = (base_val as i64 + offset) as u64;
Ok(ResolvedValue::U64(final_val))
}
}
}
pub fn resolve_node_sync(&self, node: &ResolverNode) -> Result<ResolvedValue, Error> {
match node {
ResolverNode::Static(v) => Ok(v.clone()),
ResolverNode::Provider(name) => {
if let Some(provider) = self.providers.get(name) {
provider.resolve_sync()
} else {
Err(Error::ProviderNotFound(name.clone()))
}
}
ResolverNode::Socket { ip, port } => {
let ip_val = self
.resolve_node_sync(ip)?
.as_ip()
.ok_or(Error::TypeMismatch)?;
let port_val = socket_port(
self.resolve_node_sync(port)?
.as_u32()
.ok_or(Error::TypeMismatch)?,
)?;
Ok(ResolvedValue::SocketAddr(SocketAddr::new(ip_val, port_val)))
}
ResolverNode::Calc { base, offset } => {
let base_val = self
.resolve_node_sync(base)?
.as_u64()
.ok_or(Error::TypeMismatch)?;
let final_val = (base_val as i64 + offset) as u64;
Ok(ResolvedValue::U64(final_val))
}
}
}
}
fn socket_port(value: u32) -> Result<u16, Error> {
u16::try_from(value).map_err(|_| {
Error::ParseError(format!(
"socket port {value} is outside the valid range 0..=65535"
))
})
}