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