Convert core to async and add support for async routes.

Minimum rustc bump required for rust-lang/rust#61775

core/codegen/src/attribute/catch.rs

@@ -51,7 +51,7 @@ pub fn _catch(args: TokenStream, input: TokenStream) -> Result<TokenStream> {
  let status_code = status.0.code;
 
  // Variables names we'll use and reuse.
- define_vars_and_mods!(req, catcher, response, Request, Response);
+ define_vars_and_mods!(req, catcher, Request, Response, ErrorHandlerFuture);
 
  // Determine the number of parameters that will be passed in.
  let (fn_sig, inputs) = match catch.function.sig.inputs.len() {
@@ -83,12 +83,14 @@ pub fn _catch(args: TokenStream, input: TokenStream) -> Result<TokenStream> {
  #user_catcher_fn
 
  /// Rocket code generated wrapping catch function.
- #vis fn #generated_fn_name<'_b>(#req: &'_b #Request) -> #response::Result<'_b> {
- let __response = #catcher_response;
- #Response::build()
- .status(#status)
- .merge(__response)
- .ok()
+ #vis fn #generated_fn_name<'_b>(#req: &'_b #Request) -> #ErrorHandlerFuture<'_b> {
+ Box::pin(async move {
+ let __response = #catcher_response;
+ #Response::build()
+ .status(#status)
+ .merge(__response)
+ .ok()
+ })
  }
 
  /// Rocket code generated static catcher info.

core/codegen/src/attribute/route.rs

@@ -178,7 +178,7 @@ fn data_expr(ident: &syn::Ident, ty: &syn::Type) -> TokenStream2 {
  define_vars_and_mods!(req, data, FromData, Outcome, Transform);
  let span = ident.span().unstable().join(ty.span()).unwrap().into();
  quote_spanned! { span =>
- let __transform = <#ty as #FromData>::transform(#req, #data);
+ let __transform = <#ty as #FromData>::transform(#req, #data).await;
 
  #[allow(unreachable_patterns, unreachable_code)]
  let __outcome = match __transform {
@@ -195,7 +195,7 @@ fn data_expr(ident: &syn::Ident, ty: &syn::Type) -> TokenStream2 {
  };
 
  #[allow(non_snake_case, unreachable_patterns, unreachable_code)]
- let #ident: #ty = match <#ty as #FromData>::from_data(#req, __outcome) {
+ let #ident: #ty = match <#ty as #FromData>::from_data(#req, __outcome).await {
  #Outcome::Success(__d) => __d,
  #Outcome::Forward(__d) => return #Outcome::Forward(__d),
  #Outcome::Failure((__c, _)) => return #Outcome::Failure(__c),
@@ -368,8 +368,18 @@ fn generate_respond_expr(route: &Route) -> TokenStream2 {
  let parameter_names = route.inputs.iter()
  .map(|(_, rocket_ident, _)| rocket_ident);
 
+ let responder_stmt = if route.function.sig.asyncness.is_some() {
+ quote_spanned! { ret_span =>
+ let ___responder = #user_handler_fn_name(#(#parameter_names),*).await;
+ }
+ } else {
+ quote_spanned! { ret_span =>
+ let ___responder = #user_handler_fn_name(#(#parameter_names),*);
+ }
+ };
+
  quote_spanned! { ret_span =>
- let ___responder = #user_handler_fn_name(#(#parameter_names),*);
+ #responder_stmt
  #handler::Outcome::from(#req, ___responder)
  }
 }
@@ -402,7 +412,7 @@ fn codegen_route(route: Route) -> Result<TokenStream> {
  }
 
  // Gather everything we need.
- define_vars_and_mods!(req, data, handler, Request, Data, StaticRouteInfo);
+ define_vars_and_mods!(req, data, Request, Data, StaticRouteInfo, HandlerFuture);
  let (vis, user_handler_fn) = (&route.function.vis, &route.function);
  let user_handler_fn_name = &user_handler_fn.sig.ident;
  let generated_fn_name = user_handler_fn_name.prepend(ROUTE_FN_PREFIX);
@@ -422,12 +432,14 @@ fn codegen_route(route: Route) -> Result<TokenStream> {
  #vis fn #generated_fn_name<'_b>(
  #req: &'_b #Request,
  #data: #Data
- ) -> #handler::Outcome<'_b> {
- #(#req_guard_definitions)*
- #(#parameter_definitions)*
- #data_stmt
-
- #generated_respond_expr
+ ) -> #HandlerFuture<'_b> {
+ Box::pin(async move {
+ #(#req_guard_definitions)*
+ #(#parameter_definitions)*
+ #data_stmt
+
+ #generated_respond_expr
+ })
  }
 
  /// Rocket code generated wrapping URI macro.

core/codegen/src/lib.rs

@@ -1,4 +1,5 @@
 #![feature(proc_macro_diagnostic, proc_macro_span)]
+#![feature(async_await)]
 #![recursion_limit="128"]
 
 #![doc(html_root_url = "https://api.rocket.rs/v0.5")]
@@ -96,6 +97,8 @@ vars_and_mods! {
  Data => rocket::Data,
  StaticRouteInfo => rocket::StaticRouteInfo,
  SmallVec => rocket::http::private::SmallVec,
+ HandlerFuture => rocket::handler::HandlerFuture,
+ ErrorHandlerFuture => rocket::handler::ErrorHandlerFuture,
 }
 
 macro_rules! define_vars_and_mods {

core/codegen/tests/route.rs

@@ -1,4 +1,4 @@
-#![feature(proc_macro_hygiene)]
+#![feature(proc_macro_hygiene, async_await)]
 
 // Rocket sometimes generates mangled identifiers that activate the
 // non_snake_case lint. We deny the lint in this test to ensure that

core/http/Cargo.toml

@@ -16,7 +16,7 @@ edition = "2018"
 
 [features]
 default = []
-tls = ["rustls", "hyper-sync-rustls"]
+tls = ["tokio-rustls"]
 private-cookies = ["cookie/secure"]
 
 [dependencies]
@@ -27,16 +27,11 @@ http = "0.1.17"
 mime = "0.3.13"
 time = "0.1"
 indexmap = "1.0"
-rustls = { version = "0.15", optional = true }
 state = "0.4"
+tokio-rustls = { version = "0.9.2", optional = true }
 cookie = { version = "0.12", features = ["percent-encode"] }
 pear = "0.1"
 unicode-xid = "0.2"
 
-[dependencies.hyper-sync-rustls]
-version = "=0.3.0-rc.5"
-features = ["server"]
-optional = true
-
 [dev-dependencies]
 rocket = { version = "0.5.0-dev", path = "../lib" }

core/http/src/cookies.rs

@@ -1,5 +1,4 @@
 use std::fmt;
-use std::cell::RefMut;
 
 use crate::Header;
 use cookie::Delta;
@@ -128,7 +127,7 @@ mod key {
 /// 32`.
 pub enum Cookies<'a> {
  #[doc(hidden)]
- Jarred(RefMut<'a, CookieJar>, &'a Key),
+ Jarred(CookieJar, &'a Key, Box<dyn FnOnce(CookieJar) + Send + 'a>),
  #[doc(hidden)]
  Empty(CookieJar)
 }
@@ -137,8 +136,8 @@ impl<'a> Cookies<'a> {
  /// WARNING: This is unstable! Do not use this method outside of Rocket!
  #[inline]
  #[doc(hidden)]
- pub fn new(jar: RefMut<'a, CookieJar>, key: &'a Key) -> Cookies<'a> {
- Cookies::Jarred(jar, key)
+ pub fn new<F: FnOnce(CookieJar) + Send + 'a>(jar: CookieJar, key: &'a Key, on_drop: F) -> Cookies<'a> {
+ Cookies::Jarred(jar, key, Box::new(on_drop))
  }
 
  /// WARNING: This is unstable! Do not use this method outside of Rocket!
@@ -160,7 +159,7 @@ impl<'a> Cookies<'a> {
  #[inline]
  #[doc(hidden)]
  pub fn add_original(&mut self, cookie: Cookie<'static>) {
- if let Cookies::Jarred(ref mut jar, _) = *self {
+ if let Cookies::Jarred(ref mut jar, _, _) = *self {
  jar.add_original(cookie)
  }
  }
@@ -180,7 +179,7 @@ impl<'a> Cookies<'a> {
  /// ```
  pub fn get(&self, name: &str) -> Option<&Cookie<'static>> {
  match *self {
- Cookies::Jarred(ref jar, _) => jar.get(name),
+ Cookies::Jarred(ref jar, _, _) => jar.get(name),
  Cookies::Empty(_) => None
  }
  }
@@ -205,7 +204,7 @@ impl<'a> Cookies<'a> {
  /// }
  /// ```
  pub fn add(&mut self, cookie: Cookie<'static>) {
- if let Cookies::Jarred(ref mut jar, _) = *self {
+ if let Cookies::Jarred(ref mut jar, _, _) = *self {
  jar.add(cookie)
  }
  }
@@ -231,7 +230,7 @@ impl<'a> Cookies<'a> {
  /// }
  /// ```
  pub fn remove(&mut self, cookie: Cookie<'static>) {
- if let Cookies::Jarred(ref mut jar, _) = *self {
+ if let Cookies::Jarred(ref mut jar, _, _) = *self {
  jar.remove(cookie)
  }
  }
@@ -252,7 +251,7 @@ impl<'a> Cookies<'a> {
  /// ```
  pub fn iter(&self) -> impl Iterator<Item=&Cookie<'static>> {
  match *self {
- Cookies::Jarred(ref jar, _) => jar.iter(),
+ Cookies::Jarred(ref jar, _, _) => jar.iter(),
  Cookies::Empty(ref jar) => jar.iter()
  }
  }
@@ -262,12 +261,22 @@ impl<'a> Cookies<'a> {
  #[doc(hidden)]
  pub fn delta(&self) -> Delta<'_> {
  match *self {
- Cookies::Jarred(ref jar, _) => jar.delta(),
+ Cookies::Jarred(ref jar, _, _) => jar.delta(),
  Cookies::Empty(ref jar) => jar.delta()
  }
  }
 }
 
+impl<'a> Drop for Cookies<'a> {
+ fn drop(&mut self) {
+ if let Cookies::Jarred(ref mut jar, _, ref mut on_drop) = *self {
+ let jar = std::mem::replace(jar, CookieJar::new());
+ let on_drop = std::mem::replace(on_drop, Box::new(|_| {}));
+ on_drop(jar);
+ }
+ }
+}
+
 #[cfg(feature = "private-cookies")]
 impl Cookies<'_> {
  /// Returns a reference to the `Cookie` inside this collection with the name
@@ -290,7 +299,7 @@ impl Cookies<'_> {
  /// ```
  pub fn get_private(&mut self, name: &str) -> Option<Cookie<'static>> {
  match *self {
- Cookies::Jarred(ref mut jar, key) => jar.private(key).get(name),
+ Cookies::Jarred(ref mut jar, key, _) => jar.private(key).get(name),
  Cookies::Empty(_) => None
  }
  }
@@ -326,7 +335,7 @@ impl Cookies<'_> {
  /// }
  /// ```
  pub fn add_private(&mut self, mut cookie: Cookie<'static>) {
- if let Cookies::Jarred(ref mut jar, key) = *self {
+ if let Cookies::Jarred(ref mut jar, key, _) = *self {
  Cookies::set_private_defaults(&mut cookie);
  jar.private(key).add(cookie)
  }
@@ -336,7 +345,7 @@ impl Cookies<'_> {
  /// WARNING: This is unstable! Do not use this method outside of Rocket!
  #[doc(hidden)]
  pub fn add_original_private(&mut self, mut cookie: Cookie<'static>) {
- if let Cookies::Jarred(ref mut jar, key) = *self {
+ if let Cookies::Jarred(ref mut jar, key, _) = *self {
  Cookies::set_private_defaults(&mut cookie);
  jar.private(key).add_original(cookie)
  }
@@ -390,7 +399,7 @@ impl Cookies<'_> {
  /// }
  /// ```
  pub fn remove_private(&mut self, mut cookie: Cookie<'static>) {
- if let Cookies::Jarred(ref mut jar, key) = *self {
+ if let Cookies::Jarred(ref mut jar, key, _) = *self {
  if cookie.path().is_none() {
  cookie.set_path("/");
  }
@@ -403,7 +412,7 @@ impl Cookies<'_> {
 impl fmt::Debug for Cookies<'_> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  match *self {
- Cookies::Jarred(ref jar, _) => jar.fmt(f),
+ Cookies::Jarred(ref jar, _, _) => jar.fmt(f),
  Cookies::Empty(ref jar) => jar.fmt(f)
  }
  }

core/http/src/hyper.rs

@@ -4,17 +4,17 @@
 //! These types will, with certainty, be removed with time, but they reside here
 //! while necessary.
 
-#[doc(hidden)] pub use hyper::{Body, Request, Response};
+#[doc(hidden)] pub use hyper::{Body, Request, Response, Server};
 #[doc(hidden)] pub use hyper::body::Payload as Payload;
 #[doc(hidden)] pub use hyper::error::Error;
-#[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::HeaderMap;
 #[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::request::Parts as RequestParts;
 #[doc(hidden)] pub use http::status::StatusCode;
 #[doc(hidden)] pub use http::uri::Uri;
 

core/http/src/tls.rs

@@ -1,2 +1,5 @@
-pub use hyper_sync_rustls::{util, WrappedStream, ServerSession, TlsServer};
-pub use rustls::{Certificate, PrivateKey};
+pub use tokio_rustls::TlsAcceptor;
+pub use tokio_rustls::rustls;
+
+pub use rustls::internal::pemfile;
+pub use rustls::{Certificate, NoClientAuth, PrivateKey, ServerConfig};

core/lib/Cargo.toml

@@ -24,12 +24,12 @@ 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" }
+futures-preview = { version = "0.3.0-alpha.14", features = ["compat", "io-compat"] }
 tokio = "0.1.16"
 yansi = "0.5"
-log = "0.4"
+log = { version = "0.4", features = ["std"] }
 toml = "0.4.7"
 num_cpus = "1.0"
 state = "0.4.1"

core/lib/build.rs

@@ -3,8 +3,8 @@
 use yansi::{Paint, Color::{Red, Yellow, Blue}};
 
 // Specifies the minimum nightly version needed to compile Rocket.
-const MIN_DATE: &'static str = "2019-04-05";
-const MIN_VERSION: &'static str = "1.35.0-nightly";
+const MIN_DATE: &'static str = "2019-07-03";
+const MIN_VERSION: &'static str = "1.37.0-nightly";
 
 macro_rules! err {
  ($version:expr, $date:expr, $msg:expr) => (

core/lib/src/catcher.rs

@@ -1,3 +1,5 @@
+use futures::future::Future;
+
 use crate::response;
 use crate::handler::ErrorHandler;
 use crate::codegen::StaticCatchInfo;
@@ -98,7 +100,7 @@ impl Catcher {
  }
 
  #[inline(always)]
- pub(crate) fn handle<'r>(&self, req: &'r Request<'_>) -> response::Result<'r> {
+ pub(crate) fn handle<'r>(&self, req: &'r Request<'_>) -> impl Future<Output = response::Result<'r>> {
  (self.handler)(req)
  }
 
@@ -149,10 +151,12 @@ macro_rules! default_catchers {
  let mut map = HashMap::new();
 
  $(
- fn $fn_name<'r>(req: &'r Request<'_>) -> response::Result<'r> {
- status::Custom(Status::from_code($code).unwrap(),
- content::Html(error_page_template!($code, $name, $description))
- ).respond_to(req)
+ fn $fn_name<'r>(req: &'r Request<'_>) -> std::pin::Pin<Box<dyn std::future::Future<Output = response::Result<'r>> + Send + 'r>> {
+ (async move {
+ status::Custom(Status::from_code($code).unwrap(),
+ content::Html(error_page_template!($code, $name, $description))
+ ).respond_to(req)
+ }).boxed()
  }
 
  map.insert($code, Catcher::new_default($code, $fn_name));
@@ -164,6 +168,7 @@ macro_rules! default_catchers {
 
 pub mod defaults {
  use super::Catcher;
+ use futures::future::FutureExt;
 
  use std::collections::HashMap;
 

core/lib/src/codegen.rs

@@ -1,9 +1,11 @@
+use futures::future::Future;
+
 use crate::{Request, Data};
 use crate::handler::{Outcome, ErrorHandler};
 use crate::http::{Method, MediaType};
 
 /// Type of a static handler, which users annotate with Rocket's attribute.
-pub type StaticHandler = for<'r> fn(&'r Request<'_>, Data) -> Outcome<'r>;
+pub type StaticHandler = for<'r> fn(&'r Request<'_>, Data) -> std::pin::Pin<Box<dyn Future<Output = Outcome<'r>> + Send + 'r>>;
 
 /// Information generated by the `route` attribute during codegen.
 pub struct StaticRouteInfo {