forked/hyper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #858 from hyperium/ergo

Browse Source 
Move some exports around, add try_read/try_write
This commit is contained in:
Sean McArthur
2016-07-14 11:21:36 -07:00
committed by GitHub
parent 6d54a4dfdc 85894bc123
commit 8de8b74a8f
8 changed files with 85 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
examples/hello.rs
View File

@@ -3,11 +3,8 @@ extern crate hyper;
extern crate env_logger;
extern crate num_cpus;
use std::io::Write;
use hyper::{Decoder, Encoder, Next};
use hyper::net::{HttpStream, HttpListener};
use hyper::server::{Server, Handler, Request, Response};
use hyper::{Decoder, Encoder, Next, HttpStream};
use hyper::server::{Server, Handler, Request, Response, HttpListener};
static PHRASE: &'static [u8] = b"Hello World!";

37
examples/server.rs
View File

@@ -4,11 +4,8 @@ extern crate env_logger;
#[macro_use]
extern crate log;
use std::io::{self, Read, Write};
use hyper::{Get, Post, StatusCode, RequestUri, Decoder, Encoder, Next};
use hyper::{Get, Post, StatusCode, RequestUri, Decoder, Encoder, HttpStream, Next};
use hyper::header::ContentLength;
use hyper::net::HttpStream;
use hyper::server::{Server, Handler, Request, Response};
struct Echo {
@@ -78,13 +75,13 @@ impl Handler<HttpStream> for Echo {
match self.route {
Route::Echo(ref body) => {
if self.read_pos < self.buf.len() {
match transport.read(&mut self.buf[self.read_pos..]) {
Ok(0) => {
match transport.try_read(&mut self.buf[self.read_pos..]) {
Ok(Some(0)) => {
debug!("Read 0, eof");
self.eof = true;
Next::write()
},
Ok(n) => {
Ok(Some(n)) => {
self.read_pos += n;
match *body {
Body::Len(max) if max <= self.read_pos as u64 => {
@@ -94,12 +91,10 @@ impl Handler<HttpStream> for Echo {
_ => Next::read_and_write()
}
}
Err(e) => match e.kind() {
io::ErrorKind::WouldBlock => Next::read_and_write(),
_ => {
println!("read error {:?}", e);
Next::end()
}
Ok(None) => Next::read_and_write(),
Err(e) => {
println!("read error {:?}", e);
Next::end()
}
}
} else {
@@ -137,18 +132,16 @@ impl Handler<HttpStream> for Echo {
}
Route::Echo(..) => {
if self.write_pos < self.read_pos {
match transport.write(&self.buf[self.write_pos..self.read_pos]) {
Ok(0) => panic!("write ZERO"),
Ok(n) => {
match transport.try_write(&self.buf[self.write_pos..self.read_pos]) {
Ok(Some(0)) => panic!("write ZERO"),
Ok(Some(n)) => {
self.write_pos += n;
Next::write()
}
Err(e) => match e.kind() {
io::ErrorKind::WouldBlock => Next::write(),
_ => {
println!("write error {:?}", e);
Next::end()
}
Ok(None) => Next::write(),
Err(e) => {
println!("write error {:?}", e);
Next::end()
}
}
} else if !self.eof {

3
src/header/common/accept_language.rs
View File

@@ -21,8 +21,7 @@ header! {
///
/// # Examples
/// ```
/// use hyper::LanguageTag;
/// use hyper::header::{Headers, AcceptLanguage, qitem};
/// use hyper::header::{Headers, AcceptLanguage, LanguageTag, qitem};
///
/// let mut headers = Headers::new();
/// let mut langtag: LanguageTag = Default::default();

1
src/header/common/mod.rs
View File

@@ -120,7 +120,6 @@ macro_rules! __hyper__tm {
use std::str;
use $crate::header::*;
use $crate::mime::*;
use $crate::language_tags::*;
use $crate::method::Method;
use super::$id as HeaderField;
$($tf)*

1
src/header/shared/mod.rs
View File

@@ -4,6 +4,7 @@ pub use cookie::CookieJar;
pub use self::encoding::Encoding;
pub use self::entity::EntityTag;
pub use self::httpdate::HttpDate;
pub use language_tags::LanguageTag;
pub use self::quality_item::{Quality, QualityItem, qitem, q};
mod charset;

79
src/http/mod.rs
View File

@@ -72,6 +72,31 @@ impl<'a, T: Read> Decoder<'a, T> {
Decoder(DecoderImpl::H1(decoder, transport))
}
/// Read from the `Transport`.
#[inline]
pub fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
match self.0 {
DecoderImpl::H1(ref mut decoder, ref mut transport) => {
decoder.decode(transport, buf)
}
}
}
/// Try to read from the `Transport`.
///
/// This method looks for the `WouldBlock` error. If the read did not block,
/// a return value would be `Ok(Some(x))`. If the read would block,
/// this method would return `Ok(None)`.
#[inline]
pub fn try_read(&mut self, buf: &mut [u8]) -> io::Result<Option<usize>> {
match self.read(buf) {
Ok(n) => Ok(Some(n)),
Err(e) => match e.kind() {
io::ErrorKind::WouldBlock => Ok(None),
_ => Err(e)
}
}
}
/// Get a reference to the transport.
pub fn get_ref(&self) -> &T {
@@ -86,9 +111,42 @@ impl<'a, T: Transport> Encoder<'a, T> {
Encoder(EncoderImpl::H1(encoder, transport))
}
/// Write to the `Transport`.
#[inline]
pub fn write(&mut self, data: &[u8]) -> io::Result<usize> {
if data.is_empty() {
return Ok(0);
}
match self.0 {
EncoderImpl::H1(ref mut encoder, ref mut transport) => {
if encoder.is_closed() {
Ok(0)
} else {
encoder.encode(*transport, data)
}
}
}
}
/// Try to write to the `Transport`.
///
/// This method looks for the `WouldBlock` error. If the write did not block,
/// a return value would be `Ok(Some(x))`. If the write would block,
/// this method would return `Ok(None)`.
#[inline]
pub fn try_write(&mut self, data: &[u8]) -> io::Result<Option<usize>> {
match self.write(data) {
Ok(n) => Ok(Some(n)),
Err(e) => match e.kind() {
io::ErrorKind::WouldBlock => Ok(None),
_ => Err(e)
}
}
}
/// Closes an encoder, signaling that no more writing will occur.
///
/// This is needed for encodings that don't know length of the content
/// This is needed for encodings that don't know the length of the content
/// beforehand. Most common instance would be usage of
/// `Transfer-Enciding: chunked`. You would call `close()` to signal
/// the `Encoder` should write the end chunk, or `0\r\n\r\n`.
@@ -109,29 +167,14 @@ impl<'a, T: Transport> Encoder<'a, T> {
impl<'a, T: Read> Read for Decoder<'a, T> {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
match self.0 {
DecoderImpl::H1(ref mut decoder, ref mut transport) => {
decoder.decode(transport, buf)
}
}
self.read(buf)
}
}
impl<'a, T: Transport> Write for Encoder<'a, T> {
#[inline]
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
if data.is_empty() {
return Ok(0);
}
match self.0 {
EncoderImpl::H1(ref mut encoder, ref mut transport) => {
if encoder.is_closed() {
Ok(0)
} else {
encoder.encode(*transport, data)
}
}
}
self.write(data)
}
#[inline]

4
src/lib.rs
View File

@@ -49,14 +49,14 @@ extern crate test;
pub use url::Url;
pub use client::Client;
pub use error::{Result, Error};
pub use http::{Next, Encoder, Decoder, Control, ControlError};
pub use header::Headers;
pub use http::{Next, Encoder, Decoder, Control, ControlError};
pub use method::Method::{self, Get, Head, Post, Delete};
pub use net::{HttpStream, Transport};
pub use status::StatusCode::{self, Ok, BadRequest, NotFound};
pub use server::Server;
pub use uri::RequestUri;
pub use version::HttpVersion;
pub use language_tags::LanguageTag;
macro_rules! rotor_try {
($e:expr) => ({

4
src/server/mod.rs
View File

@@ -15,7 +15,9 @@ pub use self::request::Request;
pub use self::response::Response;
use http::{self, Next};
use net::{Accept, HttpListener, HttpsListener, SslServer, Transport};
pub use net::{Accept, HttpListener, HttpsListener};
use net::{SslServer, Transport};
mod request;