Merge pull request #414 from dignifiedquire/h1

feat: add implementation based on async-h1 and http-service-h1

Author: yoshuawuyts

Cargo.toml

@@ -23,39 +23,46 @@ features = ["docs"]
 rustdoc-args = ["--cfg", "feature=\"docs\""]
 
 [features]
-default = ["hyper-server"]
-hyper-server = ["http-service-hyper"]
+default = ["h1-server"]
+hyper-server = ["futures", "hyper", "http", "tokio"]
+h1-server = ["http-service-h1"]
 docs = ["unstable"]
 unstable = []
 
 [dependencies]
-futures = "0.3.1"
-http = "0.1.19"
-http-service = "0.4.0"
-http-service-hyper = { version = "0.4.1", optional = true }
+http-types = "1.0.1"
+http-service = { git = "https://github.com/dignifiedquire/http-service-1", branch = "h1" }
+http-service-h1 = { git = "https://github.com/dignifiedquire/http-service-1", branch = "h1", optional = true }
 log = "0.4.8"
 route-recognizer = "0.1.13"
 serde = "1.0.102"
 serde_json = "1.0.41"
 serde_qs = "0.5.0"
-async-std = { version = "1.0.1", features = ["unstable"] }
+async-std = { version = "1.4.0", features = ["unstable"] }
 mime = "0.3.14"
 cookie = { version="0.12.0", features = ["percent-encode"]}
+futures-core = "0.3.1"
+futures = { version = "0.3.1", optional = true }
+hyper = { version = "0.13.2", optional = true }
+http = { version = "0.2.0", optional = true }
+tokio = { version = "0.2.13", optional = true }
+url = "2.1.1"
 
 [dev-dependencies]
-async-std = { version = "1.0.1", features = ["unstable", "attributes"] }
+async-std = { version = "1.4.0", features = ["unstable", "attributes"] }
 basic-cookies = "0.1.3"
 bytes = "0.4.12"
 futures-fs = "0.0.5"
 futures-util = { version = "0.3.0", features = ["compat"] }
-http-service-mock = "0.4.0"
+http-service-mock = { git = "https://github.com/dignifiedquire/http-service-1", branch = "h1" }
 juniper = "0.14.1"
 mime = "0.3.14"
 mime_guess = "2.0.1"
 percent-encoding = "2.1.0"
 serde = { version = "1.0.102", features = ["derive"] }
 structopt = "0.3.3"
-surf = "1.0.3"
+surf = { git = "https://github.com/dignifiedquire/surf-1", branch = "h1" }
+futures = "0.3.1"
 
 [[test]]
 name = "nested"

examples/cookies.rs

@@ -1,5 +1,6 @@
 use async_std::task;
 use cookie::Cookie;
+use http_types::StatusCode;
 use tide::{Request, Response};
 
 /// Tide will use the the `Cookies`'s `Extract` implementation to build this parameter.
@@ -9,13 +10,13 @@ async fn retrieve_cookie(cx: Request<()>) -> String {
 }
 
 async fn set_cookie(_req: Request<()>) -> Response {
-    let mut res = tide::Response::new(200);
+    let mut res = tide::Response::new(StatusCode::Ok);
     res.set_cookie(Cookie::new("hello", "world"));
     res
 }
 
 async fn remove_cookie(_req: Request<()>) -> Response {
-    let mut res = tide::Response::new(200);
+    let mut res = tide::Response::new(StatusCode::Ok);
     res.remove_cookie(Cookie::named("hello"));
     res
 }

examples/graphql.rs

@@ -1,4 +1,5 @@
 use async_std::task;
+use http_types::StatusCode;
 use juniper::RootNode;
 use std::sync::RwLock;
 use tide::{Request, Response, Server};
