Upgrade to hyper 0.12:

- Use hyper's MakeService implementation with futures API
- Use tokio runtime to serve HTTP backend

Author: schrieveslaach

core/http/Cargo.toml

@@ -22,7 +22,9 @@ private-cookies = ["cookie/private", "cookie/key-expansion"]
 [dependencies]
 smallvec = "1.0"
 percent-encoding = "1"
-hyper = { version = "0.10.13", default-features = false }
+hyper = { version = "0.12.31", default-features = false, features = ["tokio"] }
+http = "0.1.17"
+mime = "0.3.13"
 time = "0.2.11"
 indexmap = "1.0"
 rustls = { version = "0.16", optional = true }

core/http/src/hyper.rs

@@ -4,72 +4,66 @@
 //! These types will, with certainty, be removed with time, but they reside here
 //! while necessary.
 
-#[doc(hidden)] pub use hyper::server::Request as Request;
-#[doc(hidden)] pub use hyper::server::Response as Response;
-#[doc(hidden)] pub use hyper::server::Server as Server;
-#[doc(hidden)] pub use hyper::server::Handler as Handler;
-
-#[doc(hidden)] pub use hyper::net;
-
-#[doc(hidden)] pub use hyper::method::Method;
-#[doc(hidden)] pub use hyper::status::StatusCode;
+#[doc(hidden)] pub use hyper::{Body, Request, Response};
+#[doc(hidden)] pub use hyper::body::Payload as Payload;
 #[doc(hidden)] pub use hyper::error::Error;
-#[doc(hidden)] pub use hyper::uri::RequestUri;
-#[doc(hidden)] pub use hyper::http::h1;
-#[doc(hidden)] pub use hyper::buffer;
+#[doc(hidden)] pub use hyper::server::Server;
+#[doc(hidden)] pub use hyper::service::{MakeService, Service};
+
+#[doc(hidden)] pub use hyper::Chunk;
+#[doc(hidden)] pub use http::header::HeaderName as HeaderName;
+#[doc(hidden)] pub use http::header::HeaderValue as HeaderValue;
+#[doc(hidden)] pub use http::method::Method;
+#[doc(hidden)] pub use http::request::Parts;
+#[doc(hidden)] pub use http::status::StatusCode;
+#[doc(hidden)] pub use http::uri::Uri;
 
 /// Type alias to `hyper::Response<'a, hyper::net::Fresh>`.
-#[doc(hidden)] pub type FreshResponse<'a> = self::Response<'a, self::net::Fresh>;
+// TODO #[doc(hidden)] pub type FreshResponse<'a> = self::Response<'a, self::net::Fresh>;
 
 /// Reexported Hyper header types.
 pub mod header {
     use crate::Header;
 
-    use hyper::header::Header as HyperHeaderTrait;
-
     macro_rules! import_hyper_items {
         ($($item:ident),*) => ($(pub use hyper::header::$item;)*)
     }
 
     macro_rules! import_hyper_headers {
         ($($name:ident),*) => ($(
-            impl std::convert::From<self::$name> for Header<'static> {
-                fn from(header: self::$name) -> Header<'static> {
-                    Header::new($name::header_name(), header.to_string())
-                }
-            }
+            pub use http::header::$name as $name;
         )*)
     }
 
