Improve the conduit::Body type

jtgeibel · jtgeibel · commit 0deff5b4a3ba · 2020-03-01T12:31:59.000-05:00
The `WriteBody` trait was only used to support sending files via
`conduit-static` and child process standard output via
`conduit-git-http-backend`.

The git functionality is only used by crates.io in development mode, so
I have focused on file handling functionality.  The new structure allows
the blocking `civet` server to continue using `io::copy` while
`conduit-hyper` can turn the blocking `File` into an async
`tokio::fs::File` and free the background thread to handle other
requests.

For now, `conduit-git-http-backend` will fall back to buffering the
response into a `Vec&lt;u8&gt;` rather than streaming chunks of data as it
arrives from the child process.  This seems like an acceptable tradeoff
given the functionality is only used when doing local development within
a docker container.
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 
 name = "conduit"
-version = "0.9.0-alpha.1"
+version = "0.9.0-alpha.2"
 authors = ["wycats@gmail.com",
            "Alex Crichton <alex@alexcrichton.com>"]
 description = "Common HTTP server interface"
diff --git a/example/Cargo.toml b/example/Cargo.toml
@@ -4,6 +4,6 @@ version = "0.0.1"
 authors = ["Example User <mail@example.com>"]
 
 [dependencies]
-civet = "0.12.0-alpha.2"
-conduit = "0.9.0-alpha.1"
-conduit-router = "0.9.0-alpha.1"
+civet = "0.12.0-alpha.3"
+conduit = "0.9.0-alpha.2"
+conduit-router = "0.9.0-alpha.2"
diff --git a/example/src/main.rs b/example/src/main.rs
@@ -5,17 +5,17 @@ extern crate conduit_router;
 use std::sync::mpsc::channel;
 
 use civet::{Config, Server};
-use conduit::{static_to_body, vec_to_body, HttpResult, RequestExt, Response};
+use conduit::{Body, HttpResult, RequestExt, Response};
 use conduit_router::{RequestParams, RouteBuilder};
 
 fn name(req: &mut dyn RequestExt) -> HttpResult {
     let name = req.params().find("name").unwrap();
     let bytes = format!("Hello {}!", name).into_bytes();
-    Response::builder().body(vec_to_body(bytes))
+    Response::builder().body(Body::from_vec(bytes))
 }
 
 fn hello(_req: &mut dyn RequestExt) -> HttpResult {
-    Response::builder().body(static_to_body(b"Hello world!"))
+    Response::builder().body(Body::from_static(b"Hello world!"))
 }
 
 fn main() {
diff --git a/src/lib.rs b/src/lib.rs
@@ -3,27 +3,39 @@
 extern crate http;
 
 use std::error::Error;
-use std::io::{self, prelude::*, Cursor};
+use std::fs::File;
+use std::io::Read;
 use std::net::SocketAddr;
 
 pub use http::{header, HeaderMap, Method, Request, Response, StatusCode, Version};
 
 pub use self::typemap::TypeMap;
 mod typemap;
 
-pub type Body = Box<dyn WriteBody>;
 pub type ResponseResult<Error> = Result<Response<Body>, Error>;
 pub type HttpResult = ResponseResult<http::Error>;
 
 pub type BoxError = Box<dyn Error + Send>;
 pub type HandlerResult = Result<Response<Body>, BoxError>;
 
-pub fn static_to_body(bytes: &'static [u8]) -> Body {
-    Box::new(bytes)
+pub enum Body {
+    Static(&'static [u8]),
+    Owned(Vec<u8>),
+    File(File),
 }
 
-pub fn vec_to_body(bytes: Vec<u8>) -> Body {
-    Box::new(Cursor::new(bytes))
+impl Body {
+    pub fn empty() -> Self {
+        Self::from_static(b"")
+    }
+
+    pub fn from_static(bytes: &'static [u8]) -> Self {
+        Self::Static(bytes)
+    }
+
+    pub fn from_vec(bytes: Vec<u8>) -> Self {
+        Self::Owned(bytes)
+    }
 }
 
 pub fn box_error<E: Error + Send + 'static>(error: E) -> BoxError {
@@ -104,19 +116,3 @@ where
         (*self)(request).map_err(box_error)
     }
 }
-
-/// A trait which writes the response body out to a `Write`r.
-///
-/// This is implemented for all `Read`ers.
-pub trait WriteBody {
-    fn write_body(&mut self, out: &mut dyn Write) -> io::Result<u64>;
-}
-
-impl<R> WriteBody for R
-where
-    R: Read,
-{
-    fn write_body(&mut self, out: &mut dyn Write) -> io::Result<u64> {
-        io::copy(self, out)
-    }
-}
