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

refactor(lib): convert usage of tokio_core::io to tokio_io

Browse Source 
This commit updates to the most recent versions (released today) of the various
Tokio libraries in use. Namely the `tokio_core::io` module has now been
deprecated in favor of an external `tokio-io` crate. This commit pulls in that
crate and uses the `AsyncRead + AsyncWrite` abstraction instead of `Io` from
tokio-core.

BREAKING CHANGE: Any external types that were using that had implemented `Io` will need to 
  implement `AsyncRead + AsyncWrite` from tokio_io.
This commit is contained in:
Alex Crichton
2017-03-17 19:31:44 -05:00
committed by Sean McArthur
parent 34509ef51a
commit 8554904dc9
11 changed files with 118 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/client/connect.rs
View File

@@ -3,7 +3,7 @@ use std::io;
//use std::net::SocketAddr;
use futures::{Future, Poll, Async};
use tokio::io::Io;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio::reactor::Handle;
use tokio::net::{TcpStream, TcpStreamNew};
use tokio_service::Service;
@@ -18,7 +18,7 @@ use super::dns;
/// `Request=Url` and `Response: Io` instead.
pub trait Connect: Service<Request=Url, Error=io::Error> + 'static {
/// The connected Io Stream.
type Output: Io + 'static;
type Output: AsyncRead + AsyncWrite + 'static;
/// A Future that will resolve to the connected Stream.
type Future: Future<Item=Self::Output, Error=io::Error> + 'static;
/// Connect to a remote address.
@@ -27,7 +27,7 @@ pub trait Connect: Service<Request=Url, Error=io::Error> + 'static {
impl<T> Connect for T
where T: Service<Request=Url, Error=io::Error> + 'static,
T::Response: Io,
T::Response: AsyncRead + AsyncWrite,
T::Future: Future<Error=io::Error>,
{
type Output = T::Response;

16
src/client/mod.rs
View File

@@ -11,8 +11,8 @@ use std::rc::Rc;
use std::time::Duration;
use futures::{Poll, Async, Future, Stream};
use relay;
use tokio::io::Io;
use futures::unsync::oneshot;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio::reactor::Handle;
use tokio_proto::BindClient;
use tokio_proto::streaming::Message;
@@ -149,12 +149,12 @@ where C: Connect,
let pool_key = Rc::new(url[..::url::Position::BeforePath].to_owned());
self.connector.connect(url)
.map(move |io| {
let (tx, rx) = relay::channel();
let (tx, rx) = oneshot::channel();
let client = HttpClient {
client_rx: RefCell::new(Some(rx)),
}.bind_client(&handle, io);
let pooled = pool.pooled(pool_key, client);
tx.complete(pooled.clone());
drop(tx.send(pooled.clone()));
pooled
})
};
@@ -207,11 +207,11 @@ impl<C, B> fmt::Debug for Client<C, B> {
type TokioClient<B> = ClientProxy<Message<http::RequestHead, B>, Message<http::ResponseHead, TokioBody>, ::Error>;
struct HttpClient<B> {
client_rx: RefCell<Option<relay::Receiver<Pooled<TokioClient<B>>>>>,
client_rx: RefCell<Option<oneshot::Receiver<Pooled<TokioClient<B>>>>>,
}
impl<T, B> ClientProto<T> for HttpClient<B>
where T: Io + 'static,
where T: AsyncRead + AsyncWrite + 'static,
B: Stream<Error=::Error> + 'static,
B::Item: AsRef<[u8]>,
{
@@ -232,12 +232,12 @@ where T: Io + 'static,
}
struct BindingClient<T, B> {
rx: relay::Receiver<Pooled<TokioClient<B>>>,
rx: oneshot::Receiver<Pooled<TokioClient<B>>>,
io: Option<T>,
}
impl<T, B> Future for BindingClient<T, B>
where T: Io + 'static,
where T: AsyncRead + AsyncWrite + 'static,
B: Stream<Error=::Error>,
B::Item: AsRef<[u8]>,
{

51
src/client/pool.rs
View File

@@ -7,7 +7,7 @@ use std::rc::Rc;
use std::time::{Duration, Instant};
use futures::{Future, Async, Poll};
use relay;
use futures::unsync::oneshot;
use http::{KeepAlive, KA};
@@ -18,7 +18,7 @@ pub struct Pool<T> {
struct PoolInner<T> {
enabled: bool,
idle: HashMap<Rc<String>, Vec<Entry<T>>>,
parked: HashMap<Rc<String>, VecDeque<relay::Sender<Entry<T>>>>,
parked: HashMap<Rc<String>, VecDeque<oneshot::Sender<Entry<T>>>>,
timeout: Option<Duration>,
}
@@ -44,31 +44,33 @@ impl<T: Clone> Pool<T> {
fn put(&mut self, key: Rc<String>, entry: Entry<T>) {
trace!("Pool::put {:?}", key);
let mut inner = self.inner.borrow_mut();
//let inner = &mut *inner;
let mut remove_parked = false;
let tx = self.inner.borrow_mut().parked.get_mut(&key).and_then(|parked| {
let mut ret = None;
let mut entry = Some(entry);
if let Some(parked) = inner.parked.get_mut(&key) {
while let Some(tx) = parked.pop_front() {
if !tx.is_canceled() {
ret = Some(tx);
break;
match tx.send(entry.take().unwrap()) {
Ok(()) => break,
Err(e) => {
trace!("Pool::put removing canceled parked {:?}", key);
entry = Some(e);
}
}
trace!("Pool::put removing canceled parked {:?}", key);
}
remove_parked = parked.is_empty();
ret
});
}
if remove_parked {
self.inner.borrow_mut().parked.remove(&key);
inner.parked.remove(&key);
}
if let Some(tx) = tx {
trace!("Pool::put found parked {:?}", key);
tx.complete(entry);
} else {
self.inner.borrow_mut()
.idle.entry(key)
.or_insert(Vec::new())
.push(entry);
match entry {
Some(entry) => {
inner.idle.entry(key)
.or_insert(Vec::new())
.push(entry);
}
None => trace!("Pool::put found parked {:?}", key),
}
}
@@ -100,7 +102,7 @@ impl<T: Clone> Pool<T> {
}
}
fn park(&mut self, key: Rc<String>, tx: relay::Sender<Entry<T>>) {
fn park(&mut self, key: Rc<String>, tx: oneshot::Sender<Entry<T>>) {
trace!("Pool::park {:?}", key);
self.inner.borrow_mut()
.parked.entry(key)
@@ -191,7 +193,7 @@ struct Entry<T> {
pub struct Checkout<T> {
key: Rc<String>,
pool: Pool<T>,
parked: Option<relay::Receiver<Entry<T>>>,
parked: Option<oneshot::Receiver<Entry<T>>>,
}
impl<T: Clone> Future for Checkout<T> {
@@ -247,7 +249,7 @@ impl<T: Clone> Future for Checkout<T> {
Some(entry) => Ok(Async::Ready(self.pool.reuse(self.key.clone(), entry))),
None => {
if self.parked.is_none() {
let (tx, mut rx) = relay::channel();
let (tx, mut rx) = oneshot::channel();
let _ = rx.poll(); // park this task
self.pool.park(self.key.clone(), tx);
self.parked = Some(rx);
@@ -279,6 +281,7 @@ mod tests {
use std::rc::Rc;
use std::time::Duration;
use futures::{Async, Future};
use futures::future;
use http::KeepAlive;
use super::Pool;
@@ -297,7 +300,7 @@ mod tests {
#[test]
fn test_pool_checkout_returns_none_if_expired() {
::futures::lazy(|| {
future::lazy(|| {
let pool = Pool::new(true, Some(Duration::from_secs(1)));
let key = Rc::new("foo".to_string());
let mut pooled = pool.pooled(key.clone(), 41);
@@ -339,7 +342,7 @@ mod tests {
let pooled1 = pool.pooled(key.clone(), 41);
let mut pooled = pooled1.clone();
let checkout = pool.checkout(&key).join(::futures::lazy(move || {
let checkout = pool.checkout(&key).join(future::lazy(move || {
// the checkout future will park first,
// and then this lazy future will be polled, which will insert
// the pooled back into the pool

36
src/http/conn.rs
View File

@@ -5,7 +5,7 @@ use std::time::Instant;
use futures::{Poll, Async, AsyncSink, Stream, Sink, StartSend};
use futures::task::Task;
use tokio::io::Io;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_proto::streaming::pipeline::{Frame, Transport};
use header::{ContentLength, TransferEncoding};
@@ -16,7 +16,7 @@ use version::HttpVersion;
/// This handles a connection, which will have been established over an
/// `Io` (like a socket), and will likely include multiple
/// `AsyncRead + AsyncWrite` (like a socket), and will likely include multiple
/// `Transaction`s over HTTP.
///
/// The connection will determine when a message begins and ends as well as
@@ -29,7 +29,7 @@ pub struct Conn<I, B, T, K = KA> {
}
impl<I, B, T, K> Conn<I, B, T, K>
where I: Io,
where I: AsyncRead + AsyncWrite,
B: AsRef<[u8]>,
T: Http1Transaction,
K: KeepAlive
@@ -155,7 +155,7 @@ where I: Io,
}
fn maybe_park_read(&mut self) {
if self.io.poll_read().is_ready() {
if !self.io.is_read_blocked() {
// the Io object is ready to read, which means it will never alert
// us that it is ready until we drain it. However, we're currently
// finished reading, so we need to park the task to be able to
@@ -350,7 +350,7 @@ where I: Io,
}
impl<I, B, T, K> Stream for Conn<I, B, T, K>
where I: Io,
where I: AsyncRead + AsyncWrite,
B: AsRef<[u8]>,
T: Http1Transaction,
K: KeepAlive,
@@ -385,7 +385,7 @@ where I: Io,
}
impl<I, B, T, K> Sink for Conn<I, B, T, K>
where I: Io,
where I: AsyncRead + AsyncWrite,
B: AsRef<[u8]>,
T: Http1Transaction,
K: KeepAlive,
@@ -450,10 +450,15 @@ where I: Io,
trace!("Conn::flush = {:?}", ret);
ret
}
fn close(&mut self) -> Poll<(), Self::SinkError> {
try_ready!(self.poll_complete());
self.io.io_mut().shutdown()
}
}
impl<I, B, T, K> Transport for Conn<I, B, T, K>
where I: Io + 'static,
where I: AsyncRead + AsyncWrite + 'static,
B: AsRef<[u8]> + 'static,
T: Http1Transaction + 'static,
K: KeepAlive + 'static,
@@ -665,6 +670,7 @@ impl<'a, T: fmt::Debug + 'a, B: AsRef<[u8]> + 'a> fmt::Debug for DebugFrame<'a,
#[cfg(test)]
mod tests {
use futures::{Async, Future, Stream, Sink};
use futures::future;
use tokio_proto::streaming::pipeline::Frame;
use http::{self, MessageHead, ServerTransaction};
@@ -705,7 +711,7 @@ mod tests {
#[test]
fn test_conn_parse_partial() {
let _: Result<(), ()> = ::futures::lazy(|| {
let _: Result<(), ()> = future::lazy(|| {
let good_message = b"GET / HTTP/1.1\r\nHost: foo.bar\r\n\r\n".to_vec();
let io = AsyncIo::new_buf(good_message, 10);
let mut conn = Conn::<_, http::Chunk, ServerTransaction>::new(io, Default::default());
@@ -772,7 +778,7 @@ mod tests {
#[test]
fn test_conn_body_write_length() {
let _: Result<(), ()> = ::futures::lazy(|| {
let _: Result<(), ()> = future::lazy(|| {
let io = AsyncIo::new_buf(vec![], 0);
let mut conn = Conn::<_, http::Chunk, ServerTransaction>::new(io, Default::default());
let max = ::http::io::MAX_BUFFER_SIZE + 4096;
@@ -800,7 +806,7 @@ mod tests {
#[test]
fn test_conn_body_write_chunked() {
let _: Result<(), ()> = ::futures::lazy(|| {
let _: Result<(), ()> = future::lazy(|| {
let io = AsyncIo::new_buf(vec![], 4096);
let mut conn = Conn::<_, http::Chunk, ServerTransaction>::new(io, Default::default());
conn.state.writing = Writing::Body(Encoder::chunked(), None);
@@ -813,7 +819,7 @@ mod tests {
#[test]
fn test_conn_body_flush() {
let _: Result<(), ()> = ::futures::lazy(|| {
let _: Result<(), ()> = future::lazy(|| {
let io = AsyncIo::new_buf(vec![], 1024 * 1024 * 5);
let mut conn = Conn::<_, http::Chunk, ServerTransaction>::new(io, Default::default());
conn.state.writing = Writing::Body(Encoder::length(1024 * 1024), None);
@@ -829,7 +835,7 @@ mod tests {
#[test]
fn test_conn_parking() {
use std::sync::Arc;
use futures::task::Unpark;
use futures::executor::Unpark;
struct Car {
permit: bool,
@@ -847,7 +853,7 @@ mod tests {
}
// test that once writing is done, unparks
let f = ::futures::lazy(|| {
let f = future::lazy(|| {
let io = AsyncIo::new_buf(vec![], 4096);
let mut conn = Conn::<_, http::Chunk, ServerTransaction>::new(io, Default::default());
conn.state.reading = Reading::KeepAlive;
@@ -861,7 +867,7 @@ mod tests {
// test that flushing when not waiting on read doesn't unpark
let f = ::futures::lazy(|| {
let f = future::lazy(|| {
let io = AsyncIo::new_buf(vec![], 4096);
let mut conn = Conn::<_, http::Chunk, ServerTransaction>::new(io, Default::default());
conn.state.writing = Writing::KeepAlive;
@@ -872,7 +878,7 @@ mod tests {
// test that flushing and writing isn't done doesn't unpark
let f = ::futures::lazy(|| {
let f = future::lazy(|| {
let io = AsyncIo::new_buf(vec![], 4096);
let mut conn = Conn::<_, http::Chunk, ServerTransaction>::new(io, Default::default());
conn.state.reading = Reading::KeepAlive;

2
src/http/h1/decode.rs
View File

@@ -295,7 +295,7 @@ mod tests {
let (a, b) = self.split_at(n);
let mut buf = BytesMut::from(a);
*self = b;
Ok(buf.drain_to(n).freeze())
Ok(buf.split_to(n).freeze())
} else {
Ok(Bytes::new())
}

4
src/http/h1/parse.rs
View File

@@ -55,7 +55,7 @@ impl Http1Transaction for ServerTransaction {
};
let mut headers = Headers::with_capacity(headers_len);
let slice = buf.drain_to(len).freeze();
let slice = buf.split_to(len).freeze();
let path = slice.slice(path.0, path.1);
// path was found to be utf8 by httparse
let path = unsafe { ByteStr::from_utf8_unchecked(path) };
@@ -171,7 +171,7 @@ impl Http1Transaction for ClientTransaction {
};
let mut headers = Headers::with_capacity(headers_len);
let slice = buf.drain_to(len).freeze();
let slice = buf.split_to(len).freeze();
headers.extend(HeadersAsBytesIter {
headers: headers_indices[..headers_len].iter(),
slice: slice,

35
src/http/io.rs
View File

@@ -3,8 +3,7 @@ use std::fmt;
use std::io::{self, Write};
use std::ptr;
use futures::Async;
use tokio::io::Io;
use tokio_io::{AsyncRead, AsyncWrite};
use http::{Http1Transaction, h1, MessageHead, ParseResult, DebugTruncate};
use bytes::{BytesMut, Bytes};
@@ -14,6 +13,7 @@ pub const MAX_BUFFER_SIZE: usize = 8192 + 4096 * 100;
pub struct Buffered<T> {
io: T,
read_blocked: bool,
read_buf: BytesMut,
write_buf: WriteBuf,
}
@@ -27,12 +27,13 @@ impl<T> fmt::Debug for Buffered<T> {
}
}
impl<T: Io> Buffered<T> {
impl<T: AsyncRead + AsyncWrite> Buffered<T> {
pub fn new(io: T) -> Buffered<T> {
Buffered {
io: io,
read_buf: BytesMut::with_capacity(0),
write_buf: WriteBuf::new(),
read_blocked: false,
}
}
@@ -49,14 +50,10 @@ impl<T: Io> Buffered<T> {
_ => break,
}
}
self.read_buf.drain_to(i);
self.read_buf.split_to(i);
}
}
pub fn poll_read(&mut self) -> Async<()> {
self.io.poll_read()
}
pub fn parse<S: Http1Transaction>(&mut self) -> ::Result<Option<MessageHead<S::Incoming>>> {
self.reserve_read_buf();
match self.read_from_io() {
@@ -88,8 +85,17 @@ impl<T: Io> Buffered<T> {
fn read_from_io(&mut self) -> io::Result<usize> {
use bytes::BufMut;
self.read_blocked = false;
unsafe {
let n = try!(self.io.read(self.read_buf.bytes_mut()));
let n = match self.io.read(self.read_buf.bytes_mut()) {
Ok(n) => n,
Err(e) => {
if e.kind() == io::ErrorKind::WouldBlock {
self.read_blocked = true;
}
return Err(e)
}
};
self.read_buf.advance_mut(n);
Ok(n)
}
@@ -112,10 +118,13 @@ impl<T: Io> Buffered<T> {
self.write_buf.buffer(buf.as_ref())
}
#[cfg(test)]
pub fn io_mut(&mut self) -> &mut T {
&mut self.io
}
pub fn is_read_blocked(&self) -> bool {
self.read_blocked
}
}
impl<T: Write> Write for Buffered<T> {
@@ -146,17 +155,17 @@ pub trait MemRead {
fn read_mem(&mut self, len: usize) -> io::Result<Bytes>;
}
impl<T: Io> MemRead for Buffered<T> {
impl<T: AsyncRead + AsyncWrite> MemRead for Buffered<T> {
fn read_mem(&mut self, len: usize) -> io::Result<Bytes> {
trace!("Buffered.read_mem read_buf={}, wanted={}", self.read_buf.len(), len);
if !self.read_buf.is_empty() {
let n = ::std::cmp::min(len, self.read_buf.len());
trace!("Buffered.read_mem read_buf is not empty, slicing {}", n);
Ok(self.read_buf.drain_to(n).freeze())
Ok(self.read_buf.split_to(n).freeze())
} else {
self.reserve_read_buf();
let n = try!(self.read_from_io());
Ok(self.read_buf.drain_to(::std::cmp::min(len, n)).freeze())
Ok(self.read_buf.split_to(::std::cmp::min(len, n)).freeze())
}
}
}

2
src/lib.rs
View File

@@ -21,10 +21,10 @@ extern crate httparse;
#[cfg_attr(test, macro_use)] extern crate language_tags;
#[macro_use] extern crate log;
#[macro_use] pub extern crate mime;
extern crate relay;
extern crate base64;
extern crate time;
#[macro_use] extern crate tokio_core as tokio;
extern crate tokio_io;
extern crate tokio_proto;
extern crate tokio_service;
extern crate unicase;

23
src/mock.rs
View File

@@ -1,8 +1,8 @@
use std::cmp;
use std::io::{self, Read, Write};
use futures::Async;
use tokio::io::Io;
use futures::Poll;
use tokio_io::{AsyncRead, AsyncWrite};
#[derive(Debug)]
pub struct Buf {
@@ -123,21 +123,12 @@ impl<T: Write> Write for AsyncIo<T> {
}
}
impl<T: Read + Write> Io for AsyncIo<T> {
fn poll_read(&mut self) -> Async<()> {
if self.bytes_until_block == 0 {
Async::NotReady
} else {
Async::Ready(())
}
}
impl<T: Read + Write> AsyncRead for AsyncIo<T> {
}
fn poll_write(&mut self) -> Async<()> {
if self.bytes_until_block == 0 {
Async::NotReady
} else {
Async::Ready(())
}
impl<T: Read + Write> AsyncWrite for AsyncIo<T> {
fn shutdown(&mut self) -> Poll<(), io::Error> {
Ok(().into())
}
}

33
src/server/mod.rs
View File

@@ -13,9 +13,10 @@ use std::time::Duration;
use futures::future;
use futures::task::{self, Task};
use futures::{Future, Map, Stream, Poll, Async, Sink, StartSend, AsyncSink};
use futures::{Future, Stream, Poll, Async, Sink, StartSend, AsyncSink};
use futures::future::Map;
use tokio::io::Io;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio::reactor::{Core, Handle, Timeout};
use tokio::net::TcpListener;
use tokio_proto::BindServer;
@@ -124,7 +125,7 @@ impl<B: AsRef<[u8]> + 'static> Http<B> {
service: S)
where S: Service<Request = Request, Response = Response<Bd>, Error = ::Error> + 'static,
Bd: Stream<Item=B, Error=::Error> + 'static,
I: Io + 'static,
I: AsyncRead + AsyncWrite + 'static,
{
self.bind_server(handle, io, HttpService {
inner: service,
@@ -165,8 +166,8 @@ pub struct __ProtoBindTransport<T, B> {
}
impl<T, B> ServerProto<T> for Http<B>
where T: Io + 'static,
B: AsRef<[u8]> + 'static,
where T: AsyncRead + AsyncWrite + 'static,
B: AsRef<[u8]> + 'static,
{
type Request = __ProtoRequest;
type RequestBody = http::Chunk;
@@ -189,8 +190,8 @@ where T: Io + 'static,
}
impl<T, B> Sink for __ProtoTransport<T, B>
where T: Io + 'static,
B: AsRef<[u8]>,
where T: AsyncRead + AsyncWrite + 'static,
B: AsRef<[u8]> + 'static,
{
type SinkItem = Frame<__ProtoResponse, B, ::Error>;
type SinkError = io::Error;
@@ -224,9 +225,16 @@ where T: Io + 'static,
fn poll_complete(&mut self) -> Poll<(), io::Error> {
self.0.poll_complete()
}
fn close(&mut self) -> Poll<(), io::Error> {
self.0.close()
}
}
impl<T: Io + 'static, B: AsRef<[u8]>> Stream for __ProtoTransport<T, B> {
impl<T, B> Stream for __ProtoTransport<T, B>
where T: AsyncRead + AsyncWrite + 'static,
B: AsRef<[u8]> + 'static,
{
type Item = Frame<__ProtoRequest, http::Chunk, ::Error>;
type Error = io::Error;
@@ -246,7 +254,10 @@ impl<T: Io + 'static, B: AsRef<[u8]>> Stream for __ProtoTransport<T, B> {
}
}
impl<T: Io + 'static, B: AsRef<[u8]> + 'static> Transport for __ProtoTransport<T, B> {
impl<T, B> Transport for __ProtoTransport<T, B>
where T: AsyncRead + AsyncWrite + 'static,
B: AsRef<[u8]> + 'static,
{
fn tick(&mut self) {
self.0.tick()
}
@@ -256,7 +267,9 @@ impl<T: Io + 'static, B: AsRef<[u8]> + 'static> Transport for __ProtoTransport<T
}
}
impl<T: Io + 'static, B> Future for __ProtoBindTransport<T, B> {
impl<T, B> Future for __ProtoBindTransport<T, B>
where T: AsyncRead + AsyncWrite + 'static,
{
type Item = __ProtoTransport<T, B>;
type Error = io::Error;