74 lines
2.6 KiB
Rust
74 lines
2.6 KiB
Rust
use std::io;
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use futures::{future, Future};
|
|
use hyper::client::connect::dns as hyper_dns;
|
|
use trust_dns_resolver::AsyncResolver;
|
|
|
|
// If instead the type were just `AsyncResolver`, it breaks the default recursion limit
|
|
// for the compiler to determine if `reqwest::Client` is `Send`. This is because `AsyncResolver`
|
|
// has **a lot** of internal generic types that pushes us over the limit.
|
|
//
|
|
// "Erasing" the internal resolver type saves us from this limit.
|
|
type ErasedResolver = Box<Fn(hyper_dns::Name) -> ::trust_dns_resolver::BackgroundLookupIp + Send + Sync>;
|
|
|
|
#[derive(Clone)]
|
|
pub(crate) struct TrustDnsResolver {
|
|
inner: Arc<Mutex<Option<ErasedResolver>>>,
|
|
}
|
|
|
|
impl TrustDnsResolver {
|
|
pub(crate) fn new() -> Self {
|
|
TrustDnsResolver {
|
|
inner: Arc::new(Mutex::new(None)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl hyper_dns::Resolve for TrustDnsResolver {
|
|
type Addrs = ::std::vec::IntoIter<::std::net::IpAddr>;
|
|
type Future = Box<Future<Item=Self::Addrs, Error=io::Error> + Send>;
|
|
|
|
fn resolve(&self, name: hyper_dns::Name) -> Self::Future {
|
|
let inner = self.inner.clone();
|
|
Box::new(future::lazy(move || {
|
|
let mut inner = inner.lock().expect("lock resolver");
|
|
if inner.is_none() {
|
|
// The `bg` (background) future needs to be spawned onto an executor,
|
|
// but a `reqwest::Client` may be constructed before an executor is ready.
|
|
// So, the `bg` future cannot be spawned *until* the executor starts to
|
|
// `poll` this future.
|
|
match AsyncResolver::from_system_conf() {
|
|
Ok((resolver, bg)) => {
|
|
::tokio::spawn(bg);
|
|
*inner = Some(Box::new(move |name| {
|
|
resolver.lookup_ip(name.as_str())
|
|
}));
|
|
},
|
|
Err(err) => {
|
|
return future::Either::A(
|
|
future::err(io::Error::new(io::ErrorKind::Other, err.to_string()))
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
future::Either::B((inner
|
|
.as_mut()
|
|
.expect("resolver is set"))(name)
|
|
//.lookup_ip(name.as_str())
|
|
.map(|lookup| {
|
|
lookup
|
|
.iter()
|
|
.collect::<Vec<_>>()
|
|
.into_iter()
|
|
})
|
|
.map_err(|err| {
|
|
io::Error::new(io::ErrorKind::Other, err.to_string())
|
|
}))
|
|
}))
|
|
}
|
|
}
|
|
|
|
|