Merge pull request #35 from jbr/use-async-trait

Switch to using async_trait

Author: Fishrock123

Cargo.toml

@@ -37,6 +37,7 @@ async-native-tls = { version = "0.3.1", optional = true }
 # reqwest-client
 hyper = { version = "0.13.6", features = ["tcp"], optional = true }
 hyper-tls = { version = "0.4.3", optional = true }
+async-trait = "0.1.37"
 
 # isahc-client
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

src/h1.rs

@@ -1,9 +1,8 @@
 //! http-client implementation for async-h1.
 
-use super::{Error, HttpClient, Request, Response};
+use super::{async_trait, Error, HttpClient, Request, Response};
 
 use async_h1::client;
-use futures::future::BoxFuture;
 use http_types::StatusCode;
 
 /// Async-h1 based HTTP Client.
@@ -29,56 +28,55 @@ impl Clone for H1Client {
     }
 }
 
+#[async_trait]
 impl HttpClient for H1Client {
-    fn send(&self, mut req: Request) -> BoxFuture<'static, Result<Response, Error>> {
-        Box::pin(async move {
-            // Insert host
-            let host = req
-                .url()
-                .host_str()
-                .ok_or_else(|| Error::from_str(StatusCode::BadRequest, "missing hostname"))?
-                .to_string();
-
-            let scheme = req.url().scheme();
-            if scheme != "http" && scheme != "https" {
-                return Err(Error::from_str(
-                    StatusCode::BadRequest,
-                    format!("invalid url scheme '{}'", scheme),
-                ));
+    async fn send(&self, mut req: Request) -> Result<Response, Error> {
+        // Insert host
+        let host = req
+            .url()
+            .host_str()
+            .ok_or_else(|| Error::from_str(StatusCode::BadRequest, "missing hostname"))?
+            .to_string();
+
+        let scheme = req.url().scheme();
+        if scheme != "http" && scheme != "https" {
+            return Err(Error::from_str(
+                StatusCode::BadRequest,
+                format!("invalid url scheme '{}'", scheme),
+            ));
+        }
+
+        let addr = req
+            .url()
+            .socket_addrs(|| match req.url().scheme() {
+                "http" => Some(80),
+                "https" => Some(443),
+                _ => None,
+            })?
+            .into_iter()
+            .next()
+            .ok_or_else(|| Error::from_str(StatusCode::BadRequest, "missing valid address"))?;
+
+        log::trace!("> Scheme: {}", scheme);
+
+        match scheme {
+            "http" => {
+                let stream = async_std::net::TcpStream::connect(addr).await?;
+                req.set_peer_addr(stream.peer_addr().ok());
+                req.set_local_addr(stream.local_addr().ok());
+                client::connect(stream, req).await
             }
+            "https" => {
+                let raw_stream = async_std::net::TcpStream::connect(addr).await?;
+                req.set_peer_addr(raw_stream.peer_addr().ok());
+                req.set_local_addr(raw_stream.local_addr().ok());
 
-            let addr = req
-                .url()
-                .socket_addrs(|| match req.url().scheme() {
-                    "http" => Some(80),
-                    "https" => Some(443),
-                    _ => None,
-                })?
-                .into_iter()
-                .next()
-                .ok_or_else(|| Error::from_str(StatusCode::BadRequest, "missing valid address"))?;
-
-            log::trace!("> Scheme: {}", scheme);
-
-            match scheme {
-                "http" => {
-                    let stream = async_std::net::TcpStream::connect(addr).await?;
-                    req.set_peer_addr(stream.peer_addr().ok());
-                    req.set_local_addr(stream.local_addr().ok());
-                    client::connect(stream, req).await
-                }
-                "https" => {
-                    let raw_stream = async_std::net::TcpStream::connect(addr).await?;
-                    req.set_peer_addr(raw_stream.peer_addr().ok());
-                    req.set_local_addr(raw_stream.local_addr().ok());
-
-                    let stream = async_native_tls::connect(host, raw_stream).await?;
-
-                    client::connect(stream, req).await
-                }
-                _ => unreachable!(),
+                let stream = async_native_tls::connect(host, raw_stream).await?;
+
+                client::connect(stream, req).await
             }
-        })
+            _ => unreachable!(),
+        }
     }
 }
 

src/hyper.rs

@@ -1,6 +1,6 @@
 //! http-client implementation for reqwest
 
-use super::{Error, HttpClient, Request, Response};
+use super::{async_trait, Error, HttpClient, Request, Response};
 use http_types::headers::{HeaderName, HeaderValue};
 use http_types::StatusCode;
 use hyper::body::HttpBody;
@@ -21,29 +21,28 @@ impl HyperClient {
     }
 }
 
+#[async_trait]
 impl HttpClient for HyperClient {
-    fn send(&self, req: Request) -> futures::future::BoxFuture<'static, Result<Response, Error>> {
-        Box::pin(async move {
-            let req = HyperHttpRequest::try_from(req).await?.into_inner();
-            // UNWRAP: Scheme guaranteed to be "http" or "https" as part of conversion
-            let scheme = req.uri().scheme_str().unwrap();
-
-            let response = match scheme {
-                "http" => {
-                    let client = hyper::Client::builder().build_http::<hyper::Body>();
-                    client.request(req).await
-                }
-                "https" => {
-                    let https = HttpsConnector::new();
-                    let client = hyper::Client::builder().build::<_, hyper::Body>(https);
-                    client.request(req).await
-                }
-                _ => unreachable!(),
-            }?;
-
-            let resp = HttpTypesResponse::try_from(response).await?.into_inner();
-            Ok(resp)
-        })
+    async fn send(&self, req: Request) -> Result<Response, Error> {
+        let req = HyperHttpRequest::try_from(req).await?.into_inner();
+        // UNWRAP: Scheme guaranteed to be "http" or "https" as part of conversion
+        let scheme = req.uri().scheme_str().unwrap();
+
+        let response = match scheme {
+            "http" => {
+                let client = hyper::Client::builder().build_http::<hyper::Body>();
+                client.request(req).await
+            }
+            "https" => {
+                let https = HttpsConnector::new();
+                let client = hyper::Client::builder().build::<_, hyper::Body>(https);
+                client.request(req).await
+            }
+            _ => unreachable!(),
+        }?;
+
+        let resp = HttpTypesResponse::try_from(response).await?.into_inner();
+        Ok(resp)
     }
 }
 

src/isahc.rs

@@ -1,9 +1,8 @@
 //! http-client implementation for isahc
 
-use super::{Body, Error, HttpClient, Request, Response};
+use super::{async_trait, Body, Error, HttpClient, Request, Response};
 
 use async_std::io::BufReader;
-use futures::future::BoxFuture;
 use isahc::http;
 use std::sync::Arc;
 
@@ -41,8 +40,9 @@ impl Clone for IsahcClient {
     }
 }
 
