feat(lib): implement compatibility with http crate

hyperium · Sep 22, 2017 · 0c7d375 · 0c7d375
1 parent 92595e8
commit 0c7d375
Show file tree

Hide file tree

Showing 17 changed files with 535 additions and 1 deletion.
diff --git a/.travis.yml b/.travis.yml
@@ -8,6 +8,8 @@ matrix:
  env: FEATURES="--features nightly"
  - rust: beta
  - rust: stable
+ - rust: stable
+ env: FEATURES="--features compat"
  - rust: 1.15.0
 
 cache:

diff --git a/Cargo.toml b/Cargo.toml
@@ -23,6 +23,7 @@ base64 = "0.6"
 bytes = "0.4.4"
 futures = "0.1.14"
 futures-cpupool = "0.1"
+http = { version = "0.1", optional = true }
 httparse = "1.0"
 language-tags = "0.2"
 log = "0.3"
@@ -45,3 +46,4 @@ spmc = "0.2"
 default = []
 nightly = []
 raw_status = []
+compat = [ "http" ]
diff --git a/src/client/compat.rs b/src/client/compat.rs
@@ -0,0 +1,6 @@
+//! Wrappers to build compatibility with the `http` crate.
+
+pub use super::compat_impl::{
+ CompatClient,
+ CompatFutureResponse
+};
diff --git a/src/client/compat_impl.rs b/src/client/compat_impl.rs
@@ -0,0 +1,53 @@
+use futures::{Future, Poll, Stream};
+use http_types;
+use tokio_service::Service;
+
+use client::{Connect, Client, FutureResponse};
+use error::Error;
+use http::Body;
+
+/// A Client to make outgoing HTTP requests.
+#[derive(Debug)]
+pub struct CompatClient<C, B = Body> {
+ inner: Client<C, B>
+}
+
+pub fn client<C, B>(client: Client<C, B>) -> CompatClient<C, B> {
+ CompatClient { inner: client }
+}
+
+impl<C, B> Service for CompatClient<C, B>
+where C: Connect,
+ B: Stream<Error=Error> + 'static,
+ B::Item: AsRef<[u8]>,
+{
+ type Request = http_types::Request<B>;
+ type Response = http_types::Response<Body>;
+ type Error = Error;
+ type Future = CompatFutureResponse;
+
+ fn call(&self, req: Self::Request) -> Self::Future {
+ future(self.inner.call(req.into()))
+ }
+}
+
+/// A `Future` that will resolve to an `http::Response`.
+#[must_use = "futures do nothing unless polled"]
+#[derive(Debug)]
+pub struct CompatFutureResponse {
+ inner: FutureResponse
+}
+
+pub fn future(fut: FutureResponse) -> CompatFutureResponse {
+ CompatFutureResponse { inner: fut }
+}
+
+impl Future for CompatFutureResponse {
+ type Item = http_types::Response<Body>;
+ type Error = Error;
+
+ fn poll(&mut self) -> Poll<Self::Item, Error> {
+ self.inner.poll()
+ .map(|a| a.map(|r| r.into()))
+ }
+}
diff --git a/src/client/mod.rs b/src/client/mod.rs
@@ -9,6 +9,8 @@ use std::time::Duration;
 
 use futures::{future, Poll, Async, Future, Stream};
 use futures::unsync::oneshot;
+#[cfg(feature = "compat")]
+use http_types;
 use tokio_io::{AsyncRead, AsyncWrite};
 use tokio::reactor::Handle;
 use tokio_proto::BindClient;
@@ -33,6 +35,10 @@ pub use self::connect::{HttpConnector, Connect};
 mod connect;
 mod dns;
 mod pool;
+#[cfg(feature = "compat")]
+mod compat_impl;
+#[cfg(feature = "compat")]
+pub mod compat;
 
 /// A Client to make outgoing HTTP requests.
 // If the Connector is clone, then the Client can be clone easily.
@@ -108,6 +114,19 @@ where C: Connect,
  pub fn request(&self, req: Request<B>) -> FutureResponse {
  self.call(req)
  }
