config-resolver 0.2.1

A modular configuration resolver for auto-detecting and resolving runtime values (IPs, ports, peer IDs)
Documentation
use crate::error::Error;
use crate::providers::ConfigProvider;
use crate::types::{ConfigUnit, ResolvedValue, ResolverNode};
use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};

/// A registry that holds config providers and resolves configuration specifications.
#[derive(Default)]
pub struct ConfigRegistry {
    providers: HashMap<String, Box<dyn ConfigProvider>>,
}

impl ConfigRegistry {
    /// Creates a new, empty registry.
    pub fn new() -> Self {
        Self {
            providers: HashMap::new(),
        }
    }

    /// Registers a provider with the registry.
    pub fn register(&mut self, provider: Box<dyn ConfigProvider>) {
        self.providers.insert(provider.name().to_string(), provider);
    }

    /// Resolves a configuration specification string into the target type `T`.
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - The specification cannot be parsed.
    /// - A referenced provider is not registered.
    /// - The provider fails to resolve.
    /// - The resolved type cannot be converted into `T`.
    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)
    }

    /// Resolves a configuration specification string into the target type `T` synchronously.
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - The specification cannot be parsed.
    /// - A referenced provider is not registered or does not support sync resolution.
    /// - The provider fails to resolve.
    /// - The resolved type cannot be converted into `T`.
    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)
    }

    /// Parses a configuration specification string into an AST node.
    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('[') {
                // Avoid IPv6 colons if they don't have brackets
                let ip_str = &spec[..colon_idx];
                let port_str = &spec[colon_idx + 1..];
                // Check if ip_str looks like a provider or an IP
                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()))
    }

    /// Resolves an AST node into a `ResolvedValue`.
    #[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))
            }
        }
    }

    /// Resolves an AST node into a `ResolvedValue` synchronously.
    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"
        ))
    })
}