Linting

Cargo.toml

@@ -41,5 +41,4 @@ members = [
   "examples/tls",
   "examples/fairings",
   "examples/hello_2018",
-  "examples/hello_2015",
 ]

contrib/lib/Cargo.toml

@@ -42,6 +42,7 @@ memcache_pool = ["databases", "memcache", "r2d2-memcache"]
 
 [dependencies]
 # Global dependencies.
+futures-preview = { version = "0.3.0-alpha.18" }
 rocket_contrib_codegen = { version = "0.5.0-dev", path = "../codegen", optional = true }
 rocket = { version = "0.5.0-dev", path = "../../core/lib/", default-features = false }
 log = "0.4"

contrib/lib/src/helmet/helmet.rs

@@ -196,8 +196,10 @@ impl Fairing for SpaceHelmet {
         }
     }
 
-    fn on_response(&self, _request: &Request<'_>, response: &mut Response<'_>) {
-        self.apply(response);
+    fn on_response<'a>(&'a self, _request: &'a Request<'_>, response: &'a mut Response<'_>) -> std::pin::Pin<Box<dyn std::future::Future<Output=()> + Send + 'a>> {
+        Box::pin(async move {
+            self.apply(response);
+        })
     }
 
     fn on_launch(&self, rocket: &Rocket) {

contrib/lib/src/json.rs

@@ -15,14 +15,17 @@
 //! ```
 
 use std::ops::{Deref, DerefMut};
-use std::io::{self, Read};
+use std::io;
 use std::iter::FromIterator;
 
+use futures::io::AsyncReadExt;
+
 use rocket::request::Request;
 use rocket::outcome::Outcome::*;
-use rocket::data::{Outcome, Transform, Transform::*, Transformed, Data, FromData};
+use rocket::data::{Transform::*, Transformed, Data, FromData, TransformFuture, FromDataFuture};
 use rocket::response::{self, Responder, content};
 use rocket::http::Status;
+use rocket::AsyncReadExt as _;
 
 use serde::{Serialize, Serializer};
 use serde::de::{Deserialize, Deserializer};
@@ -133,42 +136,48 @@ impl<'a, T: Deserialize<'a>> FromData<'a> for Json<T> {
     type Owned = String;
     type Borrowed = str;
 
-    fn transform(r: &Request<'_>, d: Data) -> Transform<Outcome<Self::Owned, Self::Error>> {
+    fn transform(r: &Request<'_>, d: Data) -> TransformFuture<'a, Self::Owned, Self::Error> {
         let size_limit = r.limits().get("json").unwrap_or(LIMIT);
-        let mut s = String::with_capacity(512);
-        match d.open().take(size_limit).read_to_string(&mut s) {
-            Ok(_) => Borrowed(Success(s)),
-            Err(e) => Borrowed(Failure((Status::BadRequest, JsonError::Io(e))))
-        }
+        Box::pin(async move {
+            let mut s = String::with_capacity(512);
+            let mut reader = d.open().take(size_limit);
+            match reader.read_to_string(&mut s).await {
+                Ok(_) => Borrowed(Success(s)),
+                Err(e) => Borrowed(Failure((Status::BadRequest, JsonError::Io(e))))
+            }
+        })
     }
 
-    fn from_data(_: &Request<'_>, o: Transformed<'a, Self>) -> Outcome<Self, Self::Error> {
-        let string = o.borrowed()?;
-        match serde_json::from_str(&string) {
-            Ok(v) => Success(Json(v)),
-            Err(e) => {
-                error_!("Couldn't parse JSON body: {:?}", e);
-                if e.is_data() {
-                    Failure((Status::UnprocessableEntity, JsonError::Parse(string, e)))
-                } else {
-                    Failure((Status::BadRequest, JsonError::Parse(string, e)))
+    fn from_data(_: &Request<'_>, o: Transformed<'a, Self>) -> FromDataFuture<'a, Self, Self::Error> {
+        Box::pin(async move {
+            let string = o.borrowed()?;
+            match serde_json::from_str(&string) {
+                Ok(v) => Success(Json(v)),
+                Err(e) => {
+                    error_!("Couldn't parse JSON body: {:?}", e);
+                    if e.is_data() {
+                        Failure((Status::UnprocessableEntity, JsonError::Parse(string, e)))
+                    } else {
+                        Failure((Status::BadRequest, JsonError::Parse(string, e)))
+                    }
                 }
             }
-        }
+        })
     }
 }
 
 /// Serializes the wrapped value into JSON. Returns a response with Content-Type
 /// JSON and a fixed-size body with the serialized value. If serialization
 /// fails, an `Err` of `Status::InternalServerError` is returned.
-impl<'a, T: Serialize> Responder<'a> for Json<T> {
-    fn respond_to(self, req: &Request<'_>) -> response::Result<'a> {
-        serde_json::to_string(&self.0).map(|string| {
-            content::Json(string).respond_to(req).unwrap()
-        }).map_err(|e| {
-            error_!("JSON failed to serialize: {:?}", e);
-            Status::InternalServerError
-        })
+impl<'r, T: Serialize> Responder<'r> for Json<T> {
+    fn respond_to(self, req: &'r Request<'_>) -> response::ResultFuture<'r> {
+        match serde_json::to_string(&self.0) {
+            Ok(string) => Box::pin(async move { Ok(content::Json(string).respond_to(req).await.unwrap()) }),
+            Err(e) => Box::pin(async move {
+                error_!("JSON failed to serialize: {:?}", e);
+                Err(Status::InternalServerError)
+            })
+        }
     }
 }
 
@@ -283,9 +292,9 @@ impl<T> FromIterator<T> for JsonValue where serde_json::Value: FromIterator<T> {
 
 /// Serializes the value into JSON. Returns a response with Content-Type JSON
 /// and a fixed-size body with the serialized value.
-impl<'a> Responder<'a> for JsonValue {
+impl<'r> Responder<'r> for JsonValue {
     #[inline]
-    fn respond_to(self, req: &Request<'_>) -> response::Result<'a> {
+    fn respond_to(self, req: &'r Request<'_>) -> response::ResultFuture<'r> {
         content::Json(self.0.to_string()).respond_to(req)
     }
 }

contrib/lib/src/msgpack.rs

@@ -14,14 +14,16 @@
 //! features = ["msgpack"]
 //! ```
 
-use std::io::Read;
 use std::ops::{Deref, DerefMut};
 
+use futures::io::AsyncReadExt;
+
 use rocket::request::Request;
 use rocket::outcome::Outcome::*;
-use rocket::data::{Outcome, Transform, Transform::*, Transformed, Data, FromData};
-use rocket::response::{self, Responder, content};
+use rocket::data::{Data, FromData, FromDataFuture, Transform::*, TransformFuture, Transformed};
 use rocket::http::Status;
+use rocket::response::{self, content, Responder};
+use rocket::AsyncReadExt as _;
 
 use serde::Serialize;
 use serde::de::Deserialize;
@@ -119,45 +121,52 @@ impl<'a, T: Deserialize<'a>> FromData<'a> for MsgPack<T> {
     type Owned = Vec<u8>;
     type Borrowed = [u8];
 
-    fn transform(r: &Request<'_>, d: Data) -> Transform<Outcome<Self::Owned, Self::Error>> {
-        let mut buf = Vec::new();
+    fn transform(r: &Request<'_>, d: Data) -> TransformFuture<'a, Self::Owned, Self::Error> {
         let size_limit = r.limits().get("msgpack").unwrap_or(LIMIT);
-        match d.open().take(size_limit).read_to_end(&mut buf) {
-            Ok(_) => Borrowed(Success(buf)),
-            Err(e) => Borrowed(Failure((Status::BadRequest, Error::InvalidDataRead(e))))
-        }
+
+        Box::pin(async move {
+            let mut buf = Vec::new();
+            let mut reader = d.open().take(size_limit);
+            match reader.read_to_end(&mut buf).await {
+                Ok(_) => Borrowed(Success(buf)),
+                Err(e) => Borrowed(Failure((Status::BadRequest, Error::InvalidDataRead(e)))),
+            }
+        })
     }
 
-    fn from_data(_: &Request<'_>, o: Transformed<'a, Self>) -> Outcome<Self, Self::Error> {
+    fn from_data(_: &Request<'_>, o: Transformed<'a, Self>) -> FromDataFuture<'a, Self, Self::Error> {
         use self::Error::*;
 
-        let buf = o.borrowed()?;
-        match rmp_serde::from_slice(&buf) {
-            Ok(val) => Success(MsgPack(val)),
-            Err(e) => {
-                error_!("Couldn't parse MessagePack body: {:?}", e);
-                match e {
-                    TypeMismatch(_) | OutOfRange | LengthMismatch(_) => {
-                        Failure((Status::UnprocessableEntity, e))
+        Box::pin(async move {
+            let buf = o.borrowed()?;
+            match rmp_serde::from_slice(&buf) {
+                Ok(val) => Success(MsgPack(val)),
+                Err(e) => {
+                    error_!("Couldn't parse MessagePack body: {:?}", e);
+                    match e {
+                        TypeMismatch(_) | OutOfRange | LengthMismatch(_) => {
+                            Failure((Status::UnprocessableEntity, e))
+                        }
+                        _ => Failure((Status::BadRequest, e)),
                     }
-                    _ => Failure((Status::BadRequest, e))
                 }
             }
-        }
+        })
     }
 }
 
 /// Serializes the wrapped value into MessagePack. Returns a response with
 /// Content-Type `MsgPack` and a fixed-size body with the serialization. If
 /// serialization fails, an `Err` of `Status::InternalServerError` is returned.
-impl<T: Serialize> Responder<'static> for MsgPack<T> {
-    fn respond_to(self, req: &Request<'_>) -> response::Result<'static> {
-        rmp_serde::to_vec(&self.0).map_err(|e| {
-            error_!("MsgPack failed to serialize: {:?}", e);
-            Status::InternalServerError
-        }).and_then(|buf| {
-            content::MsgPack(buf).respond_to(req)
-        })
+impl<'r, T: Serialize> Responder<'r> for MsgPack<T> {
+    fn respond_to(self, req: &'r Request<'_>) -> response::ResultFuture<'r> {
+        match rmp_serde::to_vec(&self.0) {
+            Ok(buf) => content::MsgPack(buf).respond_to(req),
+            Err(e) => Box::pin(async move {
+                error_!("MsgPack failed to serialize: {:?}", e);
+                Err(Status::InternalServerError)
+            }),
+        }
     }
 }
 

contrib/lib/src/serve.rs

@@ -18,7 +18,7 @@ use std::path::{PathBuf, Path};
 
 use rocket::{Request, Data, Route};
 use rocket::http::{Method, uri::Segments};
-use rocket::handler::{Handler, Outcome};
+use rocket::handler::{Handler, HandlerFuture, Outcome};
 use rocket::response::NamedFile;
 
 /// A bitset representing configurable options for the [`StaticFiles`] handler.
@@ -273,10 +273,10 @@ impl Into<Vec<Route>> for StaticFiles {
 }
 
 impl Handler for StaticFiles {
-    fn handle<'r>(&self, req: &'r Request<'_>, data: Data) -> Outcome<'r> {
-        fn handle_dir<'r>(opt: Options, r: &'r Request<'_>, d: Data, path: &Path) -> Outcome<'r> {
+    fn handle<'r>(&self, req: &'r Request<'_>, data: Data) -> HandlerFuture<'r> {
+        fn handle_dir<'r>(opt: Options, r: &'r Request<'_>, d: Data, path: &Path) -> HandlerFuture<'r> {
             if !opt.contains(Options::Index) {
-                return Outcome::forward(d);
+                return Box::pin(async move { Outcome::forward(d) });
             }
 
             let file = NamedFile::open(path.join("index.html")).ok();
@@ -302,7 +302,7 @@ impl Handler for StaticFiles {
         match &path {
             Some(path) if path.is_dir() => handle_dir(self.options, req, data, path),
             Some(path) => Outcome::from_or_forward(req, data, NamedFile::open(path).ok()),
-            None => Outcome::forward(data)
+            None => Box::pin(async move { Outcome::forward(data) }),
         }
     }
 }

contrib/lib/src/templates/mod.rs

@@ -387,16 +387,21 @@ impl Template {
 /// Returns a response with the Content-Type derived from the template's
 /// extension and a fixed-size body containing the rendered template. If
 /// rendering fails, an `Err` of `Status::InternalServerError` is returned.
-impl Responder<'static> for Template {
-    fn respond_to(self, req: &Request<'_>) -> response::Result<'static> {
-        let ctxt = req.guard::<State<'_, ContextManager>>().succeeded().ok_or_else(|| {
-            error_!("Uninitialized template context: missing fairing.");
-            info_!("To use templates, you must attach `Template::fairing()`.");
-            info_!("See the `Template` documentation for more information.");
-            Status::InternalServerError
-        })?.inner().context();
+impl<'r> Responder<'r> for Template {
+    fn respond_to(self, req: &'r Request<'_>) -> response::ResultFuture<'r> {
+        Box::pin(async move {
+            let (render, content_type) = {
+                let ctxt = req.guard::<State<'_, ContextManager>>().succeeded().ok_or_else(|| {
+                    error_!("Uninitialized template context: missing fairing.");
+                    info_!("To use templates, you must attach `Template::fairing()`.");
+                    info_!("See the `Template` documentation for more information.");
+                    Status::InternalServerError
+                })?.inner().context();
+
+                self.finalize(&ctxt)?
+            };
 
-        let (render, content_type) = self.finalize(&ctxt)?;
-        Content(content_type, render).respond_to(req)
+            Content(content_type, render).respond_to(req).await
+        })
     }
 }

contrib/lib/tests/helmet.rs

@@ -35,23 +35,23 @@ mod helmet_tests {
         ($helmet:expr, $closure:expr) => {{
             let rocket = rocket::ignite().mount("/", routes![hello]).attach($helmet);
             let client = Client::new(rocket).unwrap();
-            let response = client.get("/").dispatch();
+            let response = client.get("/").dispatch().await;
             assert_eq!(response.status(), Status::Ok);
             $closure(response)
         }}
     }
 
-    #[test]
-    fn default_headers_test() {
+    #[rocket::async_test]
+    async fn default_headers_test() {
         dispatch!(SpaceHelmet::default(), |response: LocalResponse<'_>| {
             assert_header!(response, "X-XSS-Protection", "1");
             assert_header!(response, "X-Frame-Options", "SAMEORIGIN");
             assert_header!(response, "X-Content-Type-Options", "nosniff");
         })
     }
 
-    #[test]
-    fn disable_headers_test() {
+    #[rocket::async_test]
+    async fn disable_headers_test() {
         let helmet = SpaceHelmet::default().disable::<XssFilter>();
         dispatch!(helmet, |response: LocalResponse<'_>| {
             assert_header!(response, "X-Frame-Options", "SAMEORIGIN");
@@ -84,8 +84,8 @@ mod helmet_tests {
         });
     }
 
-    #[test]
-    fn additional_headers_test() {
+    #[rocket::async_test]
+    async fn additional_headers_test() {
         let helmet = SpaceHelmet::default()
             .enable(Hsts::default())
             .enable(ExpectCt::default())
@@ -108,8 +108,8 @@ mod helmet_tests {
         })
     }
 
-    #[test]
-    fn uri_test() {
+    #[rocket::async_test]
+    async fn uri_test() {
         let allow_uri = Uri::parse("https://www.google.com").unwrap();
         let report_uri = Uri::parse("https://www.google.com").unwrap();
         let enforce_uri = Uri::parse("https://www.google.com").unwrap();