From 8e30a1d643bc998ebd5511fe094353e75698c492 Mon Sep 17 00:00:00 2001 From: fakeshadow <24548779@qq.com> Date: Fri, 22 Jan 2021 00:18:16 -0800 Subject: [PATCH] remove either and futures-util. update lookup logic. rework connect mod. update doc --- actix-server/Cargo.toml | 2 +- actix-tls/CHANGES.md | 10 ++- actix-tls/Cargo.toml | 4 +- actix-tls/src/accept/openssl.rs | 8 +- actix-tls/src/accept/rustls.rs | 1 - actix-tls/src/connect/connect.rs | 119 ++++++++++++--------------- actix-tls/src/connect/connector.rs | 39 +++++---- actix-tls/src/connect/mod.rs | 11 +++ actix-tls/src/connect/resolve.rs | 93 ++++++++++++++------- actix-tls/src/connect/service.rs | 110 +++++++++---------------- actix-tls/src/connect/ssl/openssl.rs | 31 +++---- actix-tls/src/connect/ssl/rustls.rs | 1 + actix-tls/tests/test_connect.rs | 2 +- 13 files changed, 216 insertions(+), 215 deletions(-) mode change 100644 => 100755 actix-server/Cargo.toml mode change 100644 => 100755 actix-tls/Cargo.toml mode change 100644 => 100755 actix-tls/src/connect/connect.rs mode change 100644 => 100755 actix-tls/src/connect/connector.rs mode change 100644 => 100755 actix-tls/src/connect/resolve.rs mode change 100644 => 100755 actix-tls/src/connect/service.rs mode change 100644 => 100755 actix-tls/src/connect/ssl/openssl.rs mode change 100644 => 100755 actix-tls/src/connect/ssl/rustls.rs mode change 100644 => 100755 actix-tls/tests/test_connect.rs diff --git a/actix-server/Cargo.toml b/actix-server/Cargo.toml old mode 100644 new mode 100755 index 33bf3b6a..25095039 --- a/actix-server/Cargo.toml +++ b/actix-server/Cargo.toml @@ -28,7 +28,7 @@ actix-rt = { version = "2.0.0-beta.2", default-features = false } actix-service = "2.0.0-beta.3" actix-utils = "3.0.0-beta.1" -futures-core = { version = "0.3.7", default-features = false } +futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] } log = "0.4" mio = { version = "0.7.6", features = ["os-poll", "net"] } num_cpus = "1.13" diff --git a/actix-tls/CHANGES.md b/actix-tls/CHANGES.md index 17741864..d73a7830 100644 --- a/actix-tls/CHANGES.md +++ b/actix-tls/CHANGES.md @@ -2,9 +2,13 @@ ## Unreleased - 2021-xx-xx * Remove `trust-dns-proto` and `trust-dns-resolver` [#248] -* Use `tokio::net::lookup_host` for as simple and basic default resolver [#248] -* Add `Resolve` trait for custom dns resolver. Add `Resolver::new_custom` function - to construct custom resolvers.[#248] +* Use `tokio::net::lookup_host` as simple and basic default resolver [#248] +* Add `Resolve` trait for custom dns resolver. [#248] +* Add `Resolver::new_custom` function to construct custom resolvers. [#248] +* Export `webpki_roots::TLS_SERVER_ROOTS` in `actix_tls::connect` mod and remove + the export from `actix_tls::accept` [#248] +* Remove `ConnectTakeAddrsIter`. `Connect::take_addrs` would return + `ConnectAddrsIter<'static>` as owned iterator. [#248] [#248]: https://github.com/actix/actix-net/pull/248 diff --git a/actix-tls/Cargo.toml b/actix-tls/Cargo.toml old mode 100644 new mode 100755 index 66fd0a30..bb9d02b5 --- a/actix-tls/Cargo.toml +++ b/actix-tls/Cargo.toml @@ -50,9 +50,7 @@ actix-service = "2.0.0-beta.3" actix-utils = "3.0.0-beta.1" derive_more = "0.99.5" -either = "1.6" -futures-core = { version = "0.3.7", default-features = false } -futures-util = { version = "0.3.7", default-features = false } +futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] } http = { version = "0.2.3", optional = true } log = "0.4" tokio = { version = "1", optional = true } diff --git a/actix-tls/src/accept/openssl.rs b/actix-tls/src/accept/openssl.rs index 19f14cb3..5f2d2fc2 100644 --- a/actix-tls/src/accept/openssl.rs +++ b/actix-tls/src/accept/openssl.rs @@ -1,6 +1,8 @@ -use std::future::Future; -use std::pin::Pin; -use std::task::{Context, Poll}; +use std::{ + future::Future, + pin::Pin, + task::{Context, Poll}, +}; use actix_codec::{AsyncRead, AsyncWrite}; use actix_service::{Service, ServiceFactory}; diff --git a/actix-tls/src/accept/rustls.rs b/actix-tls/src/accept/rustls.rs index 480c20c2..e7efaa3f 100644 --- a/actix-tls/src/accept/rustls.rs +++ b/actix-tls/src/accept/rustls.rs @@ -14,7 +14,6 @@ use tokio_rustls::{Accept, TlsAcceptor}; pub use rustls::{ServerConfig, Session}; pub use tokio_rustls::server::TlsStream; -pub use webpki_roots::TLS_SERVER_ROOTS; use super::MAX_CONN_COUNTER; diff --git a/actix-tls/src/connect/connect.rs b/actix-tls/src/connect/connect.rs old mode 100644 new mode 100755 index 37fa9c6e..3928870d --- a/actix-tls/src/connect/connect.rs +++ b/actix-tls/src/connect/connect.rs @@ -1,9 +1,9 @@ -use std::collections::{vec_deque, VecDeque}; -use std::fmt; -use std::iter::{FromIterator, FusedIterator}; -use std::net::SocketAddr; - -use either::Either; +use std::{ + collections::{vec_deque, VecDeque}, + fmt, + iter::{FromIterator, FusedIterator}, + net::SocketAddr, +}; /// Connect request pub trait Address: Unpin + 'static { @@ -39,7 +39,25 @@ impl Address for &'static str { pub struct Connect { pub(crate) req: T, pub(crate) port: u16, - pub(crate) addr: Option>>, + pub(crate) addr: ConnectAddrs, +} + +#[derive(Eq, PartialEq, Debug, Hash)] +pub(crate) enum ConnectAddrs { + One(Option), + Multi(VecDeque), +} + +impl ConnectAddrs { + pub(crate) fn is_none(&self) -> bool { + matches!(*self, Self::One(None)) + } +} + +impl Default for ConnectAddrs { + fn default() -> Self { + Self::One(None) + } } impl Connect { @@ -49,7 +67,7 @@ impl Connect { Connect { req, port: port.unwrap_or(0), - addr: None, + addr: ConnectAddrs::One(None), } } @@ -59,7 +77,7 @@ impl Connect { Connect { req, port: 0, - addr: Some(Either::Left(addr)), + addr: ConnectAddrs::One(Some(addr)), } } @@ -73,9 +91,7 @@ impl Connect { /// Use address. pub fn set_addr(mut self, addr: Option) -> Self { - if let Some(addr) = addr { - self.addr = Some(Either::Left(addr)); - } + self.addr = ConnectAddrs::One(addr); self } @@ -86,9 +102,9 @@ impl Connect { { let mut addrs = VecDeque::from_iter(addrs); self.addr = if addrs.len() < 2 { - addrs.pop_front().map(Either::Left) + ConnectAddrs::One(addrs.pop_front()) } else { - Some(Either::Right(addrs)) + ConnectAddrs::Multi(addrs) }; self } @@ -105,24 +121,18 @@ impl Connect { /// Pre-resolved addresses of the request. pub fn addrs(&self) -> ConnectAddrsIter<'_> { - let inner = match self.addr { - None => Either::Left(None), - Some(Either::Left(addr)) => Either::Left(Some(addr)), - Some(Either::Right(ref addrs)) => Either::Right(addrs.iter()), - }; - - ConnectAddrsIter { inner } + match self.addr { + ConnectAddrs::One(addr) => ConnectAddrsIter::One(addr), + ConnectAddrs::Multi(ref addrs) => ConnectAddrsIter::Multi(addrs.iter()), + } } /// Takes pre-resolved addresses of the request. - pub fn take_addrs(&mut self) -> ConnectTakeAddrsIter { - let inner = match self.addr.take() { - None => Either::Left(None), - Some(Either::Left(addr)) => Either::Left(Some(addr)), - Some(Either::Right(addrs)) => Either::Right(addrs.into_iter()), - }; - - ConnectTakeAddrsIter { inner } + pub fn take_addrs(&mut self) -> ConnectAddrsIter<'static> { + match std::mem::take(&mut self.addr) { + ConnectAddrs::One(addr) => ConnectAddrsIter::One(addr), + ConnectAddrs::Multi(addrs) => ConnectAddrsIter::MultiOwned(addrs.into_iter()), + } } } @@ -140,25 +150,29 @@ impl fmt::Display for Connect { /// Iterator over addresses in a [`Connect`] request. #[derive(Clone)] -pub struct ConnectAddrsIter<'a> { - inner: Either, vec_deque::Iter<'a, SocketAddr>>, +pub enum ConnectAddrsIter<'a> { + One(Option), + Multi(vec_deque::Iter<'a, SocketAddr>), + MultiOwned(vec_deque::IntoIter), } impl Iterator for ConnectAddrsIter<'_> { type Item = SocketAddr; fn next(&mut self) -> Option { - match self.inner { - Either::Left(ref mut opt) => opt.take(), - Either::Right(ref mut iter) => iter.next().copied(), + match *self { + Self::One(ref mut addr) => addr.take(), + Self::Multi(ref mut iter) => iter.next().copied(), + Self::MultiOwned(ref mut iter) => iter.next(), } } fn size_hint(&self) -> (usize, Option) { - match self.inner { - Either::Left(Some(_)) => (1, Some(1)), - Either::Left(None) => (0, Some(0)), - Either::Right(ref iter) => iter.size_hint(), + match *self { + Self::One(None) => (0, Some(0)), + Self::One(Some(_)) => (1, Some(1)), + Self::Multi(ref iter) => iter.size_hint(), + Self::MultiOwned(ref iter) => iter.size_hint(), } } } @@ -173,35 +187,6 @@ impl ExactSizeIterator for ConnectAddrsIter<'_> {} impl FusedIterator for ConnectAddrsIter<'_> {} -/// Owned iterator over addresses in a [`Connect`] request. -#[derive(Debug)] -pub struct ConnectTakeAddrsIter { - inner: Either, vec_deque::IntoIter>, -} - -impl Iterator for ConnectTakeAddrsIter { - type Item = SocketAddr; - - fn next(&mut self) -> Option { - match self.inner { - Either::Left(ref mut opt) => opt.take(), - Either::Right(ref mut iter) => iter.next(), - } - } - - fn size_hint(&self) -> (usize, Option) { - match self.inner { - Either::Left(Some(_)) => (1, Some(1)), - Either::Left(None) => (0, Some(0)), - Either::Right(ref iter) => iter.size_hint(), - } - } -} - -impl ExactSizeIterator for ConnectTakeAddrsIter {} - -impl FusedIterator for ConnectTakeAddrsIter {} - fn parse(host: &str) -> (&str, Option) { let mut parts_iter = host.splitn(2, ':'); if let Some(host) = parts_iter.next() { diff --git a/actix-tls/src/connect/connector.rs b/actix-tls/src/connect/connector.rs old mode 100644 new mode 100755 index ea683121..fe4ceec6 --- a/actix-tls/src/connect/connector.rs +++ b/actix-tls/src/connect/connector.rs @@ -1,16 +1,18 @@ -use std::collections::VecDeque; -use std::future::Future; -use std::io; -use std::net::SocketAddr; -use std::pin::Pin; -use std::task::{Context, Poll}; +use std::{ + collections::VecDeque, + future::Future, + io, + net::SocketAddr, + pin::Pin, + task::{Context, Poll}, +}; use actix_rt::net::TcpStream; use actix_service::{Service, ServiceFactory}; use futures_core::future::LocalBoxFuture; use log::{error, trace}; -use super::connect::{Address, Connect, Connection}; +use super::connect::{Address, Connect, ConnectAddrs, Connection}; use super::error::ConnectError; /// TCP connector service factory @@ -53,12 +55,7 @@ impl Service> for TcpConnector { let port = req.port(); let Connect { req, addr, .. } = req; - if let Some(addr) = addr { - TcpConnectorResponse::new(req, port, addr) - } else { - error!("TCP connector: got unresolved address"); - TcpConnectorResponse::Error(Some(ConnectError::Unresolved)) - } + TcpConnectorResponse::new(req, port, addr) } } @@ -75,11 +72,7 @@ pub enum TcpConnectorResponse { } impl TcpConnectorResponse { - pub fn new( - req: T, - port: u16, - addr: either::Either>, - ) -> TcpConnectorResponse { + pub(crate) fn new(req: T, port: u16, addr: ConnectAddrs) -> TcpConnectorResponse { trace!( "TCP connector - connecting to {:?} port:{}", req.host(), @@ -87,13 +80,19 @@ impl TcpConnectorResponse { ); match addr { - either::Either::Left(addr) => TcpConnectorResponse::Response { + ConnectAddrs::One(None) => { + error!("TCP connector: got unresolved address"); + TcpConnectorResponse::Error(Some(ConnectError::Unresolved)) + } + ConnectAddrs::One(Some(addr)) => TcpConnectorResponse::Response { req: Some(req), port, addrs: None, stream: Some(Box::pin(TcpStream::connect(addr))), }, - either::Either::Right(addrs) => TcpConnectorResponse::Response { + // when resolver returns multiple socket addr for request they would be popped from + // front end of queue and returns with the first successful tcp connection. + ConnectAddrs::Multi(addrs) => TcpConnectorResponse::Response { req: Some(req), port, addrs: Some(addrs), diff --git a/actix-tls/src/connect/mod.rs b/actix-tls/src/connect/mod.rs index a9c675f6..c864886d 100644 --- a/actix-tls/src/connect/mod.rs +++ b/actix-tls/src/connect/mod.rs @@ -4,6 +4,17 @@ //! //! * `openssl` - enables TLS support via `openssl` crate //! * `rustls` - enables TLS support via `rustls` crate +//! +//! ## Workflow of connector service: +//! - resolve [`Address`](self::connect::Address) with given [`Resolver`](self::resolve::Resolver) +//! and collect [`SocketAddrs`](std::net::SocketAddr). +//! - establish Tcp connection and return [`TcpStream`](tokio::net::TcpStream). +//! +//! ## Workflow of tls connector services: +//! - Establish [`TcpStream`](tokio::net::TcpStream) with connector service. +//! - Wrap around the stream and do connect handshake with remote address. +//! - Return certain stream type impl [`AsyncRead`](tokio::io::AsyncRead) and +//! [`AsyncWrite`](tokio::io::AsyncWrite) mod connect; mod connector; diff --git a/actix-tls/src/connect/resolve.rs b/actix-tls/src/connect/resolve.rs old mode 100644 new mode 100755 index 79806149..b61ab7e5 --- a/actix-tls/src/connect/resolve.rs +++ b/actix-tls/src/connect/resolve.rs @@ -1,4 +1,10 @@ -use std::{net::SocketAddr, rc::Rc, task::Poll}; +use std::{ + future::Future, + net::SocketAddr, + pin::Pin, + rc::Rc, + task::{Context, Poll}, +}; use actix_service::{Service, ServiceFactory}; use futures_core::future::LocalBoxFuture; @@ -89,11 +95,11 @@ pub enum 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()); +/// let connector = actix_tls::connect::new_connector::<&str>(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); +/// let factory = actix_tls::connect::new_connector_factory::<&str>(resolver); ///``` pub trait Resolve { fn lookup<'a>( @@ -115,22 +121,34 @@ impl Resolver { ) -> Result, ConnectError> { match self { Self::Default => { - let host = if req.host().contains(':') { - req.host().to_string() + let host = req.host(); + // TODO: Connect should always return host with port if possible. + let host = if req + .host() + .splitn(2, ':') + .last() + .and_then(|p| p.parse::().ok()) + .map(|p| p == req.port()) + .unwrap_or(false) + { + host.to_string() } else { - format!("{}:{}", req.host(), req.port()) + format!("{}:{}", host, req.port()) }; - let res = tokio::net::lookup_host(host).await.map_err(|e| { - trace!( - "DNS resolver: failed to resolve host {:?} err: {}", - req.host(), - e - ); - ConnectError::Resolver(Box::new(e)) - })?; + let res = tokio::net::lookup_host(host) + .await + .map_err(|e| { + trace!( + "DNS resolver: failed to resolve host {:?} err: {}", + req.host(), + e + ); + ConnectError::Resolver(Box::new(e)) + })? + .collect(); - Ok(res.collect()) + Ok(res) } Self::Custom(resolver) => resolver .lookup(req.host(), req.port()) @@ -143,21 +161,22 @@ impl Resolver { impl Service> for Resolver { type Response = Connect; type Error = ConnectError; - type Future = LocalBoxFuture<'static, Result>; + type Future = ResolverFuture; actix_service::always_ready!(); - fn call(&mut self, mut req: Connect) -> Self::Future { - let resolver = self.clone(); - Box::pin(async move { - if req.addr.is_some() { - Ok(req) - } else if let Ok(ip) = req.host().parse() { - req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port()))); - Ok(req) - } else { - trace!("DNS resolver: resolving host {:?}", req.host()); + fn call(&mut self, req: Connect) -> Self::Future { + if !req.addr.is_none() { + ResolverFuture::Connected(Some(req)) + } else if let Ok(ip) = req.host().parse() { + let addr = SocketAddr::new(ip, req.port()); + let req = req.set_addr(Some(addr)); + ResolverFuture::Connected(Some(req)) + } else { + trace!("DNS resolver: resolving host {:?}", req.host()); + let resolver = self.clone(); + ResolverFuture::Lookup(Box::pin(async move { let addrs = resolver.lookup(&req).await?; let req = req.set_addrs(addrs); @@ -173,7 +192,25 @@ impl Service> for Resolver { } else { Ok(req) } - } - }) + })) + } + } +} + +pub enum ResolverFuture { + Connected(Option>), + Lookup(LocalBoxFuture<'static, Result, ConnectError>>), +} + +impl Future for ResolverFuture { + type Output = Result, ConnectError>; + + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + match self.get_mut() { + Self::Connected(conn) => Poll::Ready(Ok(conn + .take() + .expect("ResolverFuture polled after finished"))), + Self::Lookup(fut) => fut.as_mut().poll(cx), + } } } diff --git a/actix-tls/src/connect/service.rs b/actix-tls/src/connect/service.rs old mode 100644 new mode 100755 index 9c8d0736..6fa8a453 --- a/actix-tls/src/connect/service.rs +++ b/actix-tls/src/connect/service.rs @@ -1,11 +1,12 @@ -use std::future::Future; -use std::pin::Pin; -use std::task::{Context, Poll}; +use std::{ + future::Future, + pin::Pin, + task::{Context, Poll}, +}; use actix_rt::net::TcpStream; use actix_service::{Service, ServiceFactory}; -use either::Either; -use futures_core::future::LocalBoxFuture; +use futures_core::{future::LocalBoxFuture, ready}; use super::connect::{Address, Connect, Connection}; use super::connector::{TcpConnector, TcpConnectorFactory}; @@ -81,36 +82,42 @@ impl Service> for ConnectService { fn call(&mut self, req: Connect) -> Self::Future { ConnectServiceResponse { - state: ConnectState::Resolve(self.resolver.call(req)), + fut: ConnectFuture::Resolve(self.resolver.call(req)), tcp: self.tcp, } } } -enum ConnectState { +// helper enum to generic over futures of resolve and connect phase. +pub(crate) enum ConnectFuture { Resolve(>>::Future), Connect(>>::Future), } -impl ConnectState { - #[allow(clippy::type_complexity)] - fn poll( +// helper enum to contain the future output of ConnectFuture +pub(crate) enum ConnectOutput { + Resolved(Connect), + Connected(Connection), +} + +impl ConnectFuture { + fn poll_connect( &mut self, cx: &mut Context<'_>, - ) -> Either, ConnectError>>, Connect> { + ) -> Poll, ConnectError>> { match self { - ConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) { - Poll::Pending => Either::Left(Poll::Pending), - Poll::Ready(Ok(res)) => Either::Right(res), - Poll::Ready(Err(err)) => Either::Left(Poll::Ready(Err(err))), - }, - ConnectState::Connect(ref mut fut) => Either::Left(Pin::new(fut).poll(cx)), + ConnectFuture::Resolve(ref mut fut) => { + Pin::new(fut).poll(cx).map_ok(ConnectOutput::Resolved) + } + ConnectFuture::Connect(ref mut fut) => { + Pin::new(fut).poll(cx).map_ok(ConnectOutput::Connected) + } } } } pub struct ConnectServiceResponse { - state: ConnectState, + fut: ConnectFuture, tcp: TcpConnector, } @@ -118,17 +125,13 @@ impl Future for ConnectServiceResponse { type Output = Result, ConnectError>; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let res = match self.state.poll(cx) { - Either::Right(res) => { - self.state = ConnectState::Connect(self.tcp.call(res)); - self.state.poll(cx) + loop { + match ready!(self.fut.poll_connect(cx))? { + ConnectOutput::Resolved(res) => { + self.fut = ConnectFuture::Connect(self.tcp.call(res)); + } + ConnectOutput::Connected(res) => return Poll::Ready(Ok(res)), } - Either::Left(res) => return res, - }; - - match res { - Either::Left(res) => res, - Either::Right(_) => panic!(), } } } @@ -139,7 +142,7 @@ pub struct TcpConnectService { resolver: Resolver, } -impl Service> for TcpConnectService { +impl Service> for TcpConnectService { type Response = TcpStream; type Error = ConnectError; type Future = TcpConnectServiceResponse; @@ -148,43 +151,14 @@ impl Service> for TcpConnectService { fn call(&mut self, req: Connect) -> Self::Future { TcpConnectServiceResponse { - state: TcpConnectState::Resolve(self.resolver.call(req)), + fut: ConnectFuture::Resolve(self.resolver.call(req)), tcp: self.tcp, } } } -enum TcpConnectState { - Resolve(>>::Future), - Connect(>>::Future), -} - -impl TcpConnectState { - fn poll( - &mut self, - cx: &mut Context<'_>, - ) -> Either>, Connect> { - match self { - TcpConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) { - Poll::Pending => (), - Poll::Ready(Ok(res)) => return Either::Right(res), - Poll::Ready(Err(err)) => return Either::Left(Poll::Ready(Err(err))), - }, - TcpConnectState::Connect(ref mut fut) => { - if let Poll::Ready(res) = Pin::new(fut).poll(cx) { - return match res { - Ok(conn) => Either::Left(Poll::Ready(Ok(conn.into_parts().0))), - Err(err) => Either::Left(Poll::Ready(Err(err))), - }; - } - } - } - Either::Left(Poll::Pending) - } -} - pub struct TcpConnectServiceResponse { - state: TcpConnectState, + fut: ConnectFuture, tcp: TcpConnector, } @@ -192,17 +166,13 @@ impl Future for TcpConnectServiceResponse { type Output = Result; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let res = match self.state.poll(cx) { - Either::Right(res) => { - self.state = TcpConnectState::Connect(self.tcp.call(res)); - self.state.poll(cx) + loop { + match ready!(self.fut.poll_connect(cx))? { + ConnectOutput::Resolved(res) => { + self.fut = ConnectFuture::Connect(self.tcp.call(res)); + } + ConnectOutput::Connected(conn) => return Poll::Ready(Ok(conn.into_parts().0)), } - Either::Left(res) => return res, - }; - - match res { - Either::Left(res) => res, - Either::Right(_) => panic!(), } } } diff --git a/actix-tls/src/connect/ssl/openssl.rs b/actix-tls/src/connect/ssl/openssl.rs old mode 100644 new mode 100755 index bcda4f1d..d5d71edc --- a/actix-tls/src/connect/ssl/openssl.rs +++ b/actix-tls/src/connect/ssl/openssl.rs @@ -2,7 +2,6 @@ use std::{ fmt, future::Future, io, - marker::PhantomData, pin::Pin, task::{Context, Poll}, }; @@ -11,7 +10,6 @@ use actix_codec::{AsyncRead, AsyncWrite}; use actix_rt::net::TcpStream; use actix_service::{Service, ServiceFactory}; use futures_core::{future::LocalBoxFuture, ready}; -use futures_util::future::{ready, Either, Ready}; use log::trace; pub use openssl::ssl::{Error as SslError, HandshakeError, SslConnector, SslMethod}; @@ -82,29 +80,27 @@ where { type Response = Connection>; type Error = io::Error; - #[allow(clippy::type_complexity)] - type Future = Either, Ready>>; + type Future = ConnectAsyncExt; actix_service::always_ready!(); fn call(&mut self, stream: Connection) -> Self::Future { trace!("SSL Handshake start for: {:?}", stream.host()); let (io, stream) = stream.replace(()); - let host = stream.host().to_string(); + let host = stream.host(); - match self.connector.configure() { - Err(e) => Either::Right(ready(Err(io::Error::new(io::ErrorKind::Other, e)))), - Ok(config) => { - let ssl = config - .into_ssl(&host) - .expect("SSL connect configuration was invalid."); + let config = self + .connector + .configure() + .expect("SSL connect configuration was invalid."); - Either::Left(ConnectAsyncExt { - io: Some(SslStream::new(ssl, io).unwrap()), - stream: Some(stream), - _t: PhantomData, - }) - } + let ssl = config + .into_ssl(host) + .expect("SSL connect configuration was invalid."); + + ConnectAsyncExt { + io: Some(SslStream::new(ssl, io).unwrap()), + stream: Some(stream), } } } @@ -112,7 +108,6 @@ where pub struct ConnectAsyncExt { io: Option>, stream: Option>, - _t: PhantomData, } impl Future for ConnectAsyncExt diff --git a/actix-tls/src/connect/ssl/rustls.rs b/actix-tls/src/connect/ssl/rustls.rs old mode 100644 new mode 100755 index 5eb5bee6..e12ab7ec --- a/actix-tls/src/connect/ssl/rustls.rs +++ b/actix-tls/src/connect/ssl/rustls.rs @@ -8,6 +8,7 @@ use std::{ pub use rustls::Session; pub use tokio_rustls::{client::TlsStream, rustls::ClientConfig}; +pub use webpki_roots::TLS_SERVER_ROOTS; use actix_codec::{AsyncRead, AsyncWrite}; use actix_service::{Service, ServiceFactory}; diff --git a/actix-tls/tests/test_connect.rs b/actix-tls/tests/test_connect.rs old mode 100644 new mode 100755 index 8c138064..32d2ac0f --- a/actix-tls/tests/test_connect.rs +++ b/actix-tls/tests/test_connect.rs @@ -97,7 +97,7 @@ async fn test_custom_resolver() { struct MyResolver { trust_dns: TokioAsyncResolver, - }; + } impl Resolve for MyResolver { fn lookup<'a>(