Update to tokio 1.0, bytes 1.0 (#1076)

Co-authored-by: Wim Looman <git@nemo157.com>
Co-authored-by: Paolo Barbolini <paolo@paolo565.org>

src/dns.rs

@@ -3,6 +3,7 @@ use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{self, Poll};
 use std::io;
+use std::net::SocketAddr;
 
 use hyper::client::connect::dns as hyper_dns;
 use hyper::service::Service;
@@ -10,7 +11,7 @@ use tokio::sync::Mutex;
 use trust_dns_resolver::{
     config::{ResolverConfig, ResolverOpts},
     lookup_ip::LookupIpIntoIter,
-    system_conf, AsyncResolver, TokioConnection, TokioConnectionProvider,
+    system_conf, AsyncResolver, TokioConnection, TokioConnectionProvider, TokioHandle
 };
 
 use crate::error::BoxError;
@@ -26,6 +27,10 @@ pub(crate) struct TrustDnsResolver {
     state: Arc<Mutex<State>>,
 }
 
+pub(crate) struct SocketAddrs {
+    iter: LookupIpIntoIter,
+}
+
 enum State {
     Init,
     Ready(SharedResolver),
@@ -47,7 +52,7 @@ impl TrustDnsResolver {
 }
 
 impl Service<hyper_dns::Name> for TrustDnsResolver {
-    type Response = LookupIpIntoIter;
+    type Response = SocketAddrs;
     type Error = BoxError;
     type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
 
@@ -62,7 +67,7 @@ impl Service<hyper_dns::Name> for TrustDnsResolver {
 
             let resolver = match &*lock {
                 State::Init => {
-                    let resolver = new_resolver(tokio::runtime::Handle::current()).await?;
+                    let resolver = new_resolver().await?;
                     *lock = State::Ready(resolver.clone());
                     resolver
                 },
@@ -74,18 +79,24 @@ impl Service<hyper_dns::Name> for TrustDnsResolver {
             drop(lock);
 
             let lookup = resolver.lookup_ip(name.as_str()).await?;
-            Ok(lookup.into_iter())
+            Ok(SocketAddrs { iter: lookup.into_iter() })
         })
     }
 }
 
-/// Takes a `Handle` argument as an indicator that it must be called from
-/// within the context of a Tokio runtime.
-async fn new_resolver(handle: tokio::runtime::Handle) -> Result<SharedResolver, BoxError> {
+impl Iterator for SocketAddrs {
+    type Item = SocketAddr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next().map(|ip_addr| SocketAddr::new(ip_addr, 0))
+    }
+}
+
+async fn new_resolver() -> Result<SharedResolver, BoxError> {
     let (config, opts) = SYSTEM_CONF
         .as_ref()
         .expect("can't construct TrustDnsResolver if SYSTEM_CONF is error")
         .clone();
-    let resolver = AsyncResolver::new(config, opts, handle).await?;
+    let resolver = AsyncResolver::new(config, opts, TokioHandle)?;
     Ok(Arc::new(resolver))
 }