@@ -80,17 +81,21 @@ async fn handle_graphql(mut cx: Request<State>) -> Response {
 
     let schema = create_schema(); // probably worth making the schema a singleton using lazy_static library
     let response = query.execute(&schema, cx.state());
-    let status = if response.is_ok() { 200 } else { 400 };
+    let status = if response.is_ok() {
+        StatusCode::Ok
+    } else {
+        StatusCode::BadRequest
+    };
 
     Response::new(status)
         .body_json(&response)
         .expect("be able to serialize the graphql response")
 }
 
 async fn handle_graphiql(_: Request<State>) -> Response {
-    Response::new(200)
+    Response::new(StatusCode::Ok)
         .body_string(juniper::http::graphiql::graphiql_source("/graphql"))
-        .set_header("content-type", "text/html;charset=utf-8")
+        .set_header("content-type".parse().unwrap(), "text/html;charset=utf-8")
 }
 
 fn main() -> std::io::Result<()> {

examples/json.rs

@@ -1,5 +1,6 @@
 use async_std::io;
 use async_std::task;
+use http_types::StatusCode;
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, Serialize)]
@@ -19,7 +20,8 @@ fn main() -> io::Result<()> {
                 let cat = Cat {
                     name: "chashu".into(),
                 };
-                tide::Response::new(200).body_json(&cat).unwrap()
+
+                tide::Response::new(StatusCode::Ok).body_json(&cat).unwrap()
             });
 
         app.listen("127.0.0.1:8080").await?;

src/error.rs

@@ -1,37 +1,28 @@
 //! Tide error types.
-use http::{HttpTryFrom, StatusCode};
-use http_service::Body;
+use http_types::StatusCode;
 
 use crate::response::{IntoResponse, Response};
 
 /// A specialized Result type for Tide.
 pub type Result<T = Response> = std::result::Result<T, Error>;
 
-/// A generic error.
-#[derive(Debug)]
-pub struct Error {
-    resp: Response,
-}
-
-impl IntoResponse for Error {
-    fn into_response(self) -> Response {
-        self.resp
-    }
-}
-
-struct Cause(Box<dyn std::error::Error + Send + Sync>);
+/// Error type.
+pub use http_types::Error;
 
 impl From<Response> for Error {
     fn from(resp: Response) -> Error {
-        Error { resp }
+        Error::from_str(resp.status(), "")
     }
 }
 