+
+ /// Send an `http::Request` using this Client.
+ #[inline]
+ #[cfg(feature = "compat")]
+ pub fn request_compat(&self, req: http_types::Request<B>) -> compat::CompatFutureResponse {
+ self::compat_impl::future(self.call(req.into()))
+ }
+
+ /// Convert into a client accepting `http::Request`.
+ #[cfg(feature = "compat")]
+ pub fn into_compat(self) -> compat::CompatClient<C, B> {
+ self::compat_impl::client(self)
+ }
 }
 
 /// A `Future` that will resolve to an HTTP Response.

diff --git a/src/common/str.rs b/src/common/str.rs
@@ -29,6 +29,11 @@ impl ByteStr {
  pub fn as_str(&self) -> &str {
  unsafe { str::from_utf8_unchecked(self.0.as_ref()) }
  }
+
+ #[cfg(feature = "compat")]
+ pub fn into_bytes(self) -> Bytes {
+ self.0
+ }
 }
 
 impl Deref for ByteStr {

diff --git a/src/header/mod.rs b/src/header/mod.rs
@@ -77,9 +77,14 @@
 //! }
 //! ```
 use std::borrow::{Cow, ToOwned};
+#[cfg(feature = "compat")]
+use std::convert::From;
 use std::iter::{FromIterator, IntoIterator};
 use std::{mem, fmt};
 
+#[cfg(feature = "compat")]
+use http_types;
+
 use unicase::Ascii;
 
 use self::internals::{Item, VecMap, Entry};
@@ -546,6 +551,54 @@ impl fmt::Debug for Headers {
  }
 }
 
+#[cfg(feature = "compat")]
+impl From<http_types::HeaderMap> for Headers {
+ fn from(mut header_map: http_types::HeaderMap) -> Headers {
+ let mut headers = Headers::new();
+ for (name, mut value_drain) in header_map.drain() {
+ if let Some(first_value) = value_drain.next() {
+ let mut raw: Raw = first_value.as_bytes().into();
+ for value in value_drain {
+ raw.push(value.as_bytes());
+ }
+ headers.append_raw(name.as_str().to_string(), raw); 
+ }
+ }
+ headers
+ }
+}
+
+#[cfg(feature = "compat")]
+impl From<Headers> for http_types::HeaderMap {
+ fn from(headers: Headers) -> http_types::HeaderMap {
+ let mut header_map = http_types::HeaderMap::new();
+ for header in headers.iter() {
+ let entry = header_map.entry(header.name())
+ .expect("attempted to convert invalid header name");
+ let mut value_iter = header.raw().iter().map(|line| {
+ http_types::header::HeaderValue::from_bytes(line)
+ .expect("attempted to convert invalid header value")
+ });
+ match entry {
+ http_types::header::Entry::Occupied(mut occupied) => {
+ for value in value_iter {
+ occupied.append(value);
+ }
+ },
+ http_types::header::Entry::Vacant(vacant) => {
+ if let Some(first_value) = value_iter.next() {
+ let mut occupied = vacant.insert_entry(first_value);
+ for value in value_iter {
+ occupied.append(value);
+ }
+ }
+ }
+ }
+ }
+ header_map
+ }
+}
+
 /// An `Iterator` over the fields in a `Headers` map.
 #[allow(missing_debug_implementations)]
 pub struct HeadersItems<'a> {
@@ -940,6 +993,29 @@ mod tests {
  assert_ne!(headers1, headers2);
  }
 
