feat(lib): redesign API to use Futures and Tokio

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.

examples/client.rs

@@ -1,68 +1,20 @@
 #![deny(warnings)]
+extern crate futures;
 extern crate hyper;
+extern crate tokio_core;
 
-extern crate env_logger;
+extern crate pretty_env_logger;
 
 use std::env;
-use std::io;
-use std::sync::mpsc;
-use std::time::Duration;
+use std::io::{self, Write};
 
-use hyper::client::{Client, Request, Response, DefaultTransport as HttpStream};
-use hyper::header::Connection;
-use hyper::{Decoder, Encoder, Next};
+use futures::Future;
+use futures::stream::Stream;
 
-#[derive(Debug)]
-struct Dump(mpsc::Sender<()>);
-
-impl Drop for Dump {
-    fn drop(&mut self) {
-        let _ = self.0.send(());
-    }
-}
-
-fn read() -> Next {
-    Next::read().timeout(Duration::from_secs(10))
-}
-
-impl hyper::client::Handler<HttpStream> for Dump {
-    fn on_request(&mut self, req: &mut Request) -> Next {
-        req.headers_mut().set(Connection::close());
-        read()
-    }
-
-    fn on_request_writable(&mut self, _encoder: &mut Encoder<HttpStream>) -> Next {
-        read()
-    }
-
-    fn on_response(&mut self, res: Response) -> Next {
-        println!("Response: {}", res.status());
-        println!("Headers:\n{}", res.headers());
-        read()
-    }
-
-    fn on_response_readable(&mut self, decoder: &mut Decoder<HttpStream>) -> Next {
-        match io::copy(decoder, &mut io::stdout()) {
-            Ok(0) => Next::end(),
-            Ok(_) => read(),
-            Err(e) => match e.kind() {
-                io::ErrorKind::WouldBlock => Next::read(),
-                _ => {
-                    println!("ERROR:example: {}", e);
-                    Next::end()
-                }
-            }
-        }
-    }
-
-    fn on_error(&mut self, err: hyper::Error) -> Next {
-        println!("ERROR:example: {}", err);
-        Next::remove()
-    }
-}
+use hyper::Client;
 
 fn main() {
-    env_logger::init().unwrap();
+    pretty_env_logger::init().unwrap();
 
     let url = match env::args().nth(1) {
         Some(url) => url,
@@ -72,11 +24,26 @@ fn main() {
         }
     };
 
-    let (tx, rx) = mpsc::channel();
-    let client = Client::new().expect("Failed to create a Client");
-    client.request(url.parse().unwrap(), Dump(tx)).unwrap();
+    let url = hyper::Url::parse(&url).unwrap();
+    if url.scheme() != "http" {
+        println!("This example only works with 'http' URLs.");
+        return;
+    }
 
-    // wait till done
-    let _  = rx.recv();
-    client.close();
+    let mut core = tokio_core::reactor::Core::new().unwrap();
+    let handle = core.handle();
+    let client = Client::new(&handle);
+
+    let work = client.get(url).and_then(|res| {
+        println!("Response: {}", res.status());
+        println!("Headers: \n{}", res.headers());
+
+        res.body().for_each(|chunk| {
+            io::stdout().write_all(&chunk).map_err(From::from)
+        })
+    }).map(|_| {
+        println!("\n\nDone.");
+    });
+
+    core.run(work).unwrap();
 }

examples/hello.rs

@@ -1,50 +1,39 @@
 #![deny(warnings)]
 extern crate hyper;
-extern crate env_logger;
-extern crate num_cpus;
+extern crate futures;
+extern crate pretty_env_logger;
+//extern crate num_cpus;
 
-use hyper::{Decoder, Encoder, Next, HttpStream};
-use hyper::server::{Server, Handler, Request, Response, HttpListener};
+use hyper::header::{ContentLength, ContentType};
+use hyper::server::{Server, Service, Request, Response};
 
 static PHRASE: &'static [u8] = b"Hello World!";
 
+#[derive(Clone, Copy)]
 struct Hello;
 
