Replace getaddrinfo resolver with trust-dns-resolver

src/dns.rs

@@ -0,0 +1,73 @@
+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())
+                }))
+        }))
+    }
+}
+
+