Update Dependencies to support Rust Beta

Since async await is now stable on Rust Beta 1.39, using the futures
ecosystem should work just fine, except there's still many crates that
have #![feature(async_await)] somewhere in their dependency graph. Most
crates have been updated by now. This updates hyper-rustls as well.

Author: CryZe

Cargo.toml

@@ -12,16 +12,16 @@ repository = "https://github.com/ctz/hyper-rustls"
 [dependencies]
 bytes = "0.4"
 ct-logs = { version = "^0.6.0", optional = true }
-futures-preview = { version = "0.3.0-alpha.18", features = ["async-await", "nightly"] }
-hyper = { version = "0.13.0-alpha.1", default-features = false }
+futures-util-preview = { version = "0.3.0-alpha.19" }
+hyper = { version = "0.13.0-alpha.4", default-features = false, features = ["unstable-stream"] }
 rustls = "0.16"
-tokio-io = { version="0.2.0-alpha.2" }
-tokio-rustls = "0.12.0-alpha.1"
+tokio-io = { version="0.2.0-alpha.6" }
+tokio-rustls = "0.12.0-alpha.4"
 webpki = "^0.21.0"
 rustls-native-certs = { version = "^0.1.0", optional = true }
 
 [dev-dependencies]
-tokio = "0.2.0-alpha.2"
+tokio = "0.2.0-alpha.6"
 
 [features]
 default = ["tokio-runtime"]

examples/client.rs

@@ -2,9 +2,8 @@
 //!
 //! First parameter is the mandatory URL to GET.
 //! Second parameter is an optional path to CA store.
-#![feature(async_await)]
-use futures::TryStreamExt;
-use hyper::{client, Uri, Body, Chunk};
+use futures_util::TryStreamExt;
+use hyper::{client, Body, Chunk, Uri};
 use std::str::FromStr;
 use std::{env, fs, io};
 
@@ -67,16 +66,18 @@ async fn run_client() -> io::Result<()> {
     // the returned headers, collects the whole body and prints it to
     // stdout.
     let fut = async move {
-        let res = client.get(url).await.map_err(|e| {
-            error(format!("Could not get: {:?}", e))
-        })?;
+        let res = client
+            .get(url)
+            .await
+            .map_err(|e| error(format!("Could not get: {:?}", e)))?;
         println!("Status:\n{}", res.status());
         println!("Headers:\n{:#?}", res.headers());
 
         let body: Body = res.into_body();
-        let body: Chunk = body.try_concat().await.map_err(|e| {
-            error(format!("Could not get body: {:?}", e))
-        })?;
+        let body: Chunk = body
+            .try_concat()
+            .await
+            .map_err(|e| error(format!("Could not get body: {:?}", e)))?;
         println!("Body:\n{}", String::from_utf8_lossy(&body));
 
         Ok(())

examples/server.rs

@@ -2,8 +2,12 @@
 //!
 //! First parameter is the mandatory port to use.
 //! Certificate and private key are hardcoded to sample files.
-#![feature(async_await)]
-use futures::{Stream, StreamExt, TryFutureExt, TryStreamExt};
+use core::task::{Context, Poll};
+use futures_util::{
+    stream::{Stream, StreamExt},
+    try_future::TryFutureExt,
+    try_stream::TryStreamExt,
+};
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Method, Request, Response, Server, StatusCode};
 use rustls::internal::pemfile;
@@ -66,14 +70,33 @@ async fn run_server() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             .boxed();
 
     let service = make_service_fn(|_| async { Ok::<_, io::Error>(service_fn(echo)) });
-    let server = Server::builder(incoming_tls_stream).serve(service);
+    let server = Server::builder(HyperAcceptor {
+        acceptor: incoming_tls_stream,
+    })
+    .serve(service);
 
     // Run the future, keep going until an error occurs.
     println!("Starting to serve on https://{}.", addr);
     server.await?;
     Ok(())
 }
 
+struct HyperAcceptor {
+    acceptor: Pin<Box<dyn Stream<Item = Result<TlsStream<TcpStream>, io::Error>>>>,
+}
+
+impl hyper::server::accept::Accept for HyperAcceptor {
+    type Conn = TlsStream<TcpStream>;
+    type Error = io::Error;
+
+    fn poll_accept(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context,
+    ) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
+        Pin::new(&mut self.acceptor).poll_next(cx)
+    }
+}
+
 // Custom echo service, handling two different routes and a
 // catch-all 404 responder.
 async fn echo(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {

src/connector.rs

@@ -1,4 +1,4 @@
-use futures::FutureExt;
+use futures_util::FutureExt;
 use hyper::client::connect::{self, Connect};
 #[cfg(feature = "tokio-runtime")]
 use hyper::client::HttpConnector;
@@ -70,7 +70,16 @@ where
 {
     type Transport = MaybeHttpsStream<T::Transport>;
     type Error = io::Error;
-    type Future = Pin<Box<dyn Future<Output = Result<(MaybeHttpsStream<T::Transport>, connect::Connected), io::Error>> + Send>>;
+    type Future = Pin<
+        Box<
+            dyn Future<
+                    Output = Result<
+                        (MaybeHttpsStream<T::Transport>, connect::Connected),
+                        io::Error,
+                    >,
+                > + Send,
+        >,
+    >;
 
     fn connect(&self, dst: connect::Destination) -> Self::Future {
         let is_https = dst.scheme() == "https";
@@ -92,12 +101,12 @@ where
             let f = async move {
                 let (tcp, conn) = connecting_future.await?;
                 let connector = TlsConnector::from(cfg);
-                let dnsname = DNSNameRef::try_from_ascii_str(&hostname).map_err(|_| {
-                    io::Error::new(io::ErrorKind::Other, "invalid dnsname")
-                })?;
-                let tls = connector.connect(dnsname, tcp).await.map_err(|e| {
-                    io::Error::new(io::ErrorKind::Other, e)
-                })?;
+                let dnsname = DNSNameRef::try_from_ascii_str(&hostname)
+                    .map_err(|_| io::Error::new(io::ErrorKind::Other, "invalid dnsname"))?;
+                let tls = connector
+                    .connect(dnsname, tcp)
+                    .await
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
                 let connected = if tls.get_ref().1.get_alpn_protocol() == Some(b"h2") {
                     conn.negotiated_h2()
                 } else {