From a068636e9781469650cb952c7bfd29c2c37b95b4 Mon Sep 17 00:00:00 2001 From: fakeshadow <24548779@qq.com> Date: Tue, 19 Jan 2021 06:25:17 +0800 Subject: [PATCH] add doc and tests for trust_dns as custom resolver --- actix-tls/Cargo.toml | 1 + actix-tls/src/connect/resolve.rs | 81 ++++++++++++++++++++++------ actix-tls/src/connect/ssl/openssl.rs | 2 - actix-tls/tests/test_connect.rs | 52 +++++++++++++++++- 4 files changed, 118 insertions(+), 18 deletions(-) diff --git a/actix-tls/Cargo.toml b/actix-tls/Cargo.toml index 9004ded8..66fd0a30 100644 --- a/actix-tls/Cargo.toml +++ b/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" \ No newline at end of file diff --git a/actix-tls/src/connect/resolve.rs b/actix-tls/src/connect/resolve.rs index 5e2b7257..79806149 100644 --- a/actix-tls/src/connect/resolve.rs +++ b/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, Box>> { +/// 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, Box>>; + fn lookup<'a>( + &'a self, + host: &'a str, + port: u16, + ) -> LocalBoxFuture<'a, Result, Box>>; } impl Resolver { @@ -61,10 +112,15 @@ impl Resolver { async fn lookup( &self, req: &Connect, - host: String, ) -> Result, 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 Service> 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); diff --git a/actix-tls/src/connect/ssl/openssl.rs b/actix-tls/src/connect/ssl/openssl.rs index 033bb77d..bcda4f1d 100644 --- a/actix-tls/src/connect/ssl/openssl.rs +++ b/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 } } diff --git a/actix-tls/tests/test_connect.rs b/actix-tls/tests/test_connect.rs index 7a0074a8..8c138064 100644 --- a/actix-tls/tests/test_connect.rs +++ b/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, Box>> { + 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() {