Merge pull request #6 from jtgeibel/use-http-types

Bump to latest conduit alpha and use `http` types

Author: jtgeibel

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "conduit-hyper"
-version = "0.3.0-alpha.0"
+version = "0.3.0-alpha.1"
 authors = ["Justin Geibel <[email protected]>"]
 license = "MIT OR Apache-2.0"
 description = "Host a conduit based web application on a hyper server"
@@ -9,16 +9,15 @@ readme = "README.md"
 edition = "2018"
 
 [dependencies]
-conduit = "0.9.0-alpha.0"
+conduit = "0.9.0-alpha.1"
 futures = "0.3"
 hyper = "0.13"
 http = "0.2"
 tracing = { version = "0.1", features = ["log"] }
-semver = "0.9" # Must match version in conduit
 tokio = { version = "0.2", features = ["blocking", "rt-threaded"] }
 tower-service = "0.3"
 
 [dev-dependencies]
-conduit-router = "0.9.0-alpha.0"
+conduit-router = "0.9.0-alpha.1"
 env_logger = "0.7"
 tokio = { version = "0.2", features = ["macros"] }

examples/server.rs

@@ -1,11 +1,10 @@
 #![deny(clippy::all)]
 
-use conduit::{Handler, Request, Response};
+use conduit::{header, static_to_body, Handler, RequestExt, Response, ResponseResult};
 use conduit_hyper::Server;
 use conduit_router::RouteBuilder;
 
-use std::collections::HashMap;
-use std::io::{Cursor, Error};
+use std::io;
 use std::thread::sleep;
 
 const MAX_THREADS: usize = 1;
@@ -28,29 +27,22 @@ fn build_conduit_handler() -> impl Handler {
     router
 }
 
-fn endpoint(_: &mut dyn Request) -> Result<Response, Error> {
-    let body = "Hello world!";
+fn endpoint(_: &mut dyn RequestExt) -> ResponseResult<http::Error> {
+    let body = b"Hello world!";
 
     sleep(std::time::Duration::from_secs(2));
 
-    let mut headers = HashMap::new();
-    headers.insert(
-        "Content-Type".to_string(),
-        vec!["text/plain; charset=utf-8".to_string()],
-    );
-    headers.insert("Content-Length".to_string(), vec![body.len().to_string()]);
-    Ok(Response {
-        status: (200, "OK"),
-        headers,
-        body: Box::new(Cursor::new(body)),
-    })
+    Response::builder()
+        .header(header::CONTENT_TYPE, "text/plain; charset=utf-8")
+        .header(header::CONTENT_LENGTH, body.len())
+        .body(static_to_body(body))
 }
 
-fn panic(_: &mut dyn Request) -> Result<Response, Error> {
+fn panic(_: &mut dyn RequestExt) -> ResponseResult<http::Error> {
     // For now, connection is immediately closed
     panic!("message");
 }
 
-fn error(_: &mut dyn Request) -> Result<Response, Error> {
-    Err(Error::new(std::io::ErrorKind::Other, "io error, oops"))
+fn error(_: &mut dyn RequestExt) -> ResponseResult<io::Error> {
+    Err(io::Error::new(io::ErrorKind::Other, "io error, oops"))
 }

src/adaptor.rs

@@ -13,10 +13,9 @@ use std::io::{Cursor, Read};
 use std::net::SocketAddr;
 use std::path::{Component, Path, PathBuf};
 
-use conduit::{Extensions, Headers, Host, Method, Request, Scheme};
-use http::{request::Parts as HttpParts, HeaderMap};
-use hyper::{body::Bytes, Method as HyperMethod, Version as HttpVersion};
-use semver::Version;
+use conduit::{Extensions, HeaderMap, Host, Method, RequestExt, Scheme, Version};
+use http::request::Parts as HttpParts;
+use hyper::body::Bytes;
 
 /// Owned data consumed by the background thread
 ///
@@ -52,44 +51,6 @@ impl Parts {
     }
 }
 
-impl Headers for Parts {
-    /// Find all values associated with a header, or None.
-    ///
-    /// If the value of a header is not valid UTF-8, that value
-    /// is replaced with the emtpy string.
-    fn find(&self, key: &str) -> Option<Vec<&str>> {
-        let values = self
-            .headers()
-            .get_all(key)
-            .iter()
-            .map(|v| v.to_str().unwrap_or(""))
-            .collect::<Vec<_>>();
-
-        if values.is_empty() {
-            None
-        } else {
-            Some(values)
-        }
-    }
-
-    fn has(&self, key: &str) -> bool {
-        self.headers().contains_key(key)
-    }
-
-    /// Returns a representation of all headers
-    fn all(&self) -> Vec<(&str, Vec<&str>)> {
-        let mut all = Vec::new();
-        for key in self.headers().keys() {
-            let key = key.as_str();
-            let values = self
-                .find(key)
-                .expect("all keys should have at least one value");
-            all.push((key, values));
-        }
-        all
-    }
-}
-
 pub(crate) struct ConduitRequest {
     parts: Parts,
     path: String,
@@ -141,44 +102,22 @@ impl ConduitRequest {
     }
 }
 
-impl Request for ConduitRequest {
+impl RequestExt for ConduitRequest {
     fn http_version(&self) -> Version {
-        match self.parts().version {
-            HttpVersion::HTTP_09 => version(0, 9),
-            HttpVersion::HTTP_10 => version(1, 0),
-            HttpVersion::HTTP_11 => version(1, 1),
-            HttpVersion::HTTP_2 => version(2, 0),
-            HttpVersion::HTTP_3 => version(3, 0),
-            _ => version(0, 0),
-        }
+        self.parts().version
     }
 
-    fn conduit_version(&self) -> Version {
-        version(0, 1)
-    }
-
-    fn method(&self) -> Method {
-        match self.parts().method {
-            HyperMethod::CONNECT => Method::Connect,
-            HyperMethod::DELETE => Method::Delete,
-            HyperMethod::GET => Method::Get,
-            HyperMethod::HEAD => Method::Head,
-            HyperMethod::OPTIONS => Method::Options,
-            HyperMethod::PATCH => Method::Patch,
-            HyperMethod::POST => Method::Post,
-            HyperMethod::PUT => Method::Put,
-            HyperMethod::TRACE => Method::Trace,
-            _ => Method::Other(self.parts().method.to_string()),
-        }
+    fn method(&self) -> &Method {
+        &self.parts().method
     }
 
     /// Always returns Http
     fn scheme(&self) -> Scheme {
         Scheme::Http
     }
 
-    fn headers(&self) -> &dyn Headers {
-        &self.parts
+    fn headers(&self) -> &HeaderMap {
+        &self.parts.headers()
     }
 
     /// Returns the length of the buffered body
@@ -228,13 +167,3 @@ impl Request for ConduitRequest {
         &mut self.body
     }
 }
-
-fn version(major: u64, minor: u64) -> Version {
-    Version {
-        major,
-        minor,
-        patch: 0,
-        pre: vec![],
-        build: vec![],
-    }
-}

src/lib.rs

@@ -35,16 +35,12 @@
 //! }
 //! #
 //! # use std::{error, io};
-//! # use conduit::{Request, Response};
+//! # use conduit::{box_error, static_to_body, Response, RequestExt, HandlerResult};
 //! #
 //! # struct Endpoint();
 //! # impl Handler for Endpoint {
-//! #     fn call(&self, _: &mut dyn Request) -> Result<Response, Box<dyn error::Error + Send>> {
-//! #         Ok(Response {
-//! #             status: (200, "OK"),
-//! #             headers: Default::default(),
-//! #             body: Box::new(io::Cursor::new("")),
-//! #         })
+//! #     fn call(&self, _: &mut dyn RequestExt) -> HandlerResult {
+//! #         Response::builder().body(static_to_body(b"")).map_err(box_error)
 //! #     }
 //! # }
 //! ```
@@ -55,8 +51,7 @@ mod service;
 #[cfg(test)]
 mod tests;
 
-// Consumers of this library need access to this particular version of `semver`
-pub use semver;
-
 pub use server::Server;
 pub use service::{BlockingHandler, Service};
+
+type HyperResponse = hyper::Response<hyper::Body>;

src/service.rs

@@ -23,17 +23,12 @@ impl Service {
     /// ```no_run
     /// # use std::sync::Arc;
     /// # use conduit_hyper::{BlockingHandler, Service};
-    /// # use std::{error, io};
-    /// # use conduit::{Handler, Request, Response};
+    /// # use conduit::{box_error, static_to_body, Handler, HandlerResult, RequestExt, Response};
     /// #
     /// # struct Endpoint();
     /// # impl Handler for Endpoint {
-    /// #     fn call(&self, _: &mut dyn Request) -> Result<Response, Box<dyn error::Error + Send>> {
-    /// #         Ok(Response {
-    /// #             status: (200, "OK"),
-    /// #             headers: Default::default(),
-    /// #             body: Box::new(io::Cursor::new("")),
-    /// #         })
+    /// #     fn call(&self, _: &mut dyn RequestExt) -> HandlerResult {
+    /// #         Response::builder().body(static_to_body(b"")).map_err(box_error)
     /// #     }
     /// # }
     /// # let app = Endpoint();

src/service/blocking_handler.rs

@@ -1,22 +1,27 @@
 use crate::adaptor::{ConduitRequest, RequestInfo};
 use crate::service::ServiceError;
+use crate::HyperResponse;
 
 use std::net::SocketAddr;
-use std::sync::{atomic::Ordering, Arc};
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc,
+};
 
-use hyper::{Body, Request, Response, StatusCode};
+use conduit::Handler;
+use hyper::{Body, Request, Response};
 use tracing::error;
 
-use std::sync::atomic::AtomicUsize;
+type ConduitResponse = Response<conduit::Body>;
 
 #[derive(Debug)]
-pub struct BlockingHandler<H: conduit::Handler> {
+pub struct BlockingHandler<H: Handler> {
     thread_count: AtomicUsize,
     max_thread_count: usize,
     handler: Arc<H>,
 }
 
-impl<H: conduit::Handler> BlockingHandler<H> {
+impl<H: Handler> BlockingHandler<H> {
     pub fn new(handler: H, max_thread_count: usize) -> Self {
         Self {
             thread_count: AtomicUsize::new(0),
@@ -30,7 +35,7 @@ impl<H: conduit::Handler> BlockingHandler<H> {
         self: Arc<Self>,
         request: Request<Body>,
         remote_addr: SocketAddr,
-    ) -> Result<Response<Body>, ServiceError> {
+    ) -> Result<HyperResponse, ServiceError> {
         let (parts, body) = request.into_parts();
 
         let full_body = hyper::body::to_bytes(body).await?;
@@ -58,32 +63,18 @@ impl<H: conduit::Handler> BlockingHandler<H> {
 }
 
 /// Builds a `hyper::Response` given a `conduit:Response`
-fn good_response(mut response: conduit::Response) -> Response<Body> {
+fn good_response(mut response: ConduitResponse) -> HyperResponse {
     let mut body = Vec::new();
-    if response.body.write_body(&mut body).is_err() {
+    if response.body_mut().write_body(&mut body).is_err() {
         return server_error_response("Error writing body");
     }
 
-    let mut builder = Response::builder();
-    let status = match StatusCode::from_u16(response.status.0 as u16) {
-        Ok(s) => s,
-        Err(e) => return server_error_response(&e.to_string()),
-    };
-
-    for (key, values) in response.headers {
-        for value in values {
-            builder = builder.header(key.as_str(), value.as_str());
-        }
-    }
-
-    builder
-        .status(status)
-        .body(body.into())
-        .unwrap_or_else(|e| server_error_response(&e.to_string()))
+    let (parts, _) = response.into_parts();
+    Response::from_parts(parts, body.into())
 }
 
 /// Logs an error message and returns a generic status 500 response
-fn server_error_response(message: &str) -> Response<Body> {
+fn server_error_response(message: &str) -> HyperResponse {
     error!("Internal Server Error: {}", message);
     let body = Body::from("Internal Server Error");
     Response::builder()
@@ -93,7 +84,7 @@ fn server_error_response(message: &str) -> Response<Body> {
 }
 
 /// Logs an error message and returns a 503 status saying the service is over capacity
-fn over_capacity_error_response() -> Response<Body> {
+fn over_capacity_error_response() -> HyperResponse {
     const RETRY_AFTER: u32 = 2;
     error!("Server Capacity Exceeded");
     let body = Body::from(format!(