pub mod error;
pub mod providers;
pub mod registry;
pub mod types;
pub use error::Error;
pub use providers::*;
pub use registry::ConfigRegistry;
pub use types::*;
pub fn create_default_registry() -> ConfigRegistry {
let mut registry = ConfigRegistry::default();
#[cfg(feature = "digital-ocean")]
{
registry.register(Box::new(providers::DOPublicIpProvider));
registry.register(Box::new(providers::DOPrivateIpProvider));
}
#[cfg(feature = "ipify")]
{
registry.register(Box::new(providers::IpifyProvider));
}
#[cfg(feature = "aws")]
{
registry.register(Box::new(providers::AWSPublicIpProvider));
registry.register(Box::new(providers::AWSPrivateIpProvider));
}
registry
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::ResolvedValue;
use async_trait::async_trait;
use std::net::IpAddr;
use std::str::FromStr;
struct MockProvider(&'static str, IpAddr);
#[async_trait]
impl ConfigProvider for MockProvider {
fn name(&self) -> &str {
self.0
}
async fn resolve(&self) -> Result<ResolvedValue, Error> {
Ok(ResolvedValue::Ip(self.1))
}
}
#[tokio::test]
async fn test_resolve_static_ip() {
let registry = ConfigRegistry::default();
let ip: IpAddr = registry.resolve("127.0.0.1").await.unwrap();
assert_eq!(ip, IpAddr::from_str("127.0.0.1").unwrap());
}
#[tokio::test]
async fn test_resolve_provider_ip() {
let mut registry = ConfigRegistry::default();
registry.register(Box::new(MockProvider(
"DO_PUBLIC_IP",
"1.1.1.1".parse().unwrap(),
)));
let ip: IpAddr = registry.resolve("DO_PUBLIC_IP").await.unwrap();
assert_eq!(ip, IpAddr::from_str("1.1.1.1").unwrap());
}
#[tokio::test]
async fn test_resolve_socket_addr() {
let mut registry = ConfigRegistry::default();
registry.register(Box::new(MockProvider(
"DO_PUBLIC_IP",
"1.1.1.1".parse().unwrap(),
)));
let addr: std::net::SocketAddr = registry.resolve("DO_PUBLIC_IP:22222").await.unwrap();
assert_eq!(addr, "1.1.1.1:22222".parse().unwrap());
}
#[tokio::test]
async fn test_resolve_calc() {
let mut registry = ConfigRegistry::default();
registry.register(Box::new(MockProvider(
"DO_PUBLIC_IP",
"1.1.1.1".parse().unwrap(),
)));
let val: u64 = registry.resolve("CALC(DO_PUBLIC_IP+10000)").await.unwrap();
assert_eq!(val, 16843009 + 10000);
}
}