implementation

src/client/mod.rs

@@ -0,0 +1,22 @@
+//! # Client
+use url::Url;
+
+use method::{Get, Method};
+
+pub use self::request::Request;
+pub use self::response::Response;
+use {HttpResult};
+
+pub mod request;
+pub mod response;
+
+
+/// Create a GET client request.
+pub fn get(url: Url) -> HttpResult<Request> {
+    request(Get, url)
+}
+
+/// Create a client request.
+pub fn request(method: Method, url: Url) -> HttpResult<Request> {
+    Request::new(method, url)
+}

src/client/request.rs

@@ -0,0 +1,106 @@
+//! # Client Requests
+use std::io::net::tcp::TcpStream;
+use std::io::IoResult;
+
+use url::Url;
+
+use method;
+use header::{Headers, Host};
+use rfc7230::LINE_ENDING;
+use version;
+use {HttpResult, HttpUriError};
+use super::{Response};
+
+
+/// A client request to a remote server.
+pub struct Request {
+    /// The method of this request.
+    pub method: method::Method,
+    /// The headers that will be sent with this request.
+    pub headers: Headers,
+    /// The target URI for this request.
+    pub url: Url,
+    /// The HTTP version of this request.
+    pub version: version::HttpVersion,
+    headers_written: bool,
+    body: TcpStream,
+}
+
+impl Request {
+
+    /// Create a new client request.
+    pub fn new(method: method::Method, url: Url) -> HttpResult<Request> {
+        debug!("{} {}", method, url);
+        let host = match url.serialize_host() {
+            Some(host) => host,
+            None => return Err(HttpUriError)
+        };
+        debug!("host={}", host);
+        let port = match url.port_or_default() {
+            Some(port) => port,
+            None => return Err(HttpUriError)
+        };
+        debug!("port={}", port);
+
+        let stream = try_io!(TcpStream::connect(host.as_slice(), port));
+        let mut headers = Headers::new();
+        headers.set(Host(host));
+        Ok(Request {
+            method: method,
+            headers: headers,
+            url: url,
+            version: version::Http11,
+            headers_written: false,
+            body: stream
+        })
+    }
+
+    fn write_head(&mut self) -> IoResult<()> {
+        if self.headers_written {
+            debug!("headers previsouly written, nooping");
+            return Ok(());
+        }
+        self.headers_written = true;
+
+        let uri = self.url.serialize_path().unwrap();
+        debug!("writing head: {} {} {}", self.method, uri, self.version);
+        try!(write!(self.body, "{} {} {}", self.method, uri, self.version))
+        try!(self.body.write(LINE_ENDING));
+
+        debug!("{}", self.headers);
+
+        for (name, header) in self.headers.iter() {
+            try!(write!(self.body, "{}: {}", name, header));
+            try!(self.body.write(LINE_ENDING));
+        }
+
+        self.body.write(LINE_ENDING)
+    }
+
+    /// Completes writing the request, and returns a response to read from.
+    ///
+    /// Consumes the Request.
+    pub fn send(mut self) -> HttpResult<Response> {
+        try_io!(self.flush());
+        try_io!(self.body.close_write());
+        Response::new(self.body)
+    }
+}
+
+
+impl Writer for Request {
+    fn write(&mut self, msg: &[u8]) -> IoResult<()> {
+        if !self.headers_written {
+            try!(self.write_head());
+        }
+        self.body.write(msg)
+    }
+
+    fn flush(&mut self) -> IoResult<()> {
+        if !self.headers_written {
+            try!(self.write_head());
+        }
+        self.body.flush()
+    }
+}
+

src/client/response.rs

@@ -0,0 +1,71 @@
+//! # Client Responses
+use std::io::{Reader, IoResult};
+use std::io::net::tcp::TcpStream;
+
+use header::{mod, ContentLength, TransferEncoding, Chunked};
+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 {
+    /// 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<TcpStream>,
+}
+
+impl Response {
+
+    /// Creates a new response from a server.
+    pub fn new(mut tcp: TcpStream) -> HttpResult<Response> {
+        let (version, status) = try!(read_status_line(&mut tcp));
+        let mut headers = try!(header::Headers::from_raw(&mut tcp));
+
+        debug!("{} {}", version, status);
+        debug!("{}", headers);
+
+        let body = if headers.has::<TransferEncoding>() {
+            match headers.get_ref::<TransferEncoding>() {
+                Some(&TransferEncoding(ref codings)) => {
+                    if codings.len() > 1 {
+                        debug!("TODO: handle other codings: {}", codings);
+                    };
+
+                    if codings.contains(&Chunked) {
+                        ChunkedReader(tcp, None)
+                    } else {
+                        debug!("not chucked. read till eof");
+                        EofReader(tcp)
+                    }
+                }
+                None => unreachable!()
+            }
+        } else if headers.has::<ContentLength>() {
+            match headers.get_ref::<ContentLength>() {
+                Some(&ContentLength(len)) => SizedReader(tcp, len),
+                None => unreachable!()
+            }
+        } else {
+            debug!("neither Transfer-Encoding nor Content-Length");
+            EofReader(tcp)
+        };
+
+        Ok(Response {
+            status: status,
+            version: version,
+            headers: headers,
+            body: body,
+        })
+    }
+}
+
+impl Reader for Response {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+        self.body.read(buf)
+    }
+}