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
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 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 let ip: IpAddr = registry.resolve_sync("127.0.0.1").unwrap();
134 assert_eq!(ip, "127.0.0.1".parse::<IpAddr>().unwrap());
135
136 let ip: IpAddr = registry.resolve_sync("DO_PUBLIC_IP").unwrap();
138 assert_eq!(ip, "1.1.1.1".parse::<IpAddr>().unwrap());
139
140 let val: u64 = registry.resolve_sync("CALC(DO_PUBLIC_IP+10000)").unwrap();
142 assert_eq!(val, 16843009 + 10000);
143
144 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