use std::mem; use std::rc::Rc; use std::cell::RefCell; use std::collections::HashMap; use handler::Reply; use router::{Router, Pattern}; use resource::Resource; use headers::ContentEncoding; use handler::{Handler, RouteHandler, WrapHandler}; use httprequest::HttpRequest; use pipeline::{Pipeline, PipelineHandler}; use middleware::Middleware; use server::{HttpHandler, IntoHttpHandler, HttpHandlerTask, ServerSettings}; /// Application pub struct HttpApplication { state: Rc, prefix: String, router: Router, inner: Rc>>, middlewares: Rc>>>, } pub(crate) struct Inner { prefix: usize, default: Resource, encoding: ContentEncoding, router: Router, resources: Vec>, handlers: Vec<(String, Box>)>, } impl PipelineHandler for Inner { fn encoding(&self) -> ContentEncoding { self.encoding } fn handle(&mut self, mut req: HttpRequest) -> Reply { if let Some(idx) = self.router.recognize(&mut req) { self.resources[idx].handle(req.clone(), Some(&mut self.default)) } else { for &mut (ref prefix, ref mut handler) in &mut self.handlers { let m = { let path = &req.path()[self.prefix..]; path.starts_with(prefix) && (path.len() == prefix.len() || path.split_at(prefix.len()).1.starts_with('/')) }; if m { let path: &'static str = unsafe { mem::transmute(&req.path()[self.prefix+prefix.len()..]) }; if path.is_empty() { req.match_info_mut().add("tail", ""); } else { req.match_info_mut().add("tail", path.split_at(1).1); } return handler.handle(req) } } self.default.handle(req, None) } } } #[cfg(test)] impl HttpApplication { #[cfg(test)] pub(crate) fn run(&mut self, req: HttpRequest) -> Reply { self.inner.borrow_mut().handle(req) } #[cfg(test)] pub(crate) fn prepare_request(&self, req: HttpRequest) -> HttpRequest { req.with_state(Rc::clone(&self.state), self.router.clone()) } } impl HttpHandler for HttpApplication { fn handle(&mut self, req: HttpRequest) -> Result, HttpRequest> { let m = { let path = req.path(); path.starts_with(&self.prefix) && ( path.len() == self.prefix.len() || path.split_at(self.prefix.len()).1.starts_with('/')) }; if m { let inner = Rc::clone(&self.inner); let req = req.with_state(Rc::clone(&self.state), self.router.clone()); Ok(Box::new(Pipeline::new(req, Rc::clone(&self.middlewares), inner))) } else { Err(req) } } } struct ApplicationParts { state: S, prefix: String, settings: ServerSettings, default: Resource, resources: HashMap>>, handlers: Vec<(String, Box>)>, external: HashMap, encoding: ContentEncoding, middlewares: Vec>>, } /// Structure that follows the builder pattern for building `Application` structs. pub struct Application { parts: Option>, } impl Application<()> { /// Create application with empty state. Application can /// be configured with builder-like pattern. pub fn new() -> Application<()> { Application { parts: Some(ApplicationParts { state: (), prefix: "/".to_owned(), settings: ServerSettings::default(), default: Resource::default_not_found(), resources: HashMap::new(), handlers: Vec::new(), external: HashMap::new(), encoding: ContentEncoding::Auto, middlewares: Vec::new(), }) } } } impl Default for Application<()> { fn default() -> Self { Application::new() } } impl Application where S: 'static { /// Create application with specific state. Application can be /// configured with builder-like pattern. /// /// State is shared with all resources within same application and could be /// accessed with `HttpRequest::state()` method. pub fn with_state(state: S) -> Application { Application { parts: Some(ApplicationParts { state: state, prefix: "/".to_owned(), settings: ServerSettings::default(), default: Resource::default_not_found(), resources: HashMap::new(), handlers: Vec::new(), external: HashMap::new(), middlewares: Vec::new(), encoding: ContentEncoding::Auto, }) } } /// Set application prefix /// /// Only requests that matches application's prefix get processed by this application. /// Application prefix always contains leading "/" slash. If supplied prefix /// does not contain leading slash, it get inserted. Prefix should /// consists valid path segments. i.e for application with /// prefix `/app` any request with following paths `/app`, `/app/` or `/app/test` /// would match, but path `/application` would not match. /// /// In the following example only requests with "/app/" path prefix /// get handled. Request with path "/app/test/" would be handled, /// but request with path "/application" or "/other/..." would return *NOT FOUND* /// /// ```rust /// # extern crate actix_web; /// use actix_web::*; /// /// fn main() { /// let app = Application::new() /// .prefix("/app") /// .resource("/test", |r| { /// r.method(Method::GET).f(|_| httpcodes::HTTPOk); /// r.method(Method::HEAD).f(|_| httpcodes::HTTPMethodNotAllowed); /// }) /// .finish(); /// } /// ``` pub fn prefix>(mut self, prefix: P) -> Application { { let parts = self.parts.as_mut().expect("Use after finish"); let mut prefix = prefix.into(); if !prefix.starts_with('/') { prefix.insert(0, '/') } parts.prefix = prefix; } self } /// Configure resource for specific path. /// /// Resource may have variable path also. For instance, a resource with /// the path */a/{name}/c* would match all incoming requests with paths /// such as */a/b/c*, */a/1/c*, and */a/etc/c*. /// /// A variable part is specified in the form `{identifier}`, where /// the identifier can be used later in a request handler to access the matched /// value for that part. This is done by looking up the identifier /// in the `Params` object returned by `HttpRequest.match_info()` method. /// /// By default, each part matches the regular expression `[^{}/]+`. /// /// You can also specify a custom regex in the form `{identifier:regex}`: /// /// For instance, to route Get requests on any route matching `/users/{userid}/{friend}` and /// store userid and friend in the exposed Params object: /// /// ```rust /// # extern crate actix_web; /// use actix_web::*; /// /// fn main() { /// let app = Application::new() /// .resource("/test", |r| { /// r.method(Method::GET).f(|_| httpcodes::HTTPOk); /// r.method(Method::HEAD).f(|_| httpcodes::HTTPMethodNotAllowed); /// }); /// } /// ``` pub fn resource(mut self, path: &str, f: F) -> Application where F: FnOnce(&mut Resource) + 'static { { let parts = self.parts.as_mut().expect("Use after finish"); // add resource let mut resource = Resource::default(); f(&mut resource); let pattern = Pattern::new(resource.get_name(), path); if parts.resources.contains_key(&pattern) { panic!("Resource {:?} is registered.", path); } parts.resources.insert(pattern, Some(resource)); } self } /// Default resource is used if no matched route could be found. pub fn default_resource(mut self, f: F) -> Application where F: FnOnce(&mut Resource) + 'static { { let parts = self.parts.as_mut().expect("Use after finish"); f(&mut parts.default); } self } /// Set default content encoding. `ContentEncoding::Auto` is set by default. pub fn default_encoding(mut self, encoding: ContentEncoding) -> Application { { let parts = self.parts.as_mut().expect("Use after finish"); parts.encoding = encoding; } self } /// Register external resource. /// /// External resources are useful for URL generation purposes only and /// are never considered for matching at request time. /// Call to `HttpRequest::url_for()` will work as expected. /// /// ```rust /// # extern crate actix_web; /// use actix_web::*; /// /// fn index(mut req: HttpRequest) -> Result { /// let url = req.url_for("youtube", &["oHg5SJYRHA0"])?; /// assert_eq!(url.as_str(), "https://youtube.com/watch/oHg5SJYRHA0"); /// Ok(httpcodes::HTTPOk.into()) /// } /// /// fn main() { /// let app = Application::new() /// .resource("/index.html", |r| r.f(index)) /// .external_resource("youtube", "https://youtube.com/watch/{video_id}") /// .finish(); /// } /// ``` pub fn external_resource(mut self, name: T, url: U) -> Application where T: AsRef, U: AsRef { { let parts = self.parts.as_mut().expect("Use after finish"); if parts.external.contains_key(name.as_ref()) { panic!("External resource {:?} is registered.", name.as_ref()); } parts.external.insert( String::from(name.as_ref()), Pattern::new(name.as_ref(), url.as_ref())); } self } /// Configure handler for specific path prefix. /// /// Path prefix consists valid path segments. i.e for prefix `/app` /// any request with following paths `/app`, `/app/` or `/app/test` /// would match, but path `/application` would not match. /// /// ```rust /// # extern crate actix_web; /// use actix_web::*; /// /// fn main() { /// let app = Application::new() /// .handler("/app", |req: HttpRequest| { /// match *req.method() { /// Method::GET => httpcodes::HTTPOk, /// Method::POST => httpcodes::HTTPMethodNotAllowed, /// _ => httpcodes::HTTPNotFound, /// }}); /// } /// ``` pub fn handler>(mut self, path: &str, handler: H) -> Application { { let path = path.trim().trim_right_matches('/').to_owned(); let parts = self.parts.as_mut().expect("Use after finish"); parts.handlers.push((path, Box::new(WrapHandler::new(handler)))); } self } /// Register a middleware pub fn middleware>(mut self, mw: M) -> Application { self.parts.as_mut().expect("Use after finish") .middlewares.push(Box::new(mw)); self } /// Finish application configuration and create HttpHandler object pub fn finish(&mut self) -> HttpApplication { let parts = self.parts.take().expect("Use after finish"); let prefix = parts.prefix.trim().trim_right_matches('/'); let mut resources = parts.resources; for (_, pattern) in parts.external { resources.insert(pattern, None); } let (router, resources) = Router::new(prefix, parts.settings, resources); let inner = Rc::new(RefCell::new( Inner { prefix: prefix.len(), default: parts.default, encoding: parts.encoding, router: router.clone(), resources: resources, handlers: parts.handlers, } )); HttpApplication { state: Rc::new(parts.state), prefix: prefix.to_owned(), inner: inner, router: router.clone(), middlewares: Rc::new(parts.middlewares), } } /// Convenience method for creating `Box` instance. /// /// This method is useful if you need to register several application instances /// with different state. /// /// ```rust /// # use std::thread; /// # extern crate actix_web; /// use actix_web::*; /// /// struct State1; /// /// struct State2; /// /// fn main() { /// # thread::spawn(|| { /// HttpServer::new(|| { vec![ /// Application::with_state(State1) /// .prefix("/app1") /// .resource("/", |r| r.h(httpcodes::HTTPOk)) /// .boxed(), /// Application::with_state(State2) /// .prefix("/app2") /// .resource("/", |r| r.h(httpcodes::HTTPOk)) /// .boxed() ]}) /// .bind("127.0.0.1:8080").unwrap() /// .run() /// # }); /// } /// ``` pub fn boxed(mut self) -> Box { Box::new(self.finish()) } } impl IntoHttpHandler for Application { type Handler = HttpApplication; fn into_handler(mut self, settings: ServerSettings) -> HttpApplication { { let parts = self.parts.as_mut().expect("Use after finish"); parts.settings = settings; } self.finish() } } impl<'a, S: 'static> IntoHttpHandler for &'a mut Application { type Handler = HttpApplication; fn into_handler(self, settings: ServerSettings) -> HttpApplication { { let parts = self.parts.as_mut().expect("Use after finish"); parts.settings = settings; } self.finish() } } #[doc(hidden)] impl Iterator for Application { type Item = HttpApplication; fn next(&mut self) -> Option { if self.parts.is_some() { Some(self.finish()) } else { None } } } #[cfg(test)] mod tests { use http::StatusCode; use super::*; use test::TestRequest; use httprequest::HttpRequest; use httpcodes; #[test] fn test_default_resource() { let mut app = Application::new() .resource("/test", |r| r.h(httpcodes::HTTPOk)) .finish(); let req = TestRequest::with_uri("/test").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK); let req = TestRequest::with_uri("/blah").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND); let mut app = Application::new() .default_resource(|r| r.h(httpcodes::HTTPMethodNotAllowed)) .finish(); let req = TestRequest::with_uri("/blah").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::METHOD_NOT_ALLOWED); } #[test] fn test_unhandled_prefix() { let mut app = Application::new() .prefix("/test") .resource("/test", |r| r.h(httpcodes::HTTPOk)) .finish(); assert!(app.handle(HttpRequest::default()).is_err()); } #[test] fn test_state() { let mut app = Application::with_state(10) .resource("/", |r| r.h(httpcodes::HTTPOk)) .finish(); let req = HttpRequest::default().with_state(Rc::clone(&app.state), app.router.clone()); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK); } #[test] fn test_prefix() { let mut app = Application::new() .prefix("/test") .resource("/blah", |r| r.h(httpcodes::HTTPOk)) .finish(); let req = TestRequest::with_uri("/test").finish(); let resp = app.handle(req); assert!(resp.is_ok()); let req = TestRequest::with_uri("/test/").finish(); let resp = app.handle(req); assert!(resp.is_ok()); let req = TestRequest::with_uri("/test/blah").finish(); let resp = app.handle(req); assert!(resp.is_ok()); let req = TestRequest::with_uri("/testing").finish(); let resp = app.handle(req); assert!(resp.is_err()); } #[test] fn test_handler() { let mut app = Application::new() .handler("/test", httpcodes::HTTPOk) .finish(); let req = TestRequest::with_uri("/test").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK); let req = TestRequest::with_uri("/test/").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK); let req = TestRequest::with_uri("/test/app").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK); let req = TestRequest::with_uri("/testapp").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND); let req = TestRequest::with_uri("/blah").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND); } #[test] fn test_handler_prefix() { let mut app = Application::new() .prefix("/app") .handler("/test", httpcodes::HTTPOk) .finish(); let req = TestRequest::with_uri("/test").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND); let req = TestRequest::with_uri("/app/test").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK); let req = TestRequest::with_uri("/app/test/").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK); let req = TestRequest::with_uri("/app/test/app").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK); let req = TestRequest::with_uri("/app/testapp").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND); let req = TestRequest::with_uri("/app/blah").finish(); let resp = app.run(req); assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND); } }