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(feature = "clap")]
51pub mod clap_resolver;
52
53#[cfg(feature = "clap")]
54pub use crate::clap_resolver::*;
55
56#[cfg(test)]
57mod tests {
58    use super::*;
59    use crate::types::ResolvedValue;
60    use async_trait::async_trait;
61    use std::net::IpAddr;
62    use std::str::FromStr;
63
64    struct MockProvider(&'static str, IpAddr);
65
66    #[async_trait]
67    impl ConfigProvider for MockProvider {
68        fn name(&self) -> &str {
69            self.0
70        }
71        async fn resolve(&self) -> Result<ResolvedValue, Error> {
72            Ok(ResolvedValue::Ip(self.1))
73        }
74        fn resolve_sync(&self) -> Result<ResolvedValue, Error> {
75            Ok(ResolvedValue::Ip(self.1))
76        }
77    }
78
79    #[tokio::test]
80    async fn test_resolve_static_ip() {
81        let registry = ConfigRegistry::default();
82        let ip: IpAddr = registry.resolve("127.0.0.1").await.unwrap();
83        assert_eq!(ip, IpAddr::from_str("127.0.0.1").unwrap());
84    }
85
86    #[tokio::test]
87    async fn test_resolve_provider_ip() {
88        let mut registry = ConfigRegistry::default();
89        registry.register(Box::new(MockProvider(
90            "DO_PUBLIC_IP",
91            "1.1.1.1".parse().unwrap(),
92        )));
93        let ip: IpAddr = registry.resolve("DO_PUBLIC_IP").await.unwrap();
94        assert_eq!(ip, IpAddr::from_str("1.1.1.1").unwrap());
95    }
96
97    #[tokio::test]
98    async fn test_resolve_socket_addr() {
99        let mut registry = ConfigRegistry::default();
100        registry.register(Box::new(MockProvider(
101            "DO_PUBLIC_IP",
102            "1.1.1.1".parse().unwrap(),
103        )));
104        let addr: std::net::SocketAddr = registry.resolve("DO_PUBLIC_IP:22222").await.unwrap();
105        assert_eq!(addr, "1.1.1.1:22222".parse().unwrap());
106    }
107
108    #[tokio::test]
109    async fn test_resolve_socket_addr_rejects_out_of_range_port() {
110        let registry = ConfigRegistry::default();
111
112        let error = registry
113            .resolve::<std::net::SocketAddr>("127.0.0.1:70000")
114            .await
115            .unwrap_err();
116
117        assert!(error.to_string().contains("70000"));
118    }
119
120    #[tokio::test]
121    async fn test_resolve_calc() {
122        let mut registry = ConfigRegistry::default();
123        registry.register(Box::new(MockProvider(
124            "DO_PUBLIC_IP",
125            "1.1.1.1".parse().unwrap(),
126        )));
127        // 1.1.1.1 is 0x01010101 = 16843009
128        // 16843009 + 10000 = 16853009
129        let val: u64 = registry.resolve("CALC(DO_PUBLIC_IP+10000)").await.unwrap();
130        assert_eq!(val, 16843009 + 10000);
131    }
132
133    #[test]
134    fn test_resolve_sync() {
135        let mut registry = ConfigRegistry::default();
136        registry.register(Box::new(MockProvider(
137            "DO_PUBLIC_IP",
138            "1.1.1.1".parse().unwrap(),
139        )));
140
141        // Static IP address synchronously
142        let ip: IpAddr = registry.resolve_sync("127.0.0.1").unwrap();
143        assert_eq!(ip, "127.0.0.1".parse::<IpAddr>().unwrap());
144
145        // Provider IP address synchronously
146        let ip: IpAddr = registry.resolve_sync("DO_PUBLIC_IP").unwrap();
147        assert_eq!(ip, "1.1.1.1".parse::<IpAddr>().unwrap());
148
149        // Calculation synchronously
150        let val: u64 = registry.resolve_sync("CALC(DO_PUBLIC_IP+10000)").unwrap();
151        assert_eq!(val, 16843009 + 10000);
152
153        // Socket address synchronously
154        let addr: std::net::SocketAddr = registry.resolve_sync("DO_PUBLIC_IP:3000").unwrap();
155        assert_eq!(addr, "1.1.1.1:3000".parse().unwrap());
156
157        // Socket port validation synchronously
158        let error = registry
159            .resolve_sync::<std::net::SocketAddr>("127.0.0.1:70000")
160            .unwrap_err();
161        assert!(error.to_string().contains("70000"));
162    }
163
164    #[test]
165    #[cfg(feature = "clap")]
166    fn test_clap_value_parser() {
167        use clap::Parser;
168
169        let mut registry = ConfigRegistry::default();
170        registry.register(Box::new(MockProvider(
171            "DO_PUBLIC_IP",
172            "1.1.1.1".parse().unwrap(),
173        )));
174        let _ = init_global_registry(registry);
175
176        #[derive(Debug, Parser)]
177        struct TestArgs {
178            #[arg(long, value_parser = clap_value_parser::<IpAddr>)]
179            ip: IpAddr,
180
181            #[arg(long, value_parser = clap_value_parser::<std::net::SocketAddr>)]
182            socket: std::net::SocketAddr,
183
184            #[arg(long, value_parser = clap_value_parser::<u32>)]
185            port: u32,
186        }
187
188        let args = TestArgs::parse_from([
189            "test_app",
190            "--ip",
191            "DO_PUBLIC_IP",
192            "--socket",
193            "DO_PUBLIC_IP:3000",
194            "--port",
195            "CALC(127.0.0.1+100)",
196        ]);
197
198        assert_eq!(args.ip, "1.1.1.1".parse::<IpAddr>().unwrap());
199        assert_eq!(args.socket, "1.1.1.1:3000".parse().unwrap());
200        assert_eq!(args.port, 2130706533);
201
202        let error = TestArgs::try_parse_from([
203            "test_app",
204            "--ip",
205            "DO_PUBLIC_IP",
206            "--socket",
207            "127.0.0.1:70000",
208            "--port",
209            "1",
210        ])
211        .unwrap_err();
212        assert!(error.to_string().contains("70000"));
213    }
214}