upgrade to tokio 0.2

actix-http/src/client/connection.rs

@@ -1,6 +1,6 @@
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use std::{fmt, io, time};
+use std::{fmt, io, mem, time};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use bytes::{Buf, Bytes};
@@ -228,7 +228,10 @@ where
         }
     }
 
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
+    unsafe fn prepare_uninitialized_buffer(
+        &self,
+        buf: &mut [mem::MaybeUninit<u8>],
+    ) -> bool {
         match self {
             EitherIo::A(ref val) => val.prepare_uninitialized_buffer(buf),
             EitherIo::B(ref val) => val.prepare_uninitialized_buffer(buf),

actix-http/src/client/connector.rs

@@ -17,10 +17,10 @@ use super::pool::{ConnectionPool, Protocol};
 use super::Connect;
 
 #[cfg(feature = "openssl")]
-use open_ssl::ssl::SslConnector as OpensslConnector;
+use actix_connect::ssl::openssl::SslConnector as OpensslConnector;
 
 #[cfg(feature = "rustls")]
-use rust_tls::ClientConfig;
+use actix_connect::ssl::rustls::ClientConfig;
 #[cfg(feature = "rustls")]
 use std::sync::Arc;
 
@@ -74,7 +74,7 @@ impl Connector<(), ()> {
         let ssl = {
             #[cfg(feature = "openssl")]
             {
-                use open_ssl::ssl::SslMethod;
+                use actix_connect::ssl::openssl::SslMethod;
 
                 let mut ssl = OpensslConnector::builder(SslMethod::tls()).unwrap();
                 let _ = ssl
@@ -87,9 +87,9 @@ impl Connector<(), ()> {
                 let protos = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
                 let mut config = ClientConfig::new();
                 config.set_protocols(&protos);
-                config
-                    .root_store
-                    .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
+                config.root_store.add_server_trust_anchors(
+                    &actix_connect::ssl::rustls::TLS_SERVER_ROOTS,
+                );
                 SslConnector::Rustls(Arc::new(config))
             }
             #[cfg(not(any(feature = "openssl", feature = "rustls")))]
@@ -242,12 +242,10 @@ where
         {
             const H2: &[u8] = b"h2";
             #[cfg(feature = "openssl")]
-            use actix_connect::ssl::OpensslConnector;
+            use actix_connect::ssl::openssl::OpensslConnector;
             #[cfg(feature = "rustls")]
-            use actix_connect::ssl::RustlsConnector;
+            use actix_connect::ssl::rustls::{RustlsConnector, Session};
             use actix_service::{boxed::service, pipeline};
-            #[cfg(feature = "rustls")]
-            use rust_tls::Session;
 
             let ssl_service = TimeoutService::new(
                 self.timeout,

actix-http/src/client/error.rs

@@ -1,10 +1,10 @@
 use std::io;
 
+use actix_connect::resolver::ResolveError;
 use derive_more::{Display, From};
-use trust_dns_resolver::error::ResolveError;
 
 #[cfg(feature = "openssl")]
-use open_ssl::ssl::{Error as SslError, HandshakeError};
+use actix_connect::ssl::openssl::{HandshakeError, SslError};
 
 use crate::error::{Error, ParseError, ResponseError};
 use crate::http::{Error as HttpError, StatusCode};
@@ -21,6 +21,11 @@ pub enum ConnectError {
     #[display(fmt = "{}", _0)]
     SslError(SslError),
 
+    /// SSL Handshake error
+    #[cfg(feature = "openssl")]
+    #[display(fmt = "{}", _0)]
+    SslHandshakeError(String),
+
     /// Failed to resolve the hostname
     #[display(fmt = "Failed resolving hostname: {}", _0)]
     Resolver(ResolveError),
@@ -63,13 +68,9 @@ impl From<actix_connect::ConnectError> for ConnectError {
 }
 
 #[cfg(feature = "openssl")]
-impl<T> From<HandshakeError<T>> for ConnectError {
+impl<T: std::fmt::Debug> From<HandshakeError<T>> for ConnectError {
     fn from(err: HandshakeError<T>) -> ConnectError {
-        match err {
-            HandshakeError::SetupFailure(stack) => SslError::from(stack).into(),
-            HandshakeError::Failure(stream) => stream.into_error().into(),
-            HandshakeError::WouldBlock(stream) => stream.into_error().into(),
-        }
+        ConnectError::SslHandshakeError(format!("{:?}", err))
     }
 }
 

actix-http/src/client/h1proto.rs

@@ -1,10 +1,11 @@
 use std::io::Write;
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use std::{io, time};
+use std::{io, mem, time};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use bytes::{BufMut, Bytes, BytesMut};
+use bytes::buf::BufMutExt;
+use bytes::{Bytes, BytesMut};
 use futures::future::poll_fn;
 use futures::{SinkExt, Stream, StreamExt};
 
@@ -43,7 +44,7 @@ where
                 Some(port) => write!(wrt, "{}:{}", host, port),
             };
 
-            match wrt.get_mut().take().freeze().try_into() {
+            match wrt.get_mut().split().freeze().try_into() {
                 Ok(value) => match head {
                     RequestHeadType::Owned(ref mut head) => {
                         head.headers.insert(HOST, value)
@@ -199,7 +200,10 @@ where
 }
 
 impl<T: AsyncRead + AsyncWrite + Unpin + 'static> AsyncRead for H1Connection<T> {
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
+    unsafe fn prepare_uninitialized_buffer(
+        &self,
+        buf: &mut [mem::MaybeUninit<u8>],
+    ) -> bool {
         self.io.as_ref().unwrap().prepare_uninitialized_buffer(buf)
     }
 

actix-http/src/client/h2proto.rs

@@ -1,3 +1,4 @@
+use std::convert::TryFrom;
 use std::time;
 
 use actix_codec::{AsyncRead, AsyncWrite};
@@ -5,7 +6,7 @@ use bytes::Bytes;
 use futures::future::poll_fn;
 use h2::{client::SendRequest, SendStream};
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
-use http::{request::Request, HttpTryFrom, Method, Version};
+use http::{request::Request, Method, Version};
 
 use crate::body::{BodySize, MessageBody};
 use crate::header::HeaderMap;

actix-http/src/client/pool.rs

@@ -108,7 +108,7 @@ where
         let inner = self.1.clone();
 
         let fut = async move {
-            let key = if let Some(authority) = req.uri.authority_part() {
+            let key = if let Some(authority) = req.uri.authority() {
                 authority.clone().into()
             } else {
                 return Err(ConnectError::Unresolverd);
@@ -299,7 +299,7 @@ where
     ) {
         let (tx, rx) = oneshot::channel();
 
-        let key: Key = connect.uri.authority_part().unwrap().clone().into();
+        let key: Key = connect.uri.authority().unwrap().clone().into();
         let entry = self.waiters.vacant_entry();
         let token = entry.key();
         entry.insert(Some((connect, tx)));