+#[async_trait]
 impl HttpClient for IsahcClient {
-    fn send(&self, mut req: Request) -> BoxFuture<'static, Result<Response, Error>> {
+    async fn send(&self, mut req: Request) -> Result<Response, Error> {
         let client = self.client.clone();
         Box::pin(async move {
             let mut builder = http::Request::builder()

src/lib.rs

@@ -14,8 +14,6 @@
     forbid(unsafe_code)
 )]
 
-use futures::future::BoxFuture;
-
 #[cfg_attr(feature = "docs", doc(cfg(curl_client)))]
 #[cfg(all(feature = "curl_client", not(target_arch = "wasm32")))]
 pub mod isahc;
@@ -42,6 +40,7 @@ pub type Request = http_types::Request;
 /// An HTTP Response type with a streaming body.
 pub type Response = http_types::Response;
 
+pub use async_trait::async_trait;
 pub use http_types;
 
 /// An abstract HTTP client.
@@ -56,9 +55,10 @@ pub use http_types;
 /// new requests. In order to enable this efficiently an `HttpClient` instance may want to be passed
 /// though middleware for one of its own requests, and in order to do so should be wrapped in an
 /// `Rc`/`Arc` to enable reference cloning.
+#[async_trait]
 pub trait HttpClient: std::fmt::Debug + Unpin + Send + Sync + 'static {
     /// Perform a request.
-    fn send(&self, req: Request) -> BoxFuture<'static, Result<Response, Error>>;
+    async fn send(&self, req: Request) -> Result<Response, Error>;
 }
 
 /// The raw body of an http request or response.

src/wasm.rs

@@ -2,7 +2,6 @@
 
 use super::{http_types::Headers, Body, Error, HttpClient, Request, Response};
 
-use futures::future::BoxFuture;
 use futures::prelude::*;
 
 use std::convert::TryFrom;
@@ -29,8 +28,15 @@ impl Clone for WasmClient {
 }
 
 impl HttpClient for WasmClient {
-    fn send(&self, req: Request) -> BoxFuture<'static, Result<Response, Error>> {
-        let fut = Box::pin(async move {
+    fn send<'a, 'async_trait>(
+        &'a self,
+        req: Request,
+    ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>>
+    where
+        'a: 'async_trait,
+        Self: 'async_trait,
+    {
+        InnerFuture::new(async move {
             let req: fetch::Request = fetch::Request::new(req).await?;
             let mut res = req.send().await?;
 
@@ -44,16 +50,20 @@ impl HttpClient for WasmClient {
             }
 
             Ok(response)
-        });
-
-        Box::pin(InnerFuture { fut })
+        })
     }
 }
 
 struct InnerFuture {
     fut: Pin<Box<dyn Future<Output = Result<Response, Error>> + 'static>>,
 }
 
+impl InnerFuture {
+    fn new<F: Future<Output = Result<Response, Error>> + 'static>(fut: F) -> Pin<Box<Self>> {
+        Box::pin(Self { fut: Box::pin(fut) })
+    }
+}
+
 // This is safe because WASM doesn't have threads yet. Once WASM supports threads we should use a
 // thread to park the blocking implementation until it's been completed.
 unsafe impl Send for InnerFuture {}