hickory: add ToSocketAddrs impl

And tokio utils to run it

Author: Keruspe

src/implementors/hickory.rs

@@ -1,9 +1,16 @@
-use crate::{traits::AsyncToSocketAddrs, util::SocketAddrsFromIpAddrs};
-use hickory_resolver::{IntoName, Resolver};
-use std::{io, net::SocketAddr, str::FromStr};
+use crate::{
+    traits::AsyncToSocketAddrs,
+    util::{self, SocketAddrsFromIpAddrs},
+};
+use hickory_resolver::{IntoName, Resolver, lookup_ip::LookupIpIntoIter};
+use std::{
+    io,
+    net::{SocketAddr, ToSocketAddrs},
+    str::FromStr,
+};
 
 /// Perform async DNS resolution using hickory-dns
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct HickoryToSocketAddrs<T: IntoName + Send + 'static> {
     host: T,
     port: u16,
@@ -14,6 +21,23 @@ impl<H: IntoName + Send + 'static> HickoryToSocketAddrs<H> {
     pub fn new(host: H, port: u16) -> Self {
         Self { host, port }
     }
+
+    async fn lookup(self) -> io::Result<SocketAddrsFromIpAddrs<LookupIpIntoIter>> {
+        if !util::inside_tokio() {
+            return Err(io::Error::other(
+                "hickory-dns is only supported in a tokio context",
+            ));
+        }
+
+        Ok(SocketAddrsFromIpAddrs(
+            Resolver::builder_tokio()?
+                .build()
+                .lookup_ip(self.host)
+                .await?
+                .into_iter(),
+            self.port,
+        ))
+    }
 }
 
 impl FromStr for HickoryToSocketAddrs<String> {
@@ -30,27 +54,20 @@ impl FromStr for HickoryToSocketAddrs<String> {
     }
 }
 
+impl<T: IntoName + Clone + Send + 'static> ToSocketAddrs for HickoryToSocketAddrs<T> {
+    type Iter = SocketAddrsFromIpAddrs<LookupIpIntoIter>;
+
+    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
+        util::block_on_tokio(self.clone().lookup())
+    }
+}
+
 impl<T: IntoName + Send + 'static> AsyncToSocketAddrs for HickoryToSocketAddrs<T> {
     fn to_socket_addrs(
         self,
     ) -> impl Future<Output = io::Result<impl Iterator<Item = SocketAddr> + Send + 'static>>
     + Send
     + 'static {
-        async move {
-            if tokio::runtime::Handle::try_current().is_err() {
-                return Err(io::Error::other(
-                    "hickory-dns is only supported in a tokio context",
-                ));
-            }
-
-            Ok(SocketAddrsFromIpAddrs(
-                Resolver::builder_tokio()?
-                    .build()
-                    .lookup_ip(self.host)
-                    .await?
-                    .into_iter(),
-                self.port,
-            ))
-        }
+        self.lookup()
     }
 }

src/util/mod.rs

@@ -13,3 +13,8 @@ pub use io::*;
 
 mod runtime;
 pub use runtime::*;
+
+#[cfg(feature = "tokio")]
+mod tokio;
+#[cfg(feature = "tokio")]
+pub use tokio::*;

src/util/tokio.rs

@@ -0,0 +1,19 @@
+use std::{future::Future, io};
+use tokio::runtime::Handle;
+
+/// Check whether we're in a tokio context or not
+pub fn inside_tokio() -> bool {
+    Handle::try_current().is_ok()
+}
+
+/// Block on the given future in a tokio context, creating a new one if required
+pub fn block_on_tokio<T>(fut: impl Future<Output = io::Result<T>>) -> io::Result<T> {
+    if let Ok(handle) = Handle::try_current() {
+        handle.block_on(fut)
+    } else {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()?
+            .block_on(fut)
+    }
+}