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

feat(lib): convert to use tokio 0.1

Browse Source 
BREAKING CHANGE: All uses of `Handle` now need to be new-tokio `Handle`.

Co-authored-by: Sean McArthur <sean@seanmonstar.com>
This commit is contained in:
Sam Reis
2018-03-15 10:46:03 +11:00
committed by Sean McArthur
parent 8c52c2dfd3
commit 27b8db3af8
23 changed files with 680 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
benches/end_to_end.rs
View File

@@ -4,48 +4,47 @@
extern crate futures;
extern crate hyper;
extern crate test;
extern crate tokio_core;
extern crate tokio;
use std::net::SocketAddr;
use futures::{Future, Stream};
use tokio_core::reactor::{Core, Handle};
use tokio_core::net::TcpListener;
use tokio::runtime::Runtime;
use tokio::net::TcpListener;
use hyper::{Body, Method, Request, Response};
use hyper::server::Http;
#[bench]
fn get_one_at_a_time(b: &mut test::Bencher) {
let mut core = Core::new().unwrap();
let handle = core.handle();
let addr = spawn_hello(&handle);
let mut rt = Runtime::new().unwrap();
let addr = spawn_hello(&mut rt);
let client = hyper::Client::new(&handle);
let client = hyper::Client::configure()
.build_with_executor(&rt.handle(), rt.executor());
let url: hyper::Uri = format!("http://{}/get", addr).parse().unwrap();
b.bytes = 160 * 2 + PHRASE.len() as u64;
b.iter(move || {
let work = client.get(url.clone()).and_then(|res| {
res.into_body().into_stream().for_each(|_chunk| {
Ok(())
client.get(url.clone())
.and_then(|res| {
res.into_body().into_stream().for_each(|_chunk| {
Ok(())
})
})
});
core.run(work).unwrap();
.wait().expect("client wait");
});
}
#[bench]
fn post_one_at_a_time(b: &mut test::Bencher) {
extern crate pretty_env_logger;
let _ = pretty_env_logger::try_init();
let mut core = Core::new().unwrap();
let handle = core.handle();
let addr = spawn_hello(&handle);
let mut rt = Runtime::new().unwrap();
let addr = spawn_hello(&mut rt);
let client = hyper::Client::new(&handle);
let client = hyper::Client::configure()
.build_with_executor(&rt.handle(), rt.executor());
let url: hyper::Uri = format!("http://{}/post", addr).parse().unwrap();
@@ -55,26 +54,24 @@ fn post_one_at_a_time(b: &mut test::Bencher) {
let mut req = Request::new(post.into());
*req.method_mut() = Method::POST;
*req.uri_mut() = url.clone();
let work = client.request(req).and_then(|res| {
client.request(req).and_then(|res| {
res.into_body().into_stream().for_each(|_chunk| {
Ok(())
})
});
}).wait().expect("client wait");
core.run(work).unwrap();
});
}
static PHRASE: &'static [u8] = include_bytes!("../CHANGELOG.md"); //b"Hello, World!";
fn spawn_hello(handle: &Handle) -> SocketAddr {
fn spawn_hello(rt: &mut Runtime) -> SocketAddr {
use hyper::server::{const_service, service_fn, NewService};
let addr = "127.0.0.1:0".parse().unwrap();
let listener = TcpListener::bind(&addr, handle).unwrap();
let listener = TcpListener::bind(&addr).unwrap();
let addr = listener.local_addr().unwrap();
let handle2 = handle.clone();
let http = hyper::server::Http::<hyper::Chunk>::new();
let http = Http::<hyper::Chunk>::new();
let service = const_service(service_fn(|req: Request<Body>| {
req.into_body()
@@ -85,16 +82,15 @@ fn spawn_hello(handle: &Handle) -> SocketAddr {
})
}));
let mut conns = 0;
handle.spawn(listener.incoming().for_each(move |(socket, _addr)| {
conns += 1;
assert_eq!(conns, 1, "should only need 1 connection");
handle2.spawn(
http.serve_connection(socket, service.new_service()?)
let srv = listener.incoming()
.into_future()
.map_err(|(e, _inc)| panic!("accept error: {}", e))
.and_then(move |(accepted, _inc)| {
let socket = accepted.expect("accepted socket");
http.serve_connection(socket, service.new_service().expect("new_service"))
.map(|_| ())
.map_err(|_| ())
);
Ok(())
}).then(|_| Ok(())));
});
rt.spawn(srv);
return addr
}

3
benches/server.rs
View File

@@ -5,6 +5,7 @@ extern crate futures;
extern crate hyper;
extern crate pretty_env_logger;
extern crate test;
extern crate tokio;
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
@@ -30,7 +31,7 @@ macro_rules! bench_server {
})).unwrap();
let addr = srv.local_addr().unwrap();
addr_tx.send(addr).unwrap();
srv.run_until(until_rx.map_err(|_| ())).unwrap();
tokio::run(srv.run_until(until_rx.map_err(|_| ())).map_err(|e| panic!("server error: {}", e)));
});
addr_rx.recv().unwrap()