add doc and tests for trust_dns as custom resolver

actix-tls/Cargo.toml

@@ -80,3 +80,4 @@ bytes = "1"
 env_logger = "0.8"
 futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
 log = "0.4"
+trust-dns-resolver = "0.20.0"

actix-tls/src/connect/resolve.rs

@@ -45,11 +45,62 @@ pub enum Resolver {
 }
 
 /// trait for custom lookup with self defined resolver.
+///
+/// # Example:
+/// ```rust
+/// use std::net::SocketAddr;
+///
+/// use actix_tls::connect::{Resolve, Resolver};
+/// use futures_util::future::LocalBoxFuture;
+///
+/// // use trust_dns_resolver as custom resolver.
+/// use trust_dns_resolver::TokioAsyncResolver;
+///
+/// struct MyResolver {
+///     trust_dns: TokioAsyncResolver,
+/// };
+///
+/// // impl Resolve trait and convert given host address str and port to SocketAddr.
+/// impl Resolve for MyResolver {
+///     fn lookup<'a>(
+///         &'a self,
+///         host: &'a str,
+///         port: u16,
+///     ) -> LocalBoxFuture<'a, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>> {
+///         Box::pin(async move {
+///             let res = self
+///                 .trust_dns
+///                 .lookup_ip(host)
+///                 .await?
+///                 .iter()
+///                 .map(|ip| SocketAddr::new(ip, port))
+///                 .collect();
+///             Ok(res)
+///         })
+///     }
+/// }
+///
+/// let resolver = MyResolver {
+///     trust_dns: TokioAsyncResolver::tokio_from_system_conf().unwrap(),
+/// };
+///
+/// // construct custom resolver
+/// let resolver = Resolver::new_custom(resolver);
+///
+/// // pass custom resolver to connector builder.
+/// // connector would then be usable as a service or awc's connector.
+/// let connector = actix_tls::connect::new_connector(resolver.clone());
+///
+/// // resolver can be passed to connector factory where returned service factory
+/// // can be used to construct new connector services.
+/// let factory = actix_tls::connect::new_connector_factory(resolver);
+///```
 pub trait Resolve {
-    fn lookup(
-        &self,
-        addrs: String,
-    ) -> LocalBoxFuture<'_, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>>;
+    fn lookup<'a>(
+        &'a self,
+        host: &'a str,
+        port: u16,
+    ) -> LocalBoxFuture<'a, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>>;
 }
 
 impl Resolver {
@@ -61,10 +112,15 @@ impl Resolver {
     async fn lookup<T: Address>(
         &self,
         req: &Connect<T>,
-        host: String,
     ) -> Result<Vec<SocketAddr>, ConnectError> {
         match self {
             Self::Default => {
+                let host = if req.host().contains(':') {
+                    req.host().to_string()
+                } else {
+                    format!("{}:{}", req.host(), req.port())
+                };
+
                 let res = tokio::net::lookup_host(host).await.map_err(|e| {
                     trace!(
                         "DNS resolver: failed to resolve host {:?} err: {}",
@@ -76,9 +132,10 @@ impl Resolver {
 
                 Ok(res.collect())
             }
-            Self::Custom(resolver) => {
-                resolver.lookup(host).await.map_err(ConnectError::Resolver)
-            }
+            Self::Custom(resolver) => resolver
+                .lookup(req.host(), req.port())
+                .await
+                .map_err(ConnectError::Resolver),
         }
     }
 }
@@ -101,13 +158,7 @@ impl<T: Address> Service<Connect<T>> for Resolver {
             } else {
                 trace!("DNS resolver: resolving host {:?}", req.host());
 
-                let host = if req.host().contains(':') {
-                    req.host().to_string()
-                } else {
-                    format!("{}:{}", req.host(), req.port())
-                };
-
-                let addrs = resolver.lookup(&req, host).await?;
+                let addrs = resolver.lookup(&req).await?;
 
                 let req = req.set_addrs(addrs);
 

actix-tls/src/connect/ssl/openssl.rs

@@ -31,9 +31,7 @@ impl OpensslConnector {
     pub fn new(connector: SslConnector) -> Self {
         OpensslConnector { connector }
     }
-}
 
-impl OpensslConnector {
     pub fn service(connector: SslConnector) -> OpensslConnectorService {
         OpensslConnectorService { connector }
     }

actix-tls/tests/test_connect.rs

@@ -1,13 +1,15 @@
 use std::io;
+use std::net::SocketAddr;
 
 use actix_codec::{BytesCodec, Framed};
 use actix_rt::net::TcpStream;
 use actix_server::TestServer;
 use actix_service::{fn_service, Service, ServiceFactory};
 use bytes::Bytes;
+use futures_core::future::LocalBoxFuture;
 use futures_util::sink::SinkExt;
 
-use actix_tls::connect::{self as actix_connect, Connect};
+use actix_tls::connect::{self as actix_connect, Connect, Resolve, Resolver};
 
 #[cfg(all(feature = "connect", feature = "openssl"))]
 #[actix_rt::test]
@@ -81,6 +83,54 @@ async fn test_new_service() {
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
+#[actix_rt::test]
+async fn test_custom_resolver() {
+    use trust_dns_resolver::TokioAsyncResolver;
+
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
+        })
+    });
+
+    struct MyResolver {
+        trust_dns: TokioAsyncResolver,
+    };
+
+    impl Resolve for MyResolver {
+        fn lookup<'a>(
+            &'a self,
+            host: &'a str,
+            port: u16,
+        ) -> LocalBoxFuture<'a, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>> {
+            Box::pin(async move {
+                let res = self
+                    .trust_dns
+                    .lookup_ip(host)
+                    .await?
+                    .iter()
+                    .map(|ip| SocketAddr::new(ip, port))
+                    .collect();
+                Ok(res)
+            })
+        }
+    }
+
+    let resolver = MyResolver {
+        trust_dns: TokioAsyncResolver::tokio_from_system_conf().unwrap(),
+    };
+
+    let resolver = Resolver::new_custom(resolver);
+
+    let factory = actix_connect::new_connector_factory(resolver);
+
+    let mut conn = factory.new_service(()).await.unwrap();
+    let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
 #[cfg(all(feature = "openssl", feature = "uri"))]
 #[actix_rt::test]
 async fn test_openssl_uri() {