+ #[test]
+ #[cfg(feature = "compat")]
+ fn test_compat() {
+ use http_types;
+
+ let mut orig_hyper_headers = Headers::new();
+ orig_hyper_headers.set(ContentLength(11));
+ orig_hyper_headers.set(Host::new("foo.bar", None));
+ orig_hyper_headers.append_raw("x-foo", b"bar".to_vec());
+ orig_hyper_headers.append_raw("x-foo", b"quux".to_vec());
+
+ let mut orig_http_headers = http_types::HeaderMap::new();
+ orig_http_headers.insert(http_types::header::CONTENT_LENGTH, "11".parse().unwrap());
+ orig_http_headers.insert(http_types::header::HOST, "foo.bar".parse().unwrap());
+ orig_http_headers.append("x-foo", "bar".parse().unwrap());
+ orig_http_headers.append("x-foo", "quux".parse().unwrap());
+
+ let conv_hyper_headers: Headers = orig_http_headers.clone().into();
+ let conv_http_headers: http_types::HeaderMap = orig_hyper_headers.clone().into();
+ assert_eq!(orig_hyper_headers, conv_hyper_headers);
+ assert_eq!(orig_http_headers, conv_http_headers);
+ }
+
  #[cfg(feature = "nightly")]
  #[bench]
  fn bench_headers_new(b: &mut Bencher) {

diff --git a/src/http/request.rs b/src/http/request.rs
@@ -1,11 +1,16 @@
 use std::fmt;
+#[cfg(feature = "compat")]
+use std::mem::replace;
+use std::net::SocketAddr;
+
+#[cfg(feature = "compat")]
+use http_types;
 
 use header::Headers;
 use http::{Body, MessageHead, RequestHead, RequestLine};
 use method::Method;
 use uri::{self, Uri};
 use version::HttpVersion;
-use std::net::SocketAddr;
 
 /// An HTTP Request
 pub struct Request<B = Body> {
@@ -132,6 +137,36 @@ impl<B> fmt::Debug for Request<B> {
  }
 }
 
+#[cfg(feature = "compat")]
+impl From<Request> for http_types::Request<Body> {
+ fn from(from_req: Request) -> http_types::Request<Body> {
+ let (m, u, v, h, b) = from_req.deconstruct();
+
+ let to_req = http_types::Request::new(());
+ let (mut to_parts, _) = to_req.into_parts();
+
+ to_parts.method = m.into();
+ to_parts.uri = u.into();
+ to_parts.version = v.into();
+ to_parts.headers = h.into();
+
+ http_types::Request::from_parts(to_parts, b)
+ }
+}
+
+#[cfg(feature = "compat")]
+impl<B> From<http_types::Request<B>> for Request<B> {
+ fn from(from_req: http_types::Request<B>) -> Request<B> {
+ let (from_parts, body) = from_req.into_parts();
+
+ let mut to_req = Request::new(from_parts.method.into(), from_parts.uri.into());
+ to_req.set_version(from_parts.version.into());
+ replace(to_req.headers_mut(), from_parts.headers.into());
+ to_req.set_body(body);
+ to_req
+ }
+}
+
 /// Constructs a request using a received ResponseHead and optional body
 pub fn from_wire<B>(addr: Option<SocketAddr>, incoming: RequestHead, body: B) -> Request<B> {
  let MessageHead { version, subject: RequestLine(method, uri), headers } = incoming;

diff --git a/src/http/response.rs b/src/http/response.rs
@@ -1,4 +1,9 @@
 use std::fmt;
+#[cfg(feature = "compat")]
+use std::mem::replace;
+
+#[cfg(feature = "compat")]
+use http_types;
 
 use header::{Header, Headers};
 use http::{MessageHead, ResponseHead, Body};
@@ -142,6 +147,30 @@ impl fmt::Debug for Response {
  }
 }
 
+#[cfg(feature = "compat")]
+impl<B> From<http_types::Response<B>> for Response<B> {
+ fn from(from_res: http_types::Response<B>) -> Response<B> {
+ let (from_parts, body) = from_res.into_parts();
+ let mut to_res = Response::new();
+ to_res.version = from_parts.version.into();
+ to_res.set_status(from_parts.status.into());
+ replace(to_res.headers_mut(), from_parts.headers.into());
+ to_res.with_body(body)
+ }
+}
+
+#[cfg(feature = "compat")]
+impl From<Response> for http_types::Response<Body> {
+ fn from(mut from_res: Response) -> http_types::Response<Body> {
+ let (mut to_parts, ()) = http_types::Response::new(()).into_parts();
+ to_parts.version = from_res.version().into();
+ to_parts.status = from_res.status().into();
+ let from_headers = replace(from_res.headers_mut(), Headers::new());
+ to_parts.headers = from_headers.into();
+ http_types::Response::from_parts(to_parts, from_res.body())
+ }
+}
+
 /// Constructs a response using a received ResponseHead and optional body
 #[inline]
 #[cfg(not(feature = "raw_status"))]

diff --git a/src/lib.rs b/src/lib.rs
@@ -21,6 +21,8 @@ extern crate base64;
 extern crate bytes;
 #[macro_use] extern crate futures;
 extern crate futures_cpupool;
+#[cfg(feature = "compat")]
+extern crate http as http_types;
 extern crate httparse;
 extern crate language_tags;
 #[macro_use] extern crate log;