-impl From<StatusCode> for Error {
-    fn from(status: StatusCode) -> Error {
-        Error {
-            resp: Response::new(status.as_u16()),
-        }
+impl IntoResponse for Error {
+    fn into_response(self) -> Response {
+        Response::new(self.status())
+            .set_header(
+                http_types::headers::CONTENT_TYPE,
+                "text/plain; charset=utf-8",
+            )
+            .body_string(self.to_string())
     }
 }
 
@@ -54,34 +45,22 @@ pub trait ResultExt<T>: Sized {
     /// Convert to an `Result`, treating the `Err` case as a client
     /// error (response code 400).
     fn client_err(self) -> Result<T> {
-        self.with_err_status(400)
+        self.with_err_status(StatusCode::BadRequest)
     }
 
     /// Convert to an `Result`, treating the `Err` case as a server
     /// error (response code 500).
     fn server_err(self) -> Result<T> {
-        self.with_err_status(500)
+        self.with_err_status(StatusCode::InternalServerError)
     }
 
     /// Convert to an `Result`, wrapping the `Err` case with a custom
     /// response status.
-    fn with_err_status<S>(self, status: S) -> Result<T>
-    where
-        StatusCode: HttpTryFrom<S>;
+    fn with_err_status(self, status: StatusCode) -> Result<T>;
 }
 
 impl<T, E: std::error::Error + Send + Sync + 'static> ResultExt<T> for std::result::Result<T, E> {
-    fn with_err_status<S>(self, status: S) -> Result<T>
-    where
-        StatusCode: HttpTryFrom<S>,
-    {
-        self.map_err(|e| Error {
-            resp: http::Response::builder()
-                .status(status)
-                .extension(Cause(Box::new(e)))
-                .body(Body::empty())
-                .unwrap()
-                .into(),
-        })
+    fn with_err_status(self, status: StatusCode) -> Result<T> {
+        self.map_err(|err| Error::new(status, err))
     }
 }

src/lib.rs

@@ -51,7 +51,7 @@
 //!    let mut counter: Counter = req.body_json().await.unwrap();
 //!    println!("count is {}", counter.count);
 //!    counter.count += 1;
-//!    tide::Response::new(200).body_json(&counter).unwrap()
+//!    tide::Response::new(http_types::StatusCode::Ok).body_json(&counter).unwrap()
 //! });
 //! app.listen("127.0.0.1:8080").await?;
 //! #
@@ -197,7 +197,7 @@ pub use response::{IntoResponse, Response};
 #[doc(inline)]
 pub use server::{Route, Server};
 
-pub use http;
+pub use http_types;
 
 /// Create a new Tide server.
 ///

src/middleware/cookies.rs

@@ -1,12 +1,12 @@
+use crate::utils::BoxFuture;
 use crate::{
     middleware::{Middleware, Next},
     response::CookieEvent,
     Request, Response,
 };
-use cookie::{Cookie, CookieJar, ParseError};
-use futures::future::BoxFuture;
+use cookie::CookieJar;
+use http_types::headers;
 
-use http::HeaderMap;
 use std::sync::{Arc, RwLock};
 
 /// A middleware for making cookie data available in requests.
@@ -17,7 +17,7 @@ use std::sync::{Arc, RwLock};
 /// let mut app = tide::Server::new();
 /// app.at("/get").get(|cx: tide::Request<()>| async move { cx.cookie("testCookie").unwrap().value().to_string() });
 /// app.at("/set").get(|_| async {
-///     let mut res = tide::Response::new(200);
+///     let mut res = tide::Response::new(http_types::StatusCode::Ok);
 ///     res.set_cookie(cookie::Cookie::new("testCookie", "NewCookieValue"));
 ///     res
 /// });
@@ -43,7 +43,7 @@ impl<State: Send + Sync + 'static> Middleware<State> for CookiesMiddleware {
                 cookie_data.content.clone()
             } else {
                 // no cookie data in local context, so we need to create it
-                let cookie_data = CookieData::from_headers(ctx.headers());
+                let cookie_data = CookieData::from_request(&ctx);
                 let content = cookie_data.content.clone();
                 ctx = ctx.set_local(cookie_data);
                 content
@@ -63,9 +63,8 @@ impl<State: Send + Sync + 'static> Middleware<State> for CookiesMiddleware {
 
             // iterate over added and removed cookies
             for cookie in cookie_jar.read().unwrap().delta() {
-                let set_cookie_header = http::header::SET_COOKIE.as_ref();
                 let encoded_cookie = cookie.encoded().to_string();
-                res = res.append_header(set_cookie_header, encoded_cookie);
+                res = res.append_header(headers::SET_COOKIE, encoded_cookie);
             }
             res
         })
@@ -78,23 +77,14 @@ pub(crate) struct CookieData {
 }
 
 impl CookieData {
-    pub(crate) fn from_headers(headers: &HeaderMap) -> Self {
-        let cookie_header = headers.get(http::header::COOKIE);
-        let cookie_jar = cookie_header.and_then(|raw| {
+    pub(crate) fn from_request<S>(req: &Request<S>) -> Self {
+        let cookie_jar = req.request.cookies().and_then(|cookies| {
             let mut jar = CookieJar::new();
-
-            // as long as we have an ascii string this will start parsing the cookie
-            if let Some(raw_str) = raw.to_str().ok() {
-                raw_str
-                    .split(';')
-                    .try_for_each(|s| -> Result<_, ParseError> {
-                        jar.add_original(Cookie::parse(s.trim().to_owned())?);
-                        Ok(())
-                    })
-                    .ok()?;
+            for cookie in cookies.into_iter() {
+                jar.add_original(cookie.into_owned());
             }
 
-            Some(jar)
+            Ok(jar)
         });
         let content = Arc::new(RwLock::new(cookie_jar.unwrap_or_default()));