2d2d5574a6
There are many changes involved with this, but let's just talk about
user-facing changes.
- Creating a `Client` and `Server` now needs a Tokio `Core` event loop
to attach to.
- `Request` and `Response` both no longer implement the
`std::io::{Read,Write}` traits, but instead represent their bodies as a
`futures::Stream` of items, where each item is a `Chunk`.
- The `Client.request` method now takes a `Request`, instead of being
used as a builder, and returns a `Future` that resolves to `Response`.
- The `Handler` trait for servers is no more, and instead the Tokio
`Service` trait is used. This allows interoperability with generic
middleware.
BREAKING CHANGE: A big sweeping set of breaking changes.
62 lines
1.5 KiB
Rust
62 lines
1.5 KiB
Rust
#![feature(test)]
|
|
|
|
extern crate futures;
|
|
extern crate hyper;
|
|
extern crate tokio_core;
|
|
|
|
extern crate test;
|
|
|
|
use futures::{Future, Stream};
|
|
use tokio_core::reactor::Core;
|
|
|
|
use hyper::header::{ContentLength, ContentType};
|
|
use hyper::server::{Service, Request, Response};
|
|
|
|
|
|
#[bench]
|
|
fn one_request_at_a_time(b: &mut test::Bencher) {
|
|
extern crate pretty_env_logger;
|
|
let _ = pretty_env_logger::init();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
|
|
let addr = hyper::Server::http(&"127.0.0.1:0".parse().unwrap(), &handle).unwrap()
|
|
.handle(|| Ok(Hello), &handle).unwrap();
|
|
|
|
let mut client = hyper::Client::new(&handle);
|
|
|
|
let url: hyper::Url = format!("http://{}/get", addr).parse().unwrap();
|
|
|
|
b.bytes = 160;
|
|
b.iter(move || {
|
|
let work = client.get(url.clone()).and_then(|res| {
|
|
res.body().for_each(|_chunk| {
|
|
Ok(())
|
|
})
|
|
});
|
|
|
|
core.run(work).unwrap();
|
|
});
|
|
}
|
|
|
|
static PHRASE: &'static [u8] = b"Hello, World!";
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct Hello;
|
|
|
|
impl Service for Hello {
|
|
type Request = Request;
|
|
type Response = Response;
|
|
type Error = hyper::Error;
|
|
type Future = ::futures::Finished<Response, hyper::Error>;
|
|
fn call(&mut self, _req: Request) -> Self::Future {
|
|
::futures::finished(
|
|
Response::new()
|
|
.with_header(ContentLength(PHRASE.len() as u64))
|
|
.with_header(ContentType::plaintext())
|
|
.with_body(PHRASE)
|
|
)
|
|
}
|
|
|
|
}
|