-impl Handler<HttpStream> for Hello {
-    fn on_request(&mut self, _: Request<HttpStream>) -> Next {
-        Next::write()
-    }
-    fn on_request_readable(&mut self, _: &mut Decoder<HttpStream>) -> Next {
-        Next::write()
-    }
-    fn on_response(&mut self, response: &mut Response) -> Next {
-        use hyper::header::ContentLength;
-        response.headers_mut().set(ContentLength(PHRASE.len() as u64));
-        Next::write()
-    }
-    fn on_response_writable(&mut self, encoder: &mut Encoder<HttpStream>) -> Next {
-        let n = encoder.write(PHRASE).unwrap();
-        debug_assert_eq!(n, PHRASE.len());
-        Next::end()
+impl Service for Hello {
+    type Request = Request;
+    type Response = Response;
+    type Error = hyper::Error;
+    type Future = ::futures::Finished<Response, hyper::Error>;
+    fn call(&self, _req: Request) -> Self::Future {
+        ::futures::finished(
+            Response::new()
+                .with_header(ContentLength(PHRASE.len() as u64))
+                .with_header(ContentType::plaintext())
+                .with_body(PHRASE)
+        )
     }
+
 }
 
 fn main() {
-    env_logger::init().unwrap();
- 
-    let listener = HttpListener::bind(&"127.0.0.1:3000".parse().unwrap()).unwrap();
-    let mut handles = Vec::new();
-
-    for _ in 0..num_cpus::get() {
-        let listener = listener.try_clone().unwrap();
-        handles.push(::std::thread::spawn(move || {
-            Server::new(listener)
-                .handle(|_| Hello).unwrap();
-        }));
-    }
-    println!("Listening on http://127.0.0.1:3000");
-
-    for handle in handles {
-        handle.join().unwrap();
-    }
+    pretty_env_logger::init().unwrap();
+    let addr = "127.0.0.1:3000".parse().unwrap();
+    let _server = Server::standalone(|tokio| {
+        Server::http(&addr, tokio)?
+            .handle(|| Ok(Hello), tokio)
+    }).unwrap();
+    println!("Listening on http://{}", addr);
 }

examples/server.rs

@@ -1,164 +1,57 @@
-#![deny(warnings)]
+//#![deny(warnings)]
+extern crate futures;
 extern crate hyper;
-extern crate env_logger;
+extern crate pretty_env_logger;
 #[macro_use]
 extern crate log;
 
-use hyper::{Get, Post, StatusCode, RequestUri, Decoder, Encoder, HttpStream, Next};
+use hyper::{Get, Post, StatusCode};
 use hyper::header::ContentLength;
-use hyper::server::{Server, Handler, Request, Response};
+use hyper::server::{Server, Service, Request, Response};
 
-struct Echo {
-    buf: Vec<u8>,
-    read_pos: usize,
-    write_pos: usize,
-    eof: bool,
-    route: Route,
-}
-
-enum Route {
-    NotFound,
-    Index,
-    Echo(Body),
-}
-
-#[derive(Clone, Copy)]
-enum Body {
-    Len(u64),
-    Chunked
-}
 
 static INDEX: &'static [u8] = b"Try POST /echo";
 
-impl Echo {
-    fn new() -> Echo {
-        Echo {
-            buf: vec![0; 4096],
-            read_pos: 0,
-            write_pos: 0,
-            eof: false,
-            route: Route::NotFound,
-        }
-    }
-}
+#[derive(Clone, Copy)]
+struct Echo;
 
-impl Handler<HttpStream> for Echo {
-    fn on_request(&mut self, req: Request<HttpStream>) -> Next {
-        match *req.uri() {
-            RequestUri::AbsolutePath { ref path, .. } => match (req.method(), &path[..]) {
-                (&Get, "/") | (&Get, "/echo") => {
-                    info!("GET Index");
-                    self.route = Route::Index;
-                    Next::write()
-                }
-                (&Post, "/echo") => {
-                    info!("POST Echo");
-                    let mut is_more = true;
-                    self.route = if let Some(len) = req.headers().get::<ContentLength>() {
-                        is_more = **len > 0;
-                        Route::Echo(Body::Len(**len))
-                    } else {
-                        Route::Echo(Body::Chunked)
-                    };
-                    if is_more {
-                        Next::read_and_write()
-                    } else {
-                        Next::write()
-                    }
-                }
-                _ => Next::write(),
+impl Service for Echo {
+    type Request = Request;
+    type Response = Response;
+    type Error = hyper::Error;
+    type Future = ::futures::Finished<Response, hyper::Error>;
+
+    fn call(&self, req: Request) -> Self::Future {
+        ::futures::finished(match (req.method(), req.path()) {
+            (&Get, Some("/")) | (&Get, Some("/echo")) => {
+                Response::new()
+                    .with_header(ContentLength(INDEX.len() as u64))
+                    .with_body(INDEX)
             },
-            _ => Next::write()
-        }
-    }
-    fn on_request_readable(&mut self, transport: &mut Decoder<HttpStream>) -> Next {
-        match self.route {
-            Route::Echo(ref body) => {
-                if self.read_pos < self.buf.len() {
-                    match transport.try_read(&mut self.buf[self.read_pos..]) {
-                        Ok(Some(0)) => {
-                            debug!("Read 0, eof");
-                            self.eof = true;
-                            Next::write()
-                        },
-                        Ok(Some(n)) => {
-                            self.read_pos += n;
-                            match *body {
-                                Body::Len(max) if max <= self.read_pos as u64 => {
-                                    self.eof = true;
-                                    Next::write()
-                                },
-                                _ => Next::read_and_write()
-                            }
-                        }
-                        Ok(None) => Next::read_and_write(),
-                        Err(e) => {
-                            println!("read error {:?}", e);
-                            Next::end()
-                        }
-                    }
-                } else {
-                    Next::write()
+            (&Post, Some("/echo")) => {
+                let mut res = Response::new();
+                if let Some(len) = req.headers().get::<ContentLength>() {
+                    res.headers_mut().set(len.clone());
                 }
+                res.with_body(req.body())
+            },
+            _ => {
+                Response::new()
+                    .with_status(StatusCode::NotFound)
             }
-            _ => unreachable!()
-        }
+        })
     }
 
-    fn on_response(&mut self, res: &mut Response) -> Next {
-        match self.route {
-            Route::NotFound => {
-                res.set_status(StatusCode::NotFound);
-                Next::end()
-            }
-            Route::Index => {
-                res.headers_mut().set(ContentLength(INDEX.len() as u64));
-                Next::write()
-            }
-            Route::Echo(body) => {
-                if let Body::Len(len) = body {
-                    res.headers_mut().set(ContentLength(len));
-                }
-                Next::read_and_write()
-            }
-        }
-    }
-
-    fn on_response_writable(&mut self, transport: &mut Encoder<HttpStream>) -> Next {
-        match self.route {
-            Route::Index => {
-                transport.write(INDEX).unwrap();
-                Next::end()
-            }
-            Route::Echo(..) => {
-                if self.write_pos < self.read_pos {
-                    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()
-                        }
-                        Ok(None) => Next::write(),
-                        Err(e) => {
-                            println!("write error {:?}", e);
-                            Next::end()
-                        }
-                    }
-                } else if !self.eof {
-                    Next::read()
-                } else {
-                    Next::end()
-                }
-            }
-            _ => unreachable!()
-        }
-    }
 }
 
+
 fn main() {
-    env_logger::init().unwrap();
-    let server = Server::http(&"127.0.0.1:1337".parse().unwrap()).unwrap();
-    let (listening, server) = server.handle(|_| Echo::new()).unwrap();
+    pretty_env_logger::init().unwrap();
+    let addr = "127.0.0.1:1337".parse().unwrap();
+    let (listening, server) = Server::standalone(|tokio| {
+        Server::http(&addr, tokio)?
+            .handle(|| Ok(Echo), tokio)
+    }).unwrap();
     println!("Listening on http://{}", listening);
     server.run();
 }