feat(server): add Transport to on_request

Author: seanmonstar

examples/hello.rs

@@ -14,7 +14,7 @@ static PHRASE: &'static [u8] = b"Hello World!";
 struct Hello;
 
 impl Handler<HttpStream> for Hello {
-    fn on_request(&mut self, _: Request) -> Next {
+    fn on_request(&mut self, _: Request<HttpStream>) -> Next {
         Next::write()
     }
     fn on_request_readable(&mut self, _: &mut Decoder<HttpStream>) -> Next {

examples/server.rs

@@ -46,7 +46,7 @@ impl Echo {
 }
 
 impl Handler<HttpStream> for Echo {
-    fn on_request(&mut self, req: Request) -> Next {
+    fn on_request(&mut self, req: Request<HttpStream>) -> Next {
         match *req.uri() {
             RequestUri::AbsolutePath(ref path) => match (req.method(), &path[..]) {
                 (&Get, "/") | (&Get, "/echo") => {

examples/sync.rs

@@ -310,7 +310,7 @@ impl<H: Handler<T>, T: Transport> http::MessageHandler<T> for Message<H, T> {
         self.handler.on_request_writable(transport)
     }
 
-    fn on_incoming(&mut self, head: http::ResponseHead) -> Next {
+    fn on_incoming(&mut self, head: http::ResponseHead, _: &T) -> Next {
         trace!("on_incoming {:?}", head);
         let resp = response::new(head);
         self.handler.on_response(resp)

src/client/mod.rs

@@ -164,7 +164,7 @@ impl<K: Key, T: Transport, H: MessageHandler<T>> ConnInner<K, T, H> {
                         trace!("decoder = {:?}", decoder);
                         let keep_alive = self.keep_alive_enabled && head.should_keep_alive();
                         let mut handler = scope.create(Seed(&self.key, &self.ctrl.0));
-                        let next = handler.on_incoming(head);
+                        let next = handler.on_incoming(head, &self.transport);
                         trace!("handler.on_incoming() -> {:?}", next);
 
                         match next.interest {
@@ -231,7 +231,7 @@ impl<K: Key, T: Transport, H: MessageHandler<T>> ConnInner<K, T, H> {
                                 if http1.keep_alive {
                                     http1.keep_alive = head.should_keep_alive();
                                 }
-                                let next = http1.handler.on_incoming(head);
+                                let next = http1.handler.on_incoming(head, &self.transport);
                                 http1.reading = Reading::Wait(decoder);
                                 trace!("handler.on_incoming() -> {:?}", next);
                                 Some(next)
@@ -874,7 +874,7 @@ impl Chunk {
 
 pub trait MessageHandler<T: Transport> {
     type Message: Http1Message;
-    fn on_incoming(&mut self, head: http::MessageHead<<Self::Message as Http1Message>::Incoming>) -> Next;
+    fn on_incoming(&mut self, head: http::MessageHead<<Self::Message as Http1Message>::Incoming>, transport: &T) -> Next;
     fn on_outgoing(&mut self, head: &mut http::MessageHead<<Self::Message as Http1Message>::Outgoing>) -> Next;
     fn on_decode(&mut self, &mut http::Decoder<T>) -> Next;
     fn on_encode(&mut self, &mut http::Encoder<T>) -> Next;

src/http/conn.rs

@@ -28,9 +28,9 @@ impl<H: Handler<T>, T: Transport> Message<H, T> {
 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 {
+    fn on_incoming(&mut self, head: http::RequestHead, transport: &T) -> Next {
         trace!("on_incoming {:?}", head);
-        let req = request::new(head);
+        let req = request::new(head, transport);
         self.handler.on_request(req)
     }
 

src/server/message.rs

@@ -324,7 +324,7 @@ impl Listening {
 /// Each event handler returns it's desired `Next` action.
 pub trait Handler<T: Transport> {
     /// This event occurs first, triggering when a `Request` has been parsed.
-    fn on_request(&mut self, request: Request) -> Next;
+    fn on_request(&mut self, request: Request<T>) -> Next;
     /// This event occurs each time the `Request` is ready to be read from.
     fn on_request_readable(&mut self, request: &mut http::Decoder<T>) -> Next;
     /// This event occurs after the first time this handled signals `Next::write()`.