feat(lib): switch to non-blocking (asynchronous) IO

BREAKING CHANGE: This breaks a lot of the Client and Server APIs.
  Check the documentation for how Handlers can be used for asynchronous
  events.

src/server/message.rs

@@ -0,0 +1,58 @@
+use std::marker::PhantomData;
+
+
+use http::{self, Next};
+use net::Transport;
+
+use super::{Handler, request, response};
+
+/// A MessageHandler for a Server.
+///
+/// This should be really thin glue between http::MessageHandler and
+/// server::Handler, but largely just providing the proper types one
+/// would expect in a Server Handler.
+pub struct Message<H: Handler<T>, T: Transport> {
+    handler: H,
+    _marker: PhantomData<T>
+}
+
+impl<H: Handler<T>, T: Transport> Message<H, T> {
+    pub fn new(handler: H) -> Message<H, T> {
+        Message {
+            handler: handler,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<H: Handler<T>, T: Transport> http::MessageHandler<T> for Message<H, T> {
+    type Message = http::ServerMessage;
+
+    fn on_incoming(&mut self, head: http::RequestHead) -> Next {
+        trace!("on_incoming {:?}", head);
+        let req = request::new(head);
+        self.handler.on_request(req)
+    }
+
+    fn on_decode(&mut self, transport: &mut http::Decoder<T>) -> Next {
+        self.handler.on_request_readable(transport)
+    }
+
+    fn on_outgoing(&mut self, head: &mut http::MessageHead<::status::StatusCode>) -> Next {
+        let mut res = response::new(head);
+        self.handler.on_response(&mut res)
+    }
+
+    fn on_encode(&mut self, transport: &mut http::Encoder<T>) -> Next {
+        self.handler.on_response_writable(transport)
+    }
+
+    fn on_error(&mut self, error: ::Error) -> Next {
+        self.handler.on_error(error)
+    }
+
+    fn on_remove(self, transport: T) {
+        self.handler.on_remove(transport);
+    }
+}
+