use Buffered Readers and Writers

README.md

@@ -10,9 +10,9 @@ An HTTP library for Rust.
 
 ```
 running 3 tests
-test bench_curl  ... bench:    346762 ns/iter (+/- 16469)
-test bench_http  ... bench:    310861 ns/iter (+/- 123168)
-test bench_hyper ... bench:    284916 ns/iter (+/- 65935)
+test bench_curl  ... bench:    234539 ns/iter (+/- 22228)
+test bench_http  ... bench:    290370 ns/iter (+/- 69179)
+test bench_hyper ... bench:    224482 ns/iter (+/- 95197)
 
 test result: ok. 0 passed; 0 failed; 0 ignored; 3 measured
 ```

src/client/request.rs

@@ -1,6 +1,6 @@
 //! Client Requests
 use std::io::net::tcp::TcpStream;
-use std::io::IoResult;
+use std::io::{BufferedWriter, IoResult};
 
 use url::Url;
 
@@ -23,7 +23,7 @@ pub struct Request {
     /// The HTTP version of this request.
     pub version: version::HttpVersion,
     headers_written: bool,
-    body: TcpStream,
+    body: BufferedWriter<TcpStream>,
 }
 
 impl Request {
@@ -43,6 +43,7 @@ impl Request {
         debug!("port={}", port);
 
         let stream = try_io!(TcpStream::connect(host.as_slice(), port));
+        let stream = BufferedWriter::new(stream);
         let mut headers = Headers::new();
         headers.set(Host(host));
         Ok(Request {
@@ -82,8 +83,9 @@ impl Request {
     /// Consumes the Request.
     pub fn send(mut self) -> HttpResult<Response> {
         try_io!(self.flush());
-        try_io!(self.body.close_write());
-        Response::new(self.body)
+        let mut raw = self.body.unwrap();
+        try_io!(raw.close_write());
+        Response::new(raw)
     }
 }
 

src/client/response.rs

@@ -1,5 +1,5 @@
 //! Client Responses
-use std::io::{Reader, IoResult};
+use std::io::{BufferedReader, IoResult};
 use std::io::net::tcp::TcpStream;
 
 use header::{mod, ContentLength, TransferEncoding, Chunked};
@@ -16,13 +16,14 @@ pub struct Response {
     pub headers: header::Headers,
     /// The HTTP version of this response from the server.
     pub version: version::HttpVersion,
-    body: HttpReader<TcpStream>,
+    body: HttpReader<BufferedReader<TcpStream>>,
 }
 
 impl Response {
 
     /// Creates a new response from a server.
-    pub fn new(mut tcp: TcpStream) -> HttpResult<Response> {
+    pub fn new(tcp: TcpStream) -> HttpResult<Response> {
+        let mut tcp = BufferedReader::new(tcp);
         let (version, status) = try!(read_status_line(&mut tcp));
         let mut headers = try!(header::Headers::from_raw(&mut tcp));
 

src/server/request.rs

@@ -2,7 +2,7 @@
 //!
 //! These are requests that a `hyper::Server` receives, and include its method,
 //! target URI, headers, and message body.
-use std::io::{Reader, IoResult};
+use std::io::{Reader, BufferedReader, IoResult};
 use std::io::net::ip::SocketAddr;
 use std::io::net::tcp::TcpStream;
 
@@ -26,7 +26,7 @@ pub struct Request {
     pub uri: RequestUri,
     /// The version of HTTP for this request.
     pub version: HttpVersion,
-    body: HttpReader<TcpStream>
+    body: HttpReader<BufferedReader<TcpStream>>
 }
 
 
@@ -35,13 +35,14 @@ impl Request {
     /// Create a new Request, reading the StartLine and Headers so they are
     /// immediately useful.
     pub fn new(mut tcp: TcpStream) -> HttpResult<Request> {
+        let remote_addr = try_io!(tcp.peer_name());
+        let mut tcp = BufferedReader::new(tcp);
         let (method, uri, version) = try!(read_request_line(&mut tcp));
         let mut headers = try!(Headers::from_raw(&mut tcp));
 
         debug!("{} {} {}", method, uri, version);
         debug!("{}", headers);
 
-        let remote_addr = try_io!(tcp.peer_name());
 
         // TODO: handle Transfer-Encoding
         let body = if headers.has::<ContentLength>() {

src/server/response.rs

@@ -2,7 +2,7 @@
 //!
 //! These are responses sent by a `hyper::Server` to clients, after
 //! receiving a request.
-use std::io::IoResult;
+use std::io::{BufferedWriter, IoResult};
 use std::io::net::tcp::TcpStream;
 
 use header;
@@ -21,7 +21,7 @@ pub struct Response {
     pub version: version::HttpVersion,
 
     headers_written: bool, // TODO: can this check be moved to compile time?
-    body: TcpStream
+    body: BufferedWriter<TcpStream>, // TODO: use a HttpWriter from rfc7230
 }
 
 impl Response {
@@ -33,7 +33,7 @@ impl Response {
             version: version::Http11,
             headers: header::Headers::new(),
             headers_written: false,
-            body: tcp
+            body: BufferedWriter::new(tcp)
         }
     }
 
@@ -56,9 +56,9 @@ impl Response {
     }
 
     /// Flushes all writing of a response to the client.
-    pub fn end(&mut self) -> IoResult<()> {
-        try!(self.flush());
-        self.body.close_write()
+    pub fn end(mut self) -> IoResult<()> {
+        debug!("ending");
+        self.flush()
     }
 }