Change the Handler trait to receive an Iterator of (Request, Response) pairs.

This allows downstream users to have total control of their concurrency
strategy, while also exposing a very nice, streaming interface for frameworks
to build on.

This also resolves issues surrounding the use of IoResult as the return type
of Handler::handle, because handlers now have complete control over how to
handle internal failure.

Fixes #3
Fixes #4

src/server/mod.rs

@@ -1,6 +1,6 @@
 //! HTTP Server
 use std::io::net::tcp::{TcpListener, TcpAcceptor};
-use std::io::{Acceptor, Listener, IoResult, EndOfFile};
+use std::io::{Acceptor, Listener, IoResult, EndOfFile, IncomingConnections};
 use std::io::net::ip::{IpAddr, Port, SocketAddr};
 
 pub use self::request::Request;
@@ -30,7 +30,7 @@ impl Server {
     }
 
     /// Binds to a socket, and starts handling connections.
-    pub fn listen<H: Handler + 'static>(self, mut handler: H) -> IoResult<Listening> {
+    pub fn listen<H: Handler + 'static>(self, handler: H) -> IoResult<Listening> {
         let mut listener = try!(TcpListener::bind(self.ip.to_string().as_slice(), self.port));
         let socket = try!(listener.socket_name());
         let acceptor = try!(listener.listen());
@@ -38,7 +38,26 @@ impl Server {
 
         spawn(proc() {
             let mut acceptor = worker;
-            for conn in acceptor.incoming() {
+            handler.handle(Incoming { from: acceptor.incoming() });
+        });
+
+        Ok(Listening {
+            acceptor: acceptor,
+            socket_addr: socket,
+        })
+    }
+
+}
+
+/// An iterator over incoming connections, represented as pairs of
+/// hyper Requests and Responses.
+pub struct Incoming<'a> {
+    from: IncomingConnections<'a, TcpAcceptor>
+}
+
+impl<'a> Iterator<(Request, Response)> for Incoming<'a> {
+    fn next(&mut self) -> Option<(Request, Response)> {
+        for conn in self.from {
             match conn {
                 Ok(stream) => {
                     debug!("Incoming stream");
@@ -52,28 +71,17 @@ impl Server {
                     };
                     let mut res = Response::new(clone);
                     res.version = req.version;
-                        match handler.handle(req, res) {
+                    return Some((req, res))
-                            Ok(..) => debug!("Stream handled"),
-                            Err(e) => {
-                                error!("Error from handler: {}", e)
-                                //TODO try to send a status code
-                            }
-                        }
                 },
-                    Err(ref e) if e.kind == EndOfFile => break, // server closed
+                Err(ref e) if e.kind == EndOfFile => return None, // server closed
                 Err(e) => {
                     error!("Connection failed: {}", e);
+                    continue;
                 }
             }
         }
-        });
+        None
-
-        Ok(Listening {
-            acceptor: acceptor,
-            socket_addr: socket,
-        })
     }
-
 }
 
 /// A listening server, which can later be closed.
@@ -96,11 +104,12 @@ pub trait Handler: Send {
     /// Receives a `Request`/`Response` pair, and should perform some action on them.
     ///
     /// This could reading from the request, and writing to the response.
-    fn handle(&mut self, req: Request, res: Response) -> IoResult<()>;
+    fn handle(self, Incoming);
 }
 
-impl Handler for fn(Request, Response) -> IoResult<()> {
+impl Handler for fn(Incoming) {
-    fn handle(&mut self, req: Request, res: Response) -> IoResult<()> {
+    fn handle(self, incoming: Incoming) {
-        (*self)(req, res)
+        (self)(incoming)
     }
 }
+