-    import_hyper_items! {
-        Accept, AcceptCharset, AcceptEncoding, AcceptLanguage, AcceptRanges,
-        AccessControlAllowCredentials, AccessControlAllowHeaders,
-        AccessControlAllowMethods, AccessControlExposeHeaders,
-        AccessControlMaxAge, AccessControlRequestHeaders,
-        AccessControlRequestMethod, Allow, Authorization, Basic, Bearer,
-        CacheControl, Connection, ContentDisposition, ContentEncoding,
-        ContentLanguage, ContentLength, ContentRange, ContentType, Date, ETag,
-        EntityTag, Expires, From, Headers, Host, HttpDate, IfModifiedSince,
-        IfUnmodifiedSince, LastModified, Location, Origin, Prefer,
-        PreferenceApplied, Protocol, Quality, QualityItem, Referer,
-        StrictTransportSecurity, TransferEncoding, Upgrade, UserAgent,
-        AccessControlAllowOrigin, ByteRangeSpec, CacheDirective, Charset,
-        ConnectionOption, ContentRangeSpec, DispositionParam, DispositionType,
-        Encoding, Expect, IfMatch, IfNoneMatch, IfRange, Pragma, Preference,
-        ProtocolName, Range, RangeUnit, ReferrerPolicy, Vary, Scheme, q, qitem
-    }
-
+//    import_hyper_items! {
+//        Accept, AcceptCharset, AcceptEncoding, AcceptLanguage, AcceptRanges,
+//        AccessControlAllowCredentials, AccessControlAllowHeaders,
+//        AccessControlAllowMethods, AccessControlExposeHeaders,
+//        AccessControlMaxAge, AccessControlRequestHeaders,
+//        AccessControlRequestMethod, Allow, Authorization, Basic, Bearer,
+//        CacheControl, Connection, ContentDisposition, ContentEncoding,
+//        ContentLanguage, ContentLength, ContentRange, ContentType, Date, ETag,
+//        EntityTag, Expires, From, Headers, Host, HttpDate, IfModifiedSince,
+//        IfUnmodifiedSince, LastModified, Location, Origin, Prefer,
+//        PreferenceApplied, Protocol, Quality, QualityItem, Referer,
+//        StrictTransportSecurity, TransferEncoding, Upgrade, UserAgent,
+//        AccessControlAllowOrigin, ByteRangeSpec, CacheDirective, Charset,
+//        ConnectionOption, ContentRangeSpec, DispositionParam, DispositionType,
+//        Encoding, Expect, IfMatch, IfNoneMatch, IfRange, Pragma, Preference,
+//        ProtocolName, Range, RangeUnit, ReferrerPolicy, Vary, Scheme, q, qitem
+//    }
+//
     import_hyper_headers! {
-        Accept, AccessControlAllowCredentials, AccessControlAllowHeaders,
-        AccessControlAllowMethods, AccessControlAllowOrigin,
-        AccessControlExposeHeaders, AccessControlMaxAge,
-        AccessControlRequestHeaders, AccessControlRequestMethod, AcceptCharset,
-        AcceptEncoding, AcceptLanguage, AcceptRanges, Allow, CacheControl,
-        Connection, ContentDisposition, ContentEncoding, ContentLanguage,
-        ContentLength, ContentRange, Date, ETag, Expect, Expires, Host, IfMatch,
-        IfModifiedSince, IfNoneMatch, IfRange, IfUnmodifiedSince, LastModified,
-        Location, Origin, Pragma, Prefer, PreferenceApplied, Range, Referer,
-        ReferrerPolicy, StrictTransportSecurity, TransferEncoding, Upgrade,
-        UserAgent, Vary
+        ACCEPT, ACCESS_CONTROL_ALLOW_CREDENTIALS, ACCESS_CONTROL_ALLOW_HEADERS,
+        ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
+        ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_MAX_AGE,
+        ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD, ACCEPT_CHARSET,
+        ACCEPT_ENCODING, ACCEPT_LANGUAGE, ACCEPT_RANGES, ALLOW, CACHE_CONTROL,
+        CONNECTION, CONTENT_DISPOSITION, CONTENT_ENCODING, CONTENT_LANGUAGE,
+        CONTENT_LENGTH, CONTENT_RANGE, DATE, ETAG, EXPECT, EXPIRES, HOST, IF_MATCH,
+        IF_MODIFIED_SINCE, IF_NONE_MATCH, IF_RANGE, IF_UNMODIFIED_SINCE, LAST_MODIFIED,
+        LOCATION, ORIGIN, PRAGMA, RANGE, REFERER,
+        REFERRER_POLICY, STRICT_TRANSPORT_SECURITY, TRANSFER_ENCODING, UPGRADE,
+        USER_AGENT, VARY
     }
 }

core/http/src/method.rs

@@ -1,3 +1,5 @@
+extern crate http;
+
 use std::fmt;
 use std::str::FromStr;
 
@@ -24,18 +26,18 @@ pub enum Method {
 impl Method {
     /// WARNING: This is unstable! Do not use this method outside of Rocket!
     #[doc(hidden)]
-    pub fn from_hyp(method: &hyper::Method) -> Option<Method> {
+    pub fn from_hyp(method: &http::method::Method) -> Option<Method> {
         match *method {
-            hyper::Method::Get => Some(Get),
-            hyper::Method::Put => Some(Put),
-            hyper::Method::Post => Some(Post),
-            hyper::Method::Delete => Some(Delete),
-            hyper::Method::Options => Some(Options),
-            hyper::Method::Head => Some(Head),
-            hyper::Method::Trace => Some(Trace),
-            hyper::Method::Connect => Some(Connect),
-            hyper::Method::Patch => Some(Patch),
-            hyper::Method::Extension(_) => None,
+            http::method::Method::GET => Some(Get),
+            http::method::Method::PUT => Some(Put),
+            http::method::Method::POST => Some(Post),
+            http::method::Method::DELETE => Some(Delete),
+            http::method::Method::OPTIONS => Some(Options),
+            http::method::Method::HEAD => Some(Head),
+            http::method::Method::TRACE => Some(Trace),
+            http::method::Method::CONNECT => Some(Connect),
+            http::method::Method::PATCH => Some(Patch),
+            _ => None,
         }
     }
 

core/http/src/uri/uri.rs

@@ -94,6 +94,20 @@ impl<'a> Uri<'a> {
         crate::parse::uri::from_str(string)
     }
 
+//    pub fn from_hyp(uri: &'a hyper::Uri) -> Uri<'a> {
+//        match uri.is_absolute() {
+//            true => Uri::Absolute(Absolute::new(
+//                uri.scheme().unwrap(),
+//                match uri.host() {
+//                    Some(host) => Some(Authority::new(None, Host::Raw(host), uri.port())),
+//                    None => None
+//                },
+//                None
+//            )),
+//            false => Uri::Asterisk
+//        }
+//    }
+
     /// Returns the internal instance of `Origin` if `self` is a `Uri::Origin`.
     /// Otherwise, returns `None`.
     ///

core/lib/Cargo.toml

@@ -24,8 +24,10 @@ tls = ["rocket_http/tls"]
 private-cookies = ["rocket_http/private-cookies"]
 
 [dependencies]
+futures = "0.1"
 rocket_codegen = { version = "0.5.0-dev", path = "../codegen" }
 rocket_http = { version = "0.5.0-dev", path = "../http" }
+tokio = "0.1.16"
 yansi = "0.5"
 log = "0.4"
 toml = "0.4.7"

core/lib/src/catcher.rs

@@ -59,6 +59,7 @@ use yansi::Color::*;
 ///
 /// A function decorated with `catch` must take exactly zero or one arguments.
 /// If the catcher takes an argument, it must be of type [`&Request`](Request).
+#[derive(Clone)]
 pub struct Catcher {
     /// The HTTP status code to match against.
     pub code: u16,

core/lib/src/data/data.rs

@@ -5,20 +5,12 @@ use std::time::Duration;
 
 #[cfg(feature = "tls")] use super::net_stream::HttpsStream;
 
-use super::data_stream::{DataStream, kill_stream};
+use super::data_stream::{DataStream, /* TODO kill_stream */};
 use super::net_stream::NetStream;
 use crate::ext::ReadExt;
 
-use crate::http::hyper;
-use crate::http::hyper::h1::HttpReader;
-use crate::http::hyper::h1::HttpReader::*;
-use crate::http::hyper::net::{HttpStream, NetworkStream};
-
-pub type HyperBodyReader<'a, 'b> =
-    self::HttpReader<&'a mut hyper::buffer::BufReader<&'b mut dyn NetworkStream>>;
-
-//                              |---- from hyper ----|
-pub type BodyReader = HttpReader<Chain<Cursor<Vec<u8>>, NetStream>>;
+use crate::http::hyper::{self, Payload};
+use futures::{Async, Future};
 
 /// The number of bytes to read into the "peek" buffer.
 const PEEK_BYTES: usize = 512;
@@ -56,9 +48,7 @@ const PEEK_BYTES: usize = 512;
 /// body data. This enables partially or fully reading from a `Data` object
 /// without consuming the `Data` object.
 pub struct Data {
-    buffer: Vec<u8>,
-    is_complete: bool,
-    stream: BodyReader,
+    body: Vec<u8>,
 }
 
 impl Data {
@@ -79,62 +69,11 @@ impl Data {
     /// }
     /// ```
     pub fn open(mut self) -> DataStream {
-        let buffer = std::mem::replace(&mut self.buffer, vec![]);
-        let empty_stream = Cursor::new(vec![]).chain(NetStream::Empty);
-
         // FIXME: Insert a `BufReader` in front of the `NetStream` with capacity
         // 4096. We need the new `Chain` methods to get the inner reader to
         // actually do this, however.
-        let empty_http_stream = HttpReader::SizedReader(empty_stream, 0);
-        let stream = std::mem::replace(&mut self.stream, empty_http_stream);
-        DataStream(Cursor::new(buffer).chain(stream))
-    }
-
-    // FIXME: This is absolutely terrible (downcasting!), thanks to Hyper.
-    pub(crate) fn from_hyp(mut body: HyperBodyReader<'_, '_>) -> Result<Data, &'static str> {
-        #[inline(always)]
-        #[cfg(feature = "tls")]
-        fn concrete_stream(stream: &mut dyn NetworkStream) -> Option<NetStream> {
-            stream.downcast_ref::<HttpsStream>()
-                .map(|s| NetStream::Https(s.clone()))
-                .or_else(|| {
-                    stream.downcast_ref::<HttpStream>()
-                        .map(|s| NetStream::Http(s.clone()))
-                })
-        }
-
-        #[inline(always)]
-        #[cfg(not(feature = "tls"))]
-        fn concrete_stream(stream: &mut dyn NetworkStream) -> Option<NetStream> {
-            stream.downcast_ref::<HttpStream>()
-                .map(|s| NetStream::Http(s.clone()))
-        }
-
-        // Retrieve the underlying Http(s)Stream from Hyper.
-        let net_stream = match concrete_stream(*body.get_mut().get_mut()) {
-            Some(net_stream) => net_stream,
-            None => return Err("Stream is not an HTTP(s) stream!")
-        };
-
-        // Set the read timeout to 5 seconds.
-        let _ = net_stream.set_read_timeout(Some(Duration::from_secs(5)));
-
-        // Steal the internal, undecoded data buffer from Hyper.
-        let (mut hyper_buf, pos, cap) = body.get_mut().take_buf();
-        hyper_buf.truncate(cap); // slow, but safe
-        let mut cursor = Cursor::new(hyper_buf);
-        cursor.set_position(pos as u64);
-
-        // Create an HTTP reader from the buffer + stream.
-        let inner_data = cursor.chain(net_stream);
-        let http_stream = match body {
-            SizedReader(_, n) => SizedReader(inner_data, n),
-            EofReader(_) => EofReader(inner_data),
-            EmptyReader(_) => EmptyReader(inner_data),
-            ChunkedReader(_, n) => ChunkedReader(inner_data, n)
-        };
-
-        Ok(Data::new(http_stream))
+        let stream = ::std::mem::replace(&mut self.body, vec![]);
+        DataStream(Cursor::new(stream))
     }
 
     /// Retrieve the `peek` buffer.
@@ -155,10 +94,10 @@ impl Data {
     /// ```
     #[inline(always)]
     pub fn peek(&self) -> &[u8] {
-        if self.buffer.len() > PEEK_BYTES {
-            &self.buffer[..PEEK_BYTES]
+        if self.body.len() > PEEK_BYTES {
+            &self.body[..PEEK_BYTES]
         } else {
-            &self.buffer
+            &self.body
         }
     }
 
@@ -179,7 +118,8 @@ impl Data {
     /// ```
     #[inline(always)]
     pub fn peek_complete(&self) -> bool {
-        self.is_complete
+        // TODO self.is_complete
+        true
     }
 
     /// A helper method to write the body of the request to any `Write` type.
@@ -230,49 +170,8 @@ impl Data {
     // bytes `vec[pos..cap]` are buffered and unread. The remainder of the data
     // bytes can be read from `stream`.
     #[inline(always)]
-    pub(crate) fn new(mut stream: BodyReader) -> Data {
-        trace_!("Data::new({:?})", stream);
-        let mut peek_buf: Vec<u8> = vec![0; PEEK_BYTES];
-
-        // Fill the buffer with as many bytes as possible. If we read less than
-        // that buffer's length, we know we reached the EOF. Otherwise, it's
-        // unclear, so we just say we didn't reach EOF.
-        let eof = match stream.read_max(&mut peek_buf[..]) {
-            Ok(n) => {
-                trace_!("Filled peek buf with {} bytes.", n);
-                // We can use `set_len` here instead of `truncate`, but we'll
-                // take the performance hit to avoid `unsafe`. All of this code
-                // should go away when we migrate away from hyper 0.10.x.
-                peek_buf.truncate(n);
-                n < PEEK_BYTES
-            }
-            Err(e) => {
-                error_!("Failed to read into peek buffer: {:?}.", e);
-                // Likewise here as above.
-                peek_buf.truncate(0);
-                false
-            },
-        };
-
-        trace_!("Peek bytes: {}/{} bytes.", peek_buf.len(), PEEK_BYTES);
-        Data { buffer: peek_buf, stream, is_complete: eof }
-    }
-
-    /// This creates a `data` object from a local data source `data`.
-    #[inline]
-    pub(crate) fn local(data: Vec<u8>) -> Data {
-        let empty_stream = Cursor::new(vec![]).chain(NetStream::Empty);
-
-        Data {
-            buffer: data,
-            stream: HttpReader::SizedReader(empty_stream, 0),
-            is_complete: true,
-        }
+    pub(crate) fn new(body: Vec<u8>) -> Data {
+        Data { body }
     }
-}
 
-impl Drop for Data {
-    fn drop(&mut self) {
-        kill_stream(&mut self.stream);
-    }
 }