use std::marker::PhantomData; use regex::Regex; use futures::future::{Future, ok, err}; use http::{header, StatusCode, Error as HttpError}; use body::Body; use error::Error; use httprequest::HttpRequest; use httpresponse::HttpResponse; /// Trait defines object that could be registered as route handler #[allow(unused_variables)] pub trait Handler: 'static { /// The type of value that handler will return. type Result: Responder; /// Handle request fn handle(&mut self, req: HttpRequest) -> Self::Result; } /// Trait implemented by types that generate responses for clients. /// /// Types that implement this trait can be used as the return type of a handler. pub trait Responder { /// The associated item which can be returned. type Item: Into; /// The associated error which can be returned. type Error: Into; /// Convert itself to `Reply` or `Error`. fn respond_to(self, req: HttpRequest) -> Result; } #[doc(hidden)] /// Convenience trait that convert `Future` object into `Boxed` future pub trait AsyncResponder: Sized { fn responder(self) -> Box>; } impl AsyncResponder for F where F: Future + 'static, I: Responder + 'static, E: Into + 'static, { fn responder(self) -> Box> { Box::new(self) } } /// Handler for Fn() impl Handler for F where F: Fn(HttpRequest) -> R + 'static, R: Responder + 'static { type Result = R; fn handle(&mut self, req: HttpRequest) -> R { (self)(req) } } /// Represents response process. pub struct Reply(ReplyItem); pub(crate) enum ReplyItem { Message(HttpResponse), Future(Box>), } impl Reply { /// Create async response #[inline] pub fn async(fut: F) -> Reply where F: Future + 'static { Reply(ReplyItem::Future(Box::new(fut))) } /// Send response #[inline] pub fn response>(response: R) -> Reply { Reply(ReplyItem::Message(response.into())) } #[inline] pub(crate) fn into(self) -> ReplyItem { self.0 } #[cfg(test)] pub(crate) fn as_response(&self) -> Option<&HttpResponse> { match self.0 { ReplyItem::Message(ref resp) => Some(resp), _ => None, } } } impl Responder for Reply { type Item = Reply; type Error = Error; fn respond_to(self, _: HttpRequest) -> Result { Ok(self) } } impl Responder for HttpResponse { type Item = Reply; type Error = Error; #[inline] fn respond_to(self, _: HttpRequest) -> Result { Ok(Reply(ReplyItem::Message(self))) } } impl From for Reply { #[inline] fn from(resp: HttpResponse) -> Reply { Reply(ReplyItem::Message(resp)) } } impl> Responder for Result { type Item = ::Item; type Error = Error; fn respond_to(self, req: HttpRequest) -> Result { match self { Ok(val) => match val.respond_to(req) { Ok(val) => Ok(val), Err(err) => Err(err.into()), }, Err(err) => Err(err.into()), } } } impl> From> for Reply { #[inline] fn from(res: Result) -> Self { match res { Ok(val) => val, Err(err) => Reply(ReplyItem::Message(err.into().into())), } } } impl> From> for Reply { #[inline] fn from(res: Result) -> Self { match res { Ok(val) => Reply(ReplyItem::Message(val)), Err(err) => Reply(ReplyItem::Message(err.into().into())), } } } impl From>> for Reply { #[inline] fn from(fut: Box>) -> Reply { Reply(ReplyItem::Future(fut)) } } impl Responder for Box> where I: Responder + 'static, E: Into + 'static { type Item = Reply; type Error = Error; #[inline] fn respond_to(self, req: HttpRequest) -> Result { let fut = self.map_err(|e| e.into()) .then(move |r| { match r.respond_to(req) { Ok(reply) => match reply.into().0 { ReplyItem::Message(resp) => ok(resp), _ => panic!("Nested async replies are not supported"), }, Err(e) => err(e), } }); Ok(Reply::async(fut)) } } /// Trait defines object that could be registered as resource route pub(crate) trait RouteHandler: 'static { fn handle(&mut self, req: HttpRequest) -> Reply; } /// Route handler wrapper for Handler pub(crate) struct WrapHandler where H: Handler, R: Responder, S: 'static, { h: H, s: PhantomData, } impl WrapHandler where H: Handler, R: Responder, S: 'static, { pub fn new(h: H) -> Self { WrapHandler{h: h, s: PhantomData} } } impl RouteHandler for WrapHandler where H: Handler, R: Responder + 'static, S: 'static, { fn handle(&mut self, req: HttpRequest) -> Reply { let req2 = req.clone_without_state(); match self.h.handle(req).respond_to(req2) { Ok(reply) => reply.into(), Err(err) => Reply::response(err.into()), } } } /// Async route handler pub(crate) struct AsyncHandler where H: Fn(HttpRequest) -> F + 'static, F: Future + 'static, R: Responder + 'static, E: Into + 'static, S: 'static, { h: Box, s: PhantomData, } impl AsyncHandler where H: Fn(HttpRequest) -> F + 'static, F: Future + 'static, R: Responder + 'static, E: Into + 'static, S: 'static, { pub fn new(h: H) -> Self { AsyncHandler{h: Box::new(h), s: PhantomData} } } impl RouteHandler for AsyncHandler where H: Fn(HttpRequest) -> F + 'static, F: Future + 'static, R: Responder + 'static, E: Into + 'static, S: 'static, { fn handle(&mut self, req: HttpRequest) -> Reply { let req2 = req.clone_without_state(); let fut = (self.h)(req) .map_err(|e| e.into()) .then(move |r| { match r.respond_to(req2) { Ok(reply) => match reply.into().0 { ReplyItem::Message(resp) => ok(resp), _ => panic!("Nested async replies are not supported"), }, Err(e) => err(e), } }); Reply::async(fut) } } /// Path normalization helper /// /// By normalizing it means: /// /// - Add a trailing slash to the path. /// - Double slashes are replaced by one. /// /// The handler returns as soon as it finds a path that resolves /// correctly. The order if all enable is 1) merge, 3) both merge and append /// and 3) append. If the path resolves with /// at least one of those conditions, it will redirect to the new path. /// /// If *append* is *true* append slash when needed. If a resource is /// defined with trailing slash and the request comes without it, it will /// append it automatically. /// /// If *merge* is *true*, merge multiple consecutive slashes in the path into one. /// /// This handler designed to be use as a handler for application's *default resource*. /// /// ```rust /// # extern crate actix_web; /// # #[macro_use] extern crate serde_derive; /// # use actix_web::*; /// # /// # fn index(req: HttpRequest) -> httpcodes::StaticResponse { /// # httpcodes::HTTPOk /// # } /// fn main() { /// let app = Application::new() /// .resource("/test/", |r| r.f(index)) /// .default_resource(|r| r.h(NormalizePath::default())) /// .finish(); /// } /// ``` /// In this example `/test`, `/test///` will be redirected to `/test/` url. pub struct NormalizePath { append: bool, merge: bool, re_merge: Regex, redirect: StatusCode, not_found: StatusCode, } impl Default for NormalizePath { /// Create default `NormalizePath` instance, *append* is set to *true*, /// *merge* is set to *true* and *redirect* is set to `StatusCode::MOVED_PERMANENTLY` fn default() -> NormalizePath { NormalizePath { append: true, merge: true, re_merge: Regex::new("//+").unwrap(), redirect: StatusCode::MOVED_PERMANENTLY, not_found: StatusCode::NOT_FOUND, } } } impl NormalizePath { /// Create new `NormalizePath` instance pub fn new(append: bool, merge: bool, redirect: StatusCode) -> NormalizePath { NormalizePath { append: append, merge: merge, re_merge: Regex::new("//+").unwrap(), redirect: redirect, not_found: StatusCode::NOT_FOUND, } } } impl Handler for NormalizePath { type Result = Result; fn handle(&mut self, req: HttpRequest) -> Self::Result { if let Some(router) = req.router() { let query = req.query_string(); if self.merge { // merge slashes let p = self.re_merge.replace_all(req.path(), "/"); if p.len() != req.path().len() { if router.has_route(p.as_ref()) { let p = if !query.is_empty() { p + "?" + query } else { p }; return HttpResponse::build(self.redirect) .header(header::LOCATION, p.as_ref()) .body(Body::Empty); } // merge slashes and append trailing slash if self.append && !p.ends_with('/') { let p = p.as_ref().to_owned() + "/"; if router.has_route(&p) { let p = if !query.is_empty() { p + "?" + query } else { p }; return HttpResponse::build(self.redirect) .header(header::LOCATION, p.as_str()) .body(Body::Empty); } } // try to remove trailing slash if p.ends_with('/') { let p = p.as_ref().trim_right_matches('/'); if router.has_route(&p) { let p = p.to_owned(); let p = if !query.is_empty() { p + "?" + query } else { p }; return HttpResponse::build(self.redirect) .header(header::LOCATION, p.as_str()) .body(Body::Empty); } } } } // append trailing slash if self.append && !req.path().ends_with('/') { let p = req.path().to_owned() + "/"; if router.has_route(&p) { let p = if !query.is_empty() { p + "?" + query } else { p }; return HttpResponse::build(self.redirect) .header(header::LOCATION, p.as_str()) .body(Body::Empty); } } } Ok(HttpResponse::new(self.not_found, Body::Empty)) } } #[cfg(test)] mod tests { use super::*; use http::{header, Method}; use test::TestRequest; use application::Application; fn index(_req: HttpRequest) -> HttpResponse { HttpResponse::new(StatusCode::OK, Body::Empty) } #[test] fn test_normalize_path_trailing_slashes() { let mut app = Application::new() .resource("/resource1", |r| r.method(Method::GET).f(index)) .resource("/resource2/", |r| r.method(Method::GET).f(index)) .default_resource(|r| r.h(NormalizePath::default())) .finish(); // trailing slashes let params = vec![("/resource1", "", StatusCode::OK), ("/resource1/", "", StatusCode::NOT_FOUND), ("/resource2", "/resource2/", StatusCode::MOVED_PERMANENTLY), ("/resource2/", "", StatusCode::OK), ("/resource1?p1=1&p2=2", "", StatusCode::OK), ("/resource1/?p1=1&p2=2", "", StatusCode::NOT_FOUND), ("/resource2?p1=1&p2=2", "/resource2/?p1=1&p2=2", StatusCode::MOVED_PERMANENTLY), ("/resource2/?p1=1&p2=2", "", StatusCode::OK) ]; for (path, target, code) in params { let req = app.prepare_request(TestRequest::with_uri(path).finish()); let resp = app.run(req); let r = resp.as_response().unwrap(); assert_eq!(r.status(), code); if !target.is_empty() { assert_eq!( target, r.headers().get(header::LOCATION).unwrap().to_str().unwrap()); } } } #[test] fn test_normalize_path_trailing_slashes_disabled() { let mut app = Application::new() .resource("/resource1", |r| r.method(Method::GET).f(index)) .resource("/resource2/", |r| r.method(Method::GET).f(index)) .default_resource(|r| r.h( NormalizePath::new(false, true, StatusCode::MOVED_PERMANENTLY))) .finish(); // trailing slashes let params = vec![("/resource1", StatusCode::OK), ("/resource1/", StatusCode::NOT_FOUND), ("/resource2", StatusCode::NOT_FOUND), ("/resource2/", StatusCode::OK), ("/resource1?p1=1&p2=2", StatusCode::OK), ("/resource1/?p1=1&p2=2", StatusCode::NOT_FOUND), ("/resource2?p1=1&p2=2", StatusCode::NOT_FOUND), ("/resource2/?p1=1&p2=2", StatusCode::OK) ]; for (path, code) in params { let req = app.prepare_request(TestRequest::with_uri(path).finish()); let resp = app.run(req); let r = resp.as_response().unwrap(); assert_eq!(r.status(), code); } } #[test] fn test_normalize_path_merge_slashes() { let mut app = Application::new() .resource("/resource1", |r| r.method(Method::GET).f(index)) .resource("/resource1/a/b", |r| r.method(Method::GET).f(index)) .default_resource(|r| r.h(NormalizePath::default())) .finish(); // trailing slashes let params = vec![ ("/resource1/a/b", "", StatusCode::OK), ("//resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("//resource1//a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("///resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("/////resource1/a///b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("/////resource1/a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("/resource1/a/b?p=1", "", StatusCode::OK), ("//resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ("//resource1//a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ("///resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ("/////resource1/a///b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ("/////resource1/a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ]; for (path, target, code) in params { let req = app.prepare_request(TestRequest::with_uri(path).finish()); let resp = app.run(req); let r = resp.as_response().unwrap(); assert_eq!(r.status(), code); if !target.is_empty() { assert_eq!( target, r.headers().get(header::LOCATION).unwrap().to_str().unwrap()); } } } #[test] fn test_normalize_path_merge_and_append_slashes() { let mut app = Application::new() .resource("/resource1", |r| r.method(Method::GET).f(index)) .resource("/resource2/", |r| r.method(Method::GET).f(index)) .resource("/resource1/a/b", |r| r.method(Method::GET).f(index)) .resource("/resource2/a/b/", |r| r.method(Method::GET).f(index)) .default_resource(|r| r.h(NormalizePath::default())) .finish(); // trailing slashes let params = vec![ ("/resource1/a/b", "", StatusCode::OK), ("/resource1/a/b/", "", StatusCode::NOT_FOUND), ("//resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("//resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("///resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("///resource1//a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("/////resource1/a///b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("/////resource1/a///b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY), ("/resource2/a/b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("/resource2/a/b/", "", StatusCode::OK), ("//resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("//resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("///resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("///resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("/////resource2/a///b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("/////resource2/a///b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY), ("/resource1/a/b?p=1", "", StatusCode::OK), ("/resource1/a/b/?p=1", "", StatusCode::NOT_FOUND), ("//resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ("//resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ("///resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ("///resource1//a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ("/////resource1/a///b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ("/////resource1/a///b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY), ("/resource2/a/b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ("//resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ("//resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ("///resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ("///resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ("/////resource2/a///b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ("/////resource2/a///b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY), ]; for (path, target, code) in params { let req = app.prepare_request(TestRequest::with_uri(path).finish()); let resp = app.run(req); let r = resp.as_response().unwrap(); assert_eq!(r.status(), code); if !target.is_empty() { assert_eq!( target, r.headers().get(header::LOCATION).unwrap().to_str().unwrap()); } } } }