update to std::future::Future

Cargo.toml

@@ -13,12 +13,16 @@ autotests = true
 autoexamples = true
 edition = "2018"
 
+[package.metadata.docs.rs]
+features = ["tls"]
+
 [dependencies]
 bytes = "0.4.8"
-futures = "0.1"
+futures-preview = "0.3.0-alpha.18"
+futures-util-preview = "0.3.0-alpha.18"
 headers = "0.2"
 http = "0.1"
-hyper = "0.12.18"
+hyper = "=0.13.0-alpha.1"
 logcrate = { version = "0.4", package = "log" }
 mime = "0.3"
 mime_guess = "2.0.0"
@@ -27,10 +31,9 @@ scoped-tls = "1.0"
 serde = "1.0"
 serde_json = "1.0"
 serde_urlencoded = "0.6"
-tokio = "0.1.11"
-tokio-io = "0.1"
+tokio = "=0.2.0-alpha.4"
+tokio-executor = "=0.2.0-alpha.4"
 rustls = { version = "0.15", optional = true }
-tokio-threadpool = "0.1.7"
 # tls is enabled by default, we don't want that yet
 tungstenite = { default-features = false, version = "0.9", optional = true }
 urlencoding = "1.0.0"
@@ -45,9 +48,6 @@ default = ["multipart", "websocket"]
 websocket = ["tungstenite"]
 tls = ["rustls"]
 
-[package.metadata.docs.rs]
-features = ["tls"]
-
 [profile.release]
 codegen-units = 1
 incremental = false

examples/body.rs

@@ -1,9 +1,6 @@
 #![deny(warnings)]
-extern crate serde;
-#[macro_use]
-extern crate serde_derive;
-extern crate pretty_env_logger;
-extern crate warp;
+
+use serde_derive::{Deserialize, Serialize};
 
 use warp::Filter;
 
@@ -13,7 +10,8 @@ struct Employee {
     rate: u32,
 }
 
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     pretty_env_logger::init();
 
     // POST /employees/:rate  {"name":"Sean","rate":2}
@@ -28,5 +26,5 @@ fn main() {
             warp::reply::json(&employee)
         });
 
-    warp::serve(promote).run(([127, 0, 0, 1], 3030));
+    warp::serve(promote).run(([127, 0, 0, 1], 3030)).await
 }

examples/dir.rs

@@ -1,9 +1,8 @@
 #![deny(warnings)]
-extern crate pretty_env_logger;
-extern crate warp;
 
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     pretty_env_logger::init();
 
-    warp::serve(warp::fs::dir("examples/dir")).run(([127, 0, 0, 1], 3030));
+    warp::serve(warp::fs::dir("examples/dir")).run(([127, 0, 0, 1], 3030)).await;
 }

examples/errors.rs

@@ -1,15 +1,11 @@
 #![deny(warnings)]
-extern crate serde;
-#[macro_use]
-extern crate serde_derive;
-extern crate pretty_env_logger;
-extern crate warp;
 
 use std::error::Error as StdError;
 use std::fmt::{self, Display};
 
+use serde_derive::Serialize;
 use warp::http::StatusCode;
-use warp::{Filter, Rejection, Reply};
+use warp::{Future, Filter, Rejection, Reply};
 
 #[derive(Copy, Clone, Debug)]
 enum Error {
@@ -34,49 +30,53 @@ impl Display for Error {
 
 impl StdError for Error {}
 
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     let hello = warp::path::end().map(warp::reply);
 
     let oops =
-        warp::path("oops").and_then(|| Err::<StatusCode, _>(warp::reject::custom(Error::Oops)));
+        warp::path("oops").and_then(|| async { Err::<StatusCode, _>(warp::reject::custom(Error::Oops))});
 
     let nope =
-        warp::path("nope").and_then(|| Err::<StatusCode, _>(warp::reject::custom(Error::Nope)));
+        warp::path("nope").and_then(|| async { Err::<StatusCode, _>(warp::reject::custom(Error::Nope))});
 
     let routes = warp::get2()
         .and(hello.or(oops).or(nope))
         .recover(customize_error);
 
-    warp::serve(routes).run(([127, 0, 0, 1], 3030));
+    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }
 
 // This function receives a `Rejection` and tries to return a custom
 // value, othewise simply passes the rejection along.
-fn customize_error(err: Rejection) -> Result<impl Reply, Rejection> {
-    if let Some(&err) = err.find_cause::<Error>() {
-        let code = match err {
-            Error::Nope => StatusCode::BAD_REQUEST,
-            Error::Oops => StatusCode::INTERNAL_SERVER_ERROR,
-        };
-        let msg = err.to_string();
+fn customize_error(err: Rejection) -> impl Future< Output = Result<impl Reply, Rejection>> {
+    let err = {
+        if let Some(&err) = err.find_cause::<Error>() {
+            let code = match err {
+                Error::Nope => StatusCode::BAD_REQUEST,
+                Error::Oops => StatusCode::INTERNAL_SERVER_ERROR,
+            };
+            let msg = err.to_string();
 
-        let json = warp::reply::json(&ErrorMessage {
-            code: code.as_u16(),
-            message: msg,
-        });
-        Ok(warp::reply::with_status(json, code))
-    } else if let Some(_) = err.find_cause::<warp::reject::MethodNotAllowed>() {
-        // We can handle a specific error, here METHOD_NOT_ALLOWED,
-        // and render it however we want
-        let code = StatusCode::METHOD_NOT_ALLOWED;
-        let json = warp::reply::json(&ErrorMessage {
-            code: code.as_u16(),
-            message: "oops, you aren't allowed to use this method.".into(),
-        });
-        Ok(warp::reply::with_status(json, code))
-    } else {
-        // Could be a NOT_FOUND, or any other internal error... here we just
-        // let warp use its default rendering.
-        Err(err)
-    }
+            let json = warp::reply::json(&ErrorMessage {
+                code: code.as_u16(),
+                message: msg,
+            });
+            Ok(warp::reply::with_status(json, code))
+        } else if let Some(_) = err.find_cause::<warp::reject::MethodNotAllowed>() {
+            // We can handle a specific error, here METHOD_NOT_ALLOWED,
+            // and render it however we want
+            let code = StatusCode::METHOD_NOT_ALLOWED;
+            let json = warp::reply::json(&ErrorMessage {
+                code: code.as_u16(),
+                message: "oops, you aren't allowed to use this method.".into(),
+            });
+            Ok(warp::reply::with_status(json, code))
+        } else {
+            // Could be a NOT_FOUND, or any other internal error... here we just
+            // let warp use its default rendering.
+            Err(err)
+        }
+    };
+    async { err }
 }

examples/file.rs

@@ -1,10 +1,9 @@
 #![deny(warnings)]
-extern crate pretty_env_logger;
-extern crate warp;
 
 use warp::Filter;
 
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     pretty_env_logger::init();
 
     let readme = warp::get2()
@@ -18,5 +17,5 @@ fn main() {
     // GET /ex/... => ./examples/..
     let routes = readme.or(examples);
 
-    warp::serve(routes).run(([127, 0, 0, 1], 3030));
+    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }

examples/futures.rs

@@ -1,11 +1,9 @@
 #![deny(warnings)]
-extern crate tokio;
-extern crate warp;
 
 use std::str::FromStr;
 use std::time::{Duration, Instant};
-use tokio::timer::Delay;
-use warp::{Filter, Future};
+use tokio::timer::delay;
+use warp::Filter;
 
 /// A newtype to enforce our maximum allowed seconds.
 struct Seconds(u64);
@@ -23,21 +21,15 @@ impl FromStr for Seconds {
     }
 }
 
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     // Match `/:u32`...
     let routes = warp::path::param()
         // and_then create a `Future` that will simply wait N seconds...
-        .and_then(|Seconds(seconds)| {
-            Delay::new(Instant::now() + Duration::from_secs(seconds))
-                // return the number of seconds again...
-                .map(move |()| seconds)
-                // An error from `Delay` means a big problem with the server...
-                .map_err(|timer_err| {
-                    eprintln!("timer error: {}", timer_err);
-                    warp::reject::custom(timer_err)
-                })
-        })
-        .map(|seconds| format!("I waited {} seconds!", seconds));
+        .and_then(|Seconds(seconds): Seconds| async move {
+            delay(Instant::now() + Duration::from_secs(seconds)).await;
+            Result::Ok::<String, warp::Rejection>(format!("I waited {} seconds!", seconds))
+        });
 
-    warp::serve(routes).run(([127, 0, 0, 1], 3030));
+    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }

examples/handlebars_template.rs

@@ -26,7 +26,8 @@ where
         .unwrap_or_else(|err| err.description().to_owned())
 }
 
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     let template = "<!DOCTYPE html>
                     <html>
                       <head>
@@ -58,5 +59,5 @@ fn main() {
         })
         .map(handlebars);
 
-    warp::serve(route).run(([127, 0, 0, 1], 3030));
+    warp::serve(route).run(([127, 0, 0, 1], 3030)).await;
 }

examples/headers.rs

@@ -11,7 +11,8 @@ use warp::Filter;
 /// - `Accept` is exactly `*/*`
 ///
 /// If these conditions don't match, a 404 is returned.
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     pretty_env_logger::init();
 
     // For this example, we assume no DNS was used,
@@ -25,5 +26,5 @@ fn main() {
         .and(accept_stars)
         .map(|addr| format!("accepting stars on {}", addr));
 
-    warp::serve(routes).run(([127, 0, 0, 1], 3030));
+    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }

examples/hello.rs

@@ -3,9 +3,10 @@ extern crate warp;
 
 use warp::Filter;
 
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     // Match any request and return hello world!
     let routes = warp::any().map(|| "Hello, World!");
 
-    warp::serve(routes).run(([127, 0, 0, 1], 3030));
+    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }

examples/returning.rs

@@ -12,7 +12,8 @@ pub fn index_filter() -> impl Filter<Extract = (&'static str,), Error = Rejectio
     warp::path::end().map(|| "Index page")
 }
 
-pub fn main() {
+#[warp::tokio_rt]
+async fn main() {
     let routes = index_filter().or(assets_filter());
-    warp::serve(routes).run(([127, 0, 0, 1], 3030));
+    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }

examples/routing.rs

@@ -5,7 +5,8 @@ extern crate warp;
 
 use warp::Filter;
 
-fn main() {
+#[warp::tokio_rt]
+async fn main() {
     pretty_env_logger::init();
 
     // We'll start simple, and gradually show how you combine these powers
@@ -77,5 +78,5 @@ fn main() {
 
     let routes = warp::get2().and(hi.or(hello_from_warp).or(bye).or(math).or(sum).or(times));
 
-    warp::serve(routes).run(([127, 0, 0, 1], 3030));
+    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }

examples/sse.rs

@@ -1,27 +1,27 @@
-extern crate pretty_env_logger;
-extern crate tokio;
-extern crate warp;
+// extern crate pretty_env_logger;
 
-use std::time::Duration;
-use tokio::{clock::now, timer::Interval};
-use warp::{Filter, Stream};
+// use std::time::Duration;
+// use tokio::{clock::now, timer::Interval};
+// use futures::StreamExt;
+// use warp::Filter;
 
-fn main() {
-    pretty_env_logger::init();
+#[warp::tokio_rt]
+async fn main() {
+//     pretty_env_logger::init();
 
-    let routes = warp::path("ticks")
-        .and(warp::sse())
-        .map(|sse: warp::sse::Sse| {
-            let mut counter: u64 = 0;
-            // create server event source
-            let event_stream = Interval::new(now(), Duration::from_secs(1)).map(move |_| {
-                counter += 1;
-                // create server-sent event
-                warp::sse::data(counter)
-            });
-            // reply using server-sent events
-            sse.reply(event_stream)
-        });
+//     let routes = warp::path("ticks")
+//         .and(warp::sse())
+//         .map(|sse: warp::sse::Sse| {
+//             let mut counter: u64 = 0;
+//             // create server event source
+//             let event_stream = Interval::new(now(), Duration::from_secs(1)).map(move |_| {
+//                 counter += 1;
+//                 // create server-sent event
+//                 Ok(warp::sse::data(counter))
+//             });
+//             // reply using server-sent events
+//             sse.reply(event_stream)
+//         });
 
-    warp::serve(routes).run(([127, 0, 0, 1], 3030));
+//     warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }