config-resolver 0.1.0

A modular configuration resolver for auto-detecting and resolving runtime values (IPs, ports, peer IDs)
Documentation
//! # Config Resolver
//!
//! A modular configuration resolver for auto-detecting and resolving configuration values
//! (IP addresses, ports, peer IDs) at runtime.
//!
//! It supports static values, dynamic lookups from multiple cloud provider metadata APIs,
//! socket address parsing, and mathematical calculations on IP addresses to generate unique IDs.

pub mod error;
pub mod providers;
pub mod registry;
pub mod types;

pub use error::Error;
pub use providers::*;
pub use registry::ConfigRegistry;
pub use types::*;

/// Creates a new `ConfigRegistry` with all standard providers enabled.
///
/// Providers registered by default (depending on crate features):
/// - `DO_PUBLIC_IP`: DigitalOcean Public IP Address
/// - `DO_PRIVATE_IP`: DigitalOcean Private IP Address
/// - `AWS_PUBLIC_IP`: AWS Public IP Address
/// - `AWS_PRIVATE_IP`: AWS Private IP Address
/// - `IPIFY`: Public IP Address via ipify.org API
pub fn create_default_registry() -> ConfigRegistry {
    let mut registry = ConfigRegistry::default();

    #[cfg(feature = "digital-ocean")]
    {
        registry.register(Box::new(providers::DOPublicIpProvider));
        registry.register(Box::new(providers::DOPrivateIpProvider));
    }

    #[cfg(feature = "ipify")]
    {
        registry.register(Box::new(providers::IpifyProvider));
    }

    #[cfg(feature = "aws")]
    {
        registry.register(Box::new(providers::AWSPublicIpProvider));
        registry.register(Box::new(providers::AWSPrivateIpProvider));
    }

    registry
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::ResolvedValue;
    use async_trait::async_trait;
    use std::net::IpAddr;
    use std::str::FromStr;

    struct MockProvider(&'static str, IpAddr);

    #[async_trait]
    impl ConfigProvider for MockProvider {
        fn name(&self) -> &str {
            self.0
        }
        async fn resolve(&self) -> Result<ResolvedValue, Error> {
            Ok(ResolvedValue::Ip(self.1))
        }
    }

    #[tokio::test]
    async fn test_resolve_static_ip() {
        let registry = ConfigRegistry::default();
        let ip: IpAddr = registry.resolve("127.0.0.1").await.unwrap();
        assert_eq!(ip, IpAddr::from_str("127.0.0.1").unwrap());
    }

    #[tokio::test]
    async fn test_resolve_provider_ip() {
        let mut registry = ConfigRegistry::default();
        registry.register(Box::new(MockProvider(
            "DO_PUBLIC_IP",
            "1.1.1.1".parse().unwrap(),
        )));
        let ip: IpAddr = registry.resolve("DO_PUBLIC_IP").await.unwrap();
        assert_eq!(ip, IpAddr::from_str("1.1.1.1").unwrap());
    }

    #[tokio::test]
    async fn test_resolve_socket_addr() {
        let mut registry = ConfigRegistry::default();
        registry.register(Box::new(MockProvider(
            "DO_PUBLIC_IP",
            "1.1.1.1".parse().unwrap(),
        )));
        let addr: std::net::SocketAddr = registry.resolve("DO_PUBLIC_IP:22222").await.unwrap();
        assert_eq!(addr, "1.1.1.1:22222".parse().unwrap());
    }

    #[tokio::test]
    async fn test_resolve_calc() {
        let mut registry = ConfigRegistry::default();
        registry.register(Box::new(MockProvider(
            "DO_PUBLIC_IP",
            "1.1.1.1".parse().unwrap(),
        )));
        // 1.1.1.1 is 0x01010101 = 16843009
        // 16843009 + 10000 = 16853009
        let val: u64 = registry.resolve("CALC(DO_PUBLIC_IP+10000)").await.unwrap();
        assert_eq!(val, 16843009 + 10000);
    }
}