config-resolver 0.2.1

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(feature = "clap")]
pub mod clap_resolver;

#[cfg(feature = "clap")]
pub use crate::clap_resolver::*;

#[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))
        }
        fn resolve_sync(&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_socket_addr_rejects_out_of_range_port() {
        let registry = ConfigRegistry::default();

        let error = registry
            .resolve::<std::net::SocketAddr>("127.0.0.1:70000")
            .await
            .unwrap_err();

        assert!(error.to_string().contains("70000"));
    }

    #[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);
    }

    #[test]
    fn test_resolve_sync() {
        let mut registry = ConfigRegistry::default();
        registry.register(Box::new(MockProvider(
            "DO_PUBLIC_IP",
            "1.1.1.1".parse().unwrap(),
        )));

        // Static IP address synchronously
        let ip: IpAddr = registry.resolve_sync("127.0.0.1").unwrap();
        assert_eq!(ip, "127.0.0.1".parse::<IpAddr>().unwrap());

        // Provider IP address synchronously
        let ip: IpAddr = registry.resolve_sync("DO_PUBLIC_IP").unwrap();
        assert_eq!(ip, "1.1.1.1".parse::<IpAddr>().unwrap());

        // Calculation synchronously
        let val: u64 = registry.resolve_sync("CALC(DO_PUBLIC_IP+10000)").unwrap();
        assert_eq!(val, 16843009 + 10000);

        // Socket address synchronously
        let addr: std::net::SocketAddr = registry.resolve_sync("DO_PUBLIC_IP:3000").unwrap();
        assert_eq!(addr, "1.1.1.1:3000".parse().unwrap());

        // Socket port validation synchronously
        let error = registry
            .resolve_sync::<std::net::SocketAddr>("127.0.0.1:70000")
            .unwrap_err();
        assert!(error.to_string().contains("70000"));
    }

    #[test]
    #[cfg(feature = "clap")]
    fn test_clap_value_parser() {
        use clap::Parser;

        let mut registry = ConfigRegistry::default();
        registry.register(Box::new(MockProvider(
            "DO_PUBLIC_IP",
            "1.1.1.1".parse().unwrap(),
        )));
        let _ = init_global_registry(registry);

        #[derive(Debug, Parser)]
        struct TestArgs {
            #[arg(long, value_parser = clap_value_parser::<IpAddr>)]
            ip: IpAddr,

            #[arg(long, value_parser = clap_value_parser::<std::net::SocketAddr>)]
            socket: std::net::SocketAddr,

            #[arg(long, value_parser = clap_value_parser::<u32>)]
            port: u32,
        }

        let args = TestArgs::parse_from([
            "test_app",
            "--ip",
            "DO_PUBLIC_IP",
            "--socket",
            "DO_PUBLIC_IP:3000",
            "--port",
            "CALC(127.0.0.1+100)",
        ]);

        assert_eq!(args.ip, "1.1.1.1".parse::<IpAddr>().unwrap());
        assert_eq!(args.socket, "1.1.1.1:3000".parse().unwrap());
        assert_eq!(args.port, 2130706533);

        let error = TestArgs::try_parse_from([
            "test_app",
            "--ip",
            "DO_PUBLIC_IP",
            "--socket",
            "127.0.0.1:70000",
            "--port",
            "1",
        ])
        .unwrap_err();
        assert!(error.to_string().contains("70000"));
    }
}