prepare actix-tls release 3.0.0-rc.1 (#423)

actix-tls/src/accept/native_tls.rs

@@ -93,7 +93,7 @@ pub struct Acceptor {
 }
 
 impl Acceptor {
-    /// Constructs `native-tls` based `Acceptor` service factory.
+    /// Constructs `native-tls` based acceptor service factory.
     pub fn new(acceptor: TlsAcceptor) -> Self {
         Acceptor {
             acceptor,

actix-tls/src/accept/openssl.rs

@@ -96,7 +96,7 @@ pub struct Acceptor {
 }
 
 impl Acceptor {
-    /// Create OpenSSL based `Acceptor` service factory.
+    /// Create `openssl` based acceptor service factory.
     #[inline]
     pub fn new(acceptor: SslAcceptor) -> Self {
         Acceptor {

actix-tls/src/accept/rustls.rs

@@ -96,7 +96,7 @@ pub struct Acceptor {
 }
 
 impl Acceptor {
-    /// Constructs Rustls based acceptor service factory.
+    /// Constructs `rustls` based acceptor service factory.
     pub fn new(config: ServerConfig) -> Self {
         Acceptor {
             config: Arc::new(config),

actix-tls/src/connect/connector.rs

@@ -34,7 +34,7 @@ impl Connector {
     /// Build connector service.
     pub fn service(&self) -> ConnectorService {
         ConnectorService {
-            tcp: TcpConnector.service(),
+            tcp: TcpConnector::default().service(),
             resolver: self.resolver.service(),
         }
     }
@@ -57,7 +57,7 @@ impl<R: Host> ServiceFactory<ConnectInfo<R>> for Connector {
 ///
 /// Service implementation receives connection information, resolves DNS if required, and returns
 /// a TCP stream.
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct ConnectorService {
     tcp: TcpConnectorService,
     resolver: ResolverService,
@@ -78,14 +78,14 @@ impl<R: Host> Service<ConnectInfo<R>> for ConnectorService {
     }
 }
 
-/// Helper enum to generic over futures of resolve and connect steps.
+/// Chains futures of resolve and connect steps.
 pub(crate) enum ConnectFut<R: Host> {
     Resolve(<ResolverService as Service<ConnectInfo<R>>>::Future),
     Connect(<TcpConnectorService as Service<ConnectInfo<R>>>::Future),
 }
 
-/// Helper enum to contain the future output of `ConnectFuture`.
-pub(crate) enum ConnectOutput<R: Host> {
+/// Container for the intermediate states of [`ConnectFut`].
+pub(crate) enum ConnectFutState<R: Host> {
     Resolved(ConnectInfo<R>),
     Connected(Connection<R, TcpStream>),
 }
@@ -94,13 +94,14 @@ impl<R: Host> ConnectFut<R> {
     fn poll_connect(
         &mut self,
         cx: &mut Context<'_>,
-    ) -> Poll<Result<ConnectOutput<R>, ConnectError>> {
+    ) -> Poll<Result<ConnectFutState<R>, ConnectError>> {
         match self {
             ConnectFut::Resolve(ref mut fut) => {
-                Pin::new(fut).poll(cx).map_ok(ConnectOutput::Resolved)
+                Pin::new(fut).poll(cx).map_ok(ConnectFutState::Resolved)
             }
+
             ConnectFut::Connect(ref mut fut) => {
-                Pin::new(fut).poll(cx).map_ok(ConnectOutput::Connected)
+                Pin::new(fut).poll(cx).map_ok(ConnectFutState::Connected)
             }
         }
     }
@@ -117,10 +118,10 @@ impl<R: Host> Future for ConnectServiceResponse<R> {
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
             match ready!(self.fut.poll_connect(cx))? {
-                ConnectOutput::Resolved(res) => {
+                ConnectFutState::Resolved(res) => {
                     self.fut = ConnectFut::Connect(self.tcp.call(res));
                 }
-                ConnectOutput::Connected(res) => return Poll::Ready(Ok(res)),
+                ConnectFutState::Connected(res) => return Poll::Ready(Ok(res)),
             }
         }
     }

actix-tls/src/connect/native_tls.rs

@@ -10,22 +10,24 @@ use actix_utils::future::{ok, Ready};
 use futures_core::future::LocalBoxFuture;
 use log::trace;
 use tokio_native_tls::{
-    native_tls::TlsConnector as NativeTlsConnector, TlsConnector as TokioNativeTlsConnector,
-    TlsStream,
+    native_tls::TlsConnector as NativeTlsConnector, TlsConnector as AsyncNativeTlsConnector,
+    TlsStream as AsyncTlsStream,
 };
 
 use crate::connect::{Connection, Host};
 
 pub mod reexports {
-    //! Re-exports from `native-tls` that are useful for connectors.
+    //! Re-exports from `native-tls` and `tokio-native-tls` that are useful for connectors.
 
     pub use tokio_native_tls::native_tls::TlsConnector;
+
+    pub use tokio_native_tls::TlsStream as AsyncTlsStream;
 }
 
 /// Connector service and factory using `native-tls`.
 #[derive(Clone)]
 pub struct TlsConnector {
-    connector: TokioNativeTlsConnector,
+    connector: AsyncNativeTlsConnector,
 }
 
 impl TlsConnector {
@@ -34,7 +36,7 @@ impl TlsConnector {
     /// This type is it's own service factory, so it can be used in that setting, too.
     pub fn new(connector: NativeTlsConnector) -> Self {
         Self {
-            connector: TokioNativeTlsConnector::from(connector),
+            connector: AsyncNativeTlsConnector::from(connector),
         }
     }
 }
@@ -43,7 +45,7 @@ impl<R: Host, IO> ServiceFactory<Connection<R, IO>> for TlsConnector
 where
     IO: ActixStream + 'static,
 {
-    type Response = Connection<R, TlsStream<IO>>;
+    type Response = Connection<R, AsyncTlsStream<IO>>;
     type Error = io::Error;
     type Config = ();
     type Service = Self;
@@ -62,7 +64,7 @@ where
     R: Host,
     IO: ActixStream + 'static,
 {
-    type Response = Connection<R, TlsStream<IO>>;
+    type Response = Connection<R, AsyncTlsStream<IO>>;
     type Error = io::Error;
     type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 

actix-tls/src/connect/openssl.rs

@@ -15,14 +15,16 @@ use actix_utils::future::{ok, Ready};
 use futures_core::ready;
 use log::trace;
 use openssl::ssl::SslConnector;
-use tokio_openssl::SslStream;
+use tokio_openssl::SslStream as AsyncSslStream;
 
 use crate::connect::{Connection, Host};
 
 pub mod reexports {
-    //! Re-exports from `openssl` that are useful for connectors.
+    //! Re-exports from `openssl` and `tokio-openssl` that are useful for connectors.
 
-    pub use openssl::ssl::{Error as SslError, HandshakeError, SslConnector, SslMethod};
+    pub use openssl::ssl::{Error, HandshakeError, SslConnector, SslMethod};
+
+    pub use tokio_openssl::SslStream as AsyncSslStream;
 }
 
 /// Connector service factory using `openssl`.
@@ -55,7 +57,7 @@ where
     R: Host,
     IO: ActixStream + 'static,
 {
-    type Response = Connection<R, SslStream<IO>>;
+    type Response = Connection<R, AsyncSslStream<IO>>;
     type Error = io::Error;
     type Config = ();
     type Service = TlsConnectorService;
@@ -87,7 +89,7 @@ where
     R: Host,
     IO: ActixStream,
 {
-    type Response = Connection<R, SslStream<IO>>;
+    type Response = Connection<R, AsyncSslStream<IO>>;
     type Error = io::Error;
     type Future = ConnectFut<R, IO>;
 
@@ -108,7 +110,7 @@ where
             .expect("SSL connect configuration was invalid.");
 
         ConnectFut {
-            io: Some(SslStream::new(ssl, io).unwrap()),
+            io: Some(AsyncSslStream::new(ssl, io).unwrap()),
             stream: Some(stream),
         }
     }
@@ -117,7 +119,7 @@ where
 /// Connect future for OpenSSL service.
 #[doc(hidden)]
 pub struct ConnectFut<R, IO> {
-    io: Option<SslStream<IO>>,
+    io: Option<AsyncSslStream<IO>>,
     stream: Option<Connection<R, ()>>,
 }
 
@@ -126,7 +128,7 @@ where
     R: Host,
     IO: ActixStream,
 {
-    type Output = Result<Connection<R, SslStream<IO>>, io::Error>;
+    type Output = Result<Connection<R, AsyncSslStream<IO>>, io::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();

actix-tls/src/connect/rustls.rs

@@ -17,7 +17,7 @@ use actix_utils::future::{ok, Ready};
 use futures_core::ready;
 use log::trace;
 use tokio_rustls::rustls::{client::ServerName, OwnedTrustAnchor, RootCertStore};
-use tokio_rustls::{client::TlsStream, rustls::ClientConfig};
+use tokio_rustls::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
 use tokio_rustls::{Connect as RustlsConnect, TlsConnector as RustlsTlsConnector};
 use webpki_roots::TLS_SERVER_ROOTS;
 
@@ -26,7 +26,9 @@ use crate::connect::{Connection, Host};
 pub mod reexports {
     //! Re-exports from `rustls` and `webpki_roots` that are useful for connectors.
 
-    pub use tokio_rustls::{client::TlsStream, rustls::ClientConfig};
+    pub use tokio_rustls::rustls::ClientConfig;
+
+    pub use tokio_rustls::client::TlsStream as AsyncTlsStream;
 
     pub use webpki_roots::TLS_SERVER_ROOTS;
 }
@@ -69,7 +71,7 @@ where
     R: Host,
     IO: ActixStream + 'static,
 {
-    type Response = Connection<R, TlsStream<IO>>;
+    type Response = Connection<R, AsyncTlsStream<IO>>;
     type Error = io::Error;
     type Config = ();
     type Service = TlsConnectorService;
@@ -94,7 +96,7 @@ where
     R: Host,
     IO: ActixStream,
 {
-    type Response = Connection<R, TlsStream<IO>>;
+    type Response = Connection<R, AsyncTlsStream<IO>>;
     type Error = io::Error;
     type Future = ConnectFut<R, IO>;
 
@@ -130,7 +132,7 @@ where
     R: Host,
     IO: ActixStream,
 {
-    type Output = Result<Connection<R, TlsStream<IO>>, io::Error>;
+    type Output = Result<Connection<R, AsyncTlsStream<IO>>, io::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         match self.get_mut() {

actix-tls/src/connect/tcp.rs

@@ -21,13 +21,14 @@ use tokio_util::sync::ReusableBoxFuture;
 use super::{connect_addrs::ConnectAddrs, error::ConnectError, ConnectInfo, Connection, Host};
 
 /// TCP connector service factory.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Clone, Copy, Default)]
+#[non_exhaustive]
 pub struct TcpConnector;
 
 impl TcpConnector {
     /// Returns a new TCP connector service.
     pub fn service(&self) -> TcpConnectorService {
-        TcpConnectorService
+        TcpConnectorService::default()
     }
 }
 
@@ -45,7 +46,8 @@ impl<R: Host> ServiceFactory<ConnectInfo<R>> for TcpConnector {
 }
 
 /// TCP connector service.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Default)]
+#[non_exhaustive]
 pub struct TcpConnectorService;
 
 impl<R: Host> Service<ConnectInfo<R>> for TcpConnectorService {