Skip to main content

config_resolver/
lib.rs

1//! # Config Resolver
2//!
3//! A modular configuration resolver for auto-detecting and resolving configuration values
4//! (IP addresses, ports, peer IDs) at runtime.
5//!
6//! It supports static values, dynamic lookups from multiple cloud provider metadata APIs,
7//! socket address parsing, and mathematical calculations on IP addresses to generate unique IDs.
8
9pub mod error;
10pub mod providers;
11pub mod registry;
12pub mod types;
13
14pub use error::Error;
15pub use providers::*;
16pub use registry::ConfigRegistry;
17pub use types::*;
18
19/// Creates a new `ConfigRegistry` with all standard providers enabled.
20///
21/// Providers registered by default (depending on crate features):
22/// - `DO_PUBLIC_IP`: DigitalOcean Public IP Address
23/// - `DO_PRIVATE_IP`: DigitalOcean Private IP Address
24/// - `AWS_PUBLIC_IP`: AWS Public IP Address
25/// - `AWS_PRIVATE_IP`: AWS Private IP Address
26/// - `IPIFY`: Public IP Address via ipify.org API
27pub fn create_default_registry() -> ConfigRegistry {
28    let mut registry = ConfigRegistry::default();
29
30    #[cfg(feature = "digital-ocean")]
31    {
32        registry.register(Box::new(providers::DOPublicIpProvider));
33        registry.register(Box::new(providers::DOPrivateIpProvider));
34    }
35
36    #[cfg(feature = "ipify")]
37    {
38        registry.register(Box::new(providers::IpifyProvider));
39    }
40
41    #[cfg(feature = "aws")]
42    {
43        registry.register(Box::new(providers::AWSPublicIpProvider));
44        registry.register(Box::new(providers::AWSPrivateIpProvider));
45    }
46
47    registry
48}
49
50#[cfg(test)]
51mod tests {
52    use super::*;
53    use crate::types::ResolvedValue;
54    use async_trait::async_trait;
55    use std::net::IpAddr;
56    use std::str::FromStr;
57
58    struct MockProvider(&'static str, IpAddr);
59
60    #[async_trait]
61    impl ConfigProvider for MockProvider {
62        fn name(&self) -> &str {
63            self.0
64        }
65        async fn resolve(&self) -> Result<ResolvedValue, Error> {
66            Ok(ResolvedValue::Ip(self.1))
67        }
68    }
69
70    #[tokio::test]
71    async fn test_resolve_static_ip() {
72        let registry = ConfigRegistry::default();
73        let ip: IpAddr = registry.resolve("127.0.0.1").await.unwrap();
74        assert_eq!(ip, IpAddr::from_str("127.0.0.1").unwrap());
75    }
76
77    #[tokio::test]
78    async fn test_resolve_provider_ip() {
79        let mut registry = ConfigRegistry::default();
80        registry.register(Box::new(MockProvider(
81            "DO_PUBLIC_IP",
82            "1.1.1.1".parse().unwrap(),
83        )));
84        let ip: IpAddr = registry.resolve("DO_PUBLIC_IP").await.unwrap();
85        assert_eq!(ip, IpAddr::from_str("1.1.1.1").unwrap());
86    }
87
88    #[tokio::test]
89    async fn test_resolve_socket_addr() {
90        let mut registry = ConfigRegistry::default();
91        registry.register(Box::new(MockProvider(
92            "DO_PUBLIC_IP",
93            "1.1.1.1".parse().unwrap(),
94        )));
95        let addr: std::net::SocketAddr = registry.resolve("DO_PUBLIC_IP:22222").await.unwrap();
96        assert_eq!(addr, "1.1.1.1:22222".parse().unwrap());
97    }
98
99    #[tokio::test]
100    async fn test_resolve_calc() {
101        let mut registry = ConfigRegistry::default();
102        registry.register(Box::new(MockProvider(
103            "DO_PUBLIC_IP",
104            "1.1.1.1".parse().unwrap(),
105        )));
106        // 1.1.1.1 is 0x01010101 = 16843009
107        // 16843009 + 10000 = 16853009
108        let val: u64 = registry.resolve("CALC(DO_PUBLIC_IP+10000)").await.unwrap();
109        assert_eq!(val, 16843009 + 10000);
110    }
111}