use NetworkStream in client

Author: seanmonstar

src/client/request.rs

@@ -1,10 +1,10 @@
 //! Client Requests
-use std::io::net::tcp::TcpStream;
 use std::io::{BufferedWriter, IoResult};
 
 use url::Url;
 
 use method;
+use net::{NetworkStream, HttpStream};
 use header::{Headers, Host};
 use rfc7230::LINE_ENDING;
 use version;
@@ -13,7 +13,7 @@ use super::{Response};
 
 
 /// A client request to a remote server.
-pub struct Request {
+pub struct Request<S = HttpStream> {
     /// The method of this request.
     pub method: method::Method,
     /// The headers that will be sent with this request.
@@ -23,13 +23,13 @@ pub struct Request {
     /// The HTTP version of this request.
     pub version: version::HttpVersion,
     headers_written: bool,
-    body: BufferedWriter<TcpStream>,
+    body: BufferedWriter<S>,
 }
 
-impl Request {
+impl<S: NetworkStream> Request<S> {
 
     /// Create a new client request.
-    pub fn new(method: method::Method, url: Url) -> HttpResult<Request> {
+    pub fn new(method: method::Method, url: Url) -> HttpResult<Request<S>> {
         debug!("{} {}", method, url);
         let host = match url.serialize_host() {
             Some(host) => host,
@@ -42,7 +42,7 @@ impl Request {
         };
         debug!("port={}", port);
 
-        let stream = try_io!(TcpStream::connect(host.as_slice(), port));
+        let stream = try_io!(NetworkStream::connect(host.as_slice(), port));
         let stream = BufferedWriter::new(stream);
         let mut headers = Headers::new();
         headers.set(Host(host));
@@ -81,16 +81,15 @@ impl Request {
     /// Completes writing the request, and returns a response to read from.
     ///
     /// Consumes the Request.
-    pub fn send(mut self) -> HttpResult<Response> {
+    pub fn send(mut self) -> HttpResult<Response<S>> {
         try_io!(self.flush());
-        let mut raw = self.body.unwrap();
-        try_io!(raw.close_write());
+        let raw = self.body.unwrap();
         Response::new(raw)
     }
 }
 
 
-impl Writer for Request {
+impl<S: NetworkStream> Writer for Request<S> {
     fn write(&mut self, msg: &[u8]) -> IoResult<()> {
         if !self.headers_written {
             try!(self.write_head());

src/client/response.rs

@@ -1,31 +1,31 @@
 //! Client Responses
 use std::io::{BufferedReader, IoResult};
-use std::io::net::tcp::TcpStream;
 
 use header::{mod, ContentLength, TransferEncoding, Chunked};
+use net::{NetworkStream, HttpStream};
 use rfc7230::{read_status_line, HttpReader, SizedReader, ChunkedReader, EofReader};
 use status;
 use version;
 use {HttpResult};
 
 /// A response for a client request to a remote server.
-pub struct Response {
+pub struct Response<S = HttpStream> {
     /// The status from the server.
     pub status: status::StatusCode,
     /// The headers from the server.
     pub headers: header::Headers,
     /// The HTTP version of this response from the server.
     pub version: version::HttpVersion,
-    body: HttpReader<BufferedReader<TcpStream>>,
+    body: HttpReader<BufferedReader<S>>,
 }
 
-impl Response {
+impl<S: NetworkStream> Response<S> {
 
     /// Creates a new response from a server.
-    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));
+    pub fn new(stream: S) -> HttpResult<Response<S>> {
+        let mut stream = BufferedReader::new(stream);
+        let (version, status) = try!(read_status_line(&mut stream));
+        let mut headers = try!(header::Headers::from_raw(&mut stream));
 
         debug!("{} {}", version, status);
         debug!("{}", headers);
@@ -38,22 +38,22 @@ impl Response {
                     };
 
                     if codings.contains(&Chunked) {
-                        ChunkedReader(tcp, None)
+                        ChunkedReader(stream, None)
                     } else {
-                        debug!("not chucked. read till eof");
-                        EofReader(tcp)
+                        debug!("not chuncked. read till eof");
+                        EofReader(stream)
                     }
                 }
                 None => unreachable!()
             }
         } else if headers.has::<ContentLength>() {
             match headers.get_ref::<ContentLength>() {
-                Some(&ContentLength(len)) => SizedReader(tcp, len),
+                Some(&ContentLength(len)) => SizedReader(stream, len),
                 None => unreachable!()
             }
         } else {
             debug!("neither Transfer-Encoding nor Content-Length");
-            EofReader(tcp)
+            EofReader(stream)
         };
 
         Ok(Response {
@@ -65,7 +65,8 @@ impl Response {
     }
 }
 
-impl Reader for Response {
+impl<S: NetworkStream> Reader for Response<S> {
+    #[inline]
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
         self.body.read(buf)
     }

src/net.rs

@@ -25,6 +25,9 @@ pub trait NetworkAcceptor<S: NetworkStream>: Acceptor<S> + Clone + Send {
 pub trait NetworkStream: Stream + Clone {
     /// Get the remote address of the underlying connection.
     fn peer_name(&mut self) -> IoResult<SocketAddr>;
+
+    /// Connect to a remote address.
+    fn connect(host: &str, port: Port) -> IoResult<Self>;
 }
 
 /// A `NetworkListener` for `HttpStream`s.
@@ -107,4 +110,11 @@ impl NetworkStream for HttpStream {
     fn peer_name(&mut self) -> IoResult<SocketAddr> {
         self.inner.peer_name()
     }
+
+    #[inline]
+    fn connect(host: &str, port: Port) -> IoResult<HttpStream> {
+        Ok(HttpStream {
+            inner: try!(TcpStream::connect(host, port))
+        })
+    }
 }