use std::net::SocketAddr;
use std::sync::Arc;
use reqwest::dns::{Addrs, Name, Resolve, Resolving};
use super::dns_cache::DnsCacheService;
#[derive(Debug, Clone)]
pub struct Ipv4OnlyResolver {
dns_cache: Option<Arc<DnsCacheService>>,
}
impl Default for Ipv4OnlyResolver {
fn default() -> Self {
Self::new()
}
}
impl Ipv4OnlyResolver {
pub fn new() -> Self {
Self { dns_cache: None }
}
pub fn with_cache(dns_cache: Arc<DnsCacheService>) -> Self {
Self {
dns_cache: Some(dns_cache),
}
}
}
impl Resolve for Ipv4OnlyResolver {
fn resolve(&self, name: Name) -> Resolving {
let host = name.as_str().to_string();
let cache = self.dns_cache.clone();
Box::pin(async move {
if let Some(cache) = cache {
match cache.lookup_host(&host, 0).await {
Ok(ips) => {
let ipv4_addrs: Vec<SocketAddr> = ips
.into_iter()
.filter(|ip| ip.is_ipv4())
.map(|ip| SocketAddr::new(ip, 0))
.collect();
log::debug!(
"Ipv4OnlyResolver resolved {} -> {} IPv4 addrs (cached)",
host,
ipv4_addrs.len()
);
return Ok(Box::new(ipv4_addrs.into_iter()) as Addrs);
}
Err(e) => {
log::warn!(
"DNS cache lookup failed for {}: {}, falling back to system DNS",
host,
e
);
}
}
}
let lookup = format!("{}:0", host);
let resolved = tokio::net::lookup_host(lookup)
.await
.map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?;
let ipv4_addrs: Vec<SocketAddr> = resolved.filter(|a| a.is_ipv4()).collect();
log::debug!(
"Ipv4OnlyResolver resolved {} -> {} IPv4 addrs",
host,
ipv4_addrs.len()
);
Ok(Box::new(ipv4_addrs.into_iter()) as Addrs)
})
}
}
pub fn create_ipv4_only_resolver() -> Arc<dyn Resolve> {
Arc::new(Ipv4OnlyResolver::new())
}
pub fn create_ipv4_only_resolver_with_cache(dns_cache: Arc<DnsCacheService>) -> Arc<dyn Resolve> {
Arc::new(Ipv4OnlyResolver::with_cache(dns_cache))
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6};
use std::str::FromStr;
#[test]
fn test_ipv4_only_resolver_creation() {
let _resolver = Ipv4OnlyResolver::new();
let _arc = create_ipv4_only_resolver();
}
#[test]
fn test_ipv4_only_resolver_with_cache_creation() {
let rt = tokio::runtime::Runtime::new().unwrap();
let dns_cache: Arc<DnsCacheService> = rt.block_on(async {
let cache = Arc::new(
oxcache::Cache::builder()
.capacity(100)
.ttl(std::time::Duration::from_secs(300))
.build()
.await
.unwrap(),
);
Arc::new(DnsCacheService::new(cache, 300).unwrap())
});
let _resolver = Ipv4OnlyResolver::with_cache(dns_cache.clone());
let _arc = create_ipv4_only_resolver_with_cache(dns_cache);
}
#[test]
fn test_filter_ipv6_addresses() {
let addrs: Vec<SocketAddr> = vec![
SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 80)),
SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::LOCALHOST, 80, 0, 0)),
SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(1, 2, 3, 4), 443)),
];
let ipv4_only: Vec<SocketAddr> = addrs.into_iter().filter(|a| a.is_ipv4()).collect();
assert_eq!(ipv4_only.len(), 2);
assert!(ipv4_only.iter().all(|a| a.is_ipv4()));
}
#[tokio::test]
async fn test_resolve_ipv4_only_without_cache() {
let resolver = Ipv4OnlyResolver::new();
let name = Name::from_str("example.com").unwrap();
let result = resolver.resolve(name).await;
if let Ok(addrs) = result {
let collected: Vec<_> = addrs.collect();
if !collected.is_empty() {
assert!(
collected.iter().all(|a| a.is_ipv4()),
"All addresses should be IPv4, got: {:?}",
collected
);
}
}
}
#[tokio::test]
async fn test_resolve_ipv4_only_with_cache() {
let cache = Arc::new(
oxcache::Cache::builder()
.capacity(100)
.ttl(std::time::Duration::from_secs(300))
.build()
.await
.unwrap(),
);
let dns_cache = Arc::new(DnsCacheService::new(cache, 300).unwrap());
let test_ip: std::net::IpAddr = "203.0.113.5".parse().unwrap();
dns_cache.set("example.com", 0, vec![test_ip], 300).await;
let resolver = Ipv4OnlyResolver::with_cache(dns_cache);
let name = Name::from_str("example.com").unwrap();
let result = resolver.resolve(name).await;
assert!(result.is_ok(), "resolve should succeed via cache");
let addrs: Vec<_> = result.unwrap().collect();
assert_eq!(addrs.len(), 1);
assert!(addrs[0].is_ipv4());
assert_eq!(addrs[0].ip(), test_ip);
}
#[tokio::test]
async fn test_resolve_falls_back_to_system_dns_on_cache_miss() {
let cache = Arc::new(
oxcache::Cache::builder()
.capacity(100)
.ttl(std::time::Duration::from_secs(300))
.build()
.await
.unwrap(),
);
let dns_cache = Arc::new(DnsCacheService::new(cache, 300).unwrap());
let resolver = Ipv4OnlyResolver::with_cache(dns_cache);
let name = Name::from_str("localhost").unwrap();
let result = resolver.resolve(name).await;
if let Ok(addrs) = result {
let collected: Vec<_> = addrs.collect();
if !collected.is_empty() {
assert!(
collected.iter().all(|a| a.is_ipv4()),
"All addresses should be IPv4, got: {:?}",
collected
);
}
}
}
}