1pub 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
19pub 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 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 let ip: IpAddr = registry.resolve_sync("127.0.0.1").unwrap();
143 assert_eq!(ip, "127.0.0.1".parse::<IpAddr>().unwrap());
144
145 let ip: IpAddr = registry.resolve_sync("DO_PUBLIC_IP").unwrap();
147 assert_eq!(ip, "1.1.1.1".parse::<IpAddr>().unwrap());
148
149 let val: u64 = registry.resolve_sync("CALC(DO_PUBLIC_IP+10000)").unwrap();
151 assert_eq!(val, 16843009 + 10000);
152
153 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 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}