use std::{cell::RefCell, fmt, rc::Rc};
use crate::http::Response;
use crate::router::{IntoPattern, ResourceDef};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::dev::{AndThen, ServiceChain, ServiceChainFactory};
use crate::service::{chain, chain_factory, ServiceCtx};
use crate::service::{
Identity, IntoServiceFactory, Middleware, Service, ServiceFactory, Stack,
};
use crate::util::Extensions;
use super::dev::{insert_slash, WebServiceConfig, WebServiceFactory};
use super::extract::FromRequest;
use super::handler::Handler;
use super::request::WebRequest;
use super::response::WebResponse;
use super::route::{IntoRoutes, Route, RouteService};
use super::{app::Filter, error::ErrorRenderer, guard::Guard, service::AppState};
type HttpService<Err: ErrorRenderer> =
BoxService<WebRequest<Err>, WebResponse, Err::Container>;
type HttpNewService<Err: ErrorRenderer> =
BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
type ResourcePipeline<F, Err> =
ServiceChain<AndThen<F, ResourceRouter<Err>>, WebRequest<Err>>;
pub struct Resource<Err: ErrorRenderer, M = Identity, T = Filter<Err>> {
middleware: M,
filter: ServiceChainFactory<T, WebRequest<Err>>,
rdef: Vec<String>,
name: Option<String>,
routes: Vec<Route<Err>>,
state: Option<Extensions>,
guards: Vec<Box<dyn Guard>>,
default: Rc<RefCell<Option<Rc<HttpNewService<Err>>>>>,
}
impl<Err: ErrorRenderer> Resource<Err> {
pub fn new<T: IntoPattern>(path: T) -> Resource<Err> {
Resource {
routes: Vec::new(),
rdef: path.patterns(),
name: None,
state: None,
middleware: Identity,
filter: chain_factory(Filter::new()),
guards: Vec::new(),
default: Rc::new(RefCell::new(None)),
}
}
}
impl<Err, M, T> Resource<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
>,
Err: ErrorRenderer,
{
pub fn name(mut self, name: &str) -> Self {
self.name = Some(name.to_string());
self
}
pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
self.guards.push(Box::new(guard));
self
}
pub(crate) fn add_guards(mut self, guards: Vec<Box<dyn Guard>>) -> Self {
self.guards.extend(guards);
self
}
pub fn state<D: 'static>(mut self, st: D) -> Self {
if self.state.is_none() {
self.state = Some(Extensions::new());
}
self.state.as_mut().unwrap().insert(st);
self
}
pub fn route<R>(mut self, route: R) -> Self
where
R: IntoRoutes<Err>,
{
for route in route.routes() {
self.routes.push(route);
}
self
}
pub fn to<F, Args>(mut self, handler: F) -> Self
where
F: Handler<Args, Err> + 'static,
Args: FromRequest<Err> + 'static,
Args::Error: Into<Err::Container>,
{
self.routes.push(Route::new().to(handler));
self
}
pub fn filter<U, F>(
self,
filter: F,
) -> Resource<
Err,
M,
impl ServiceFactory<
WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
>,
>
where
U: ServiceFactory<
WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
>,
F: IntoServiceFactory<U, WebRequest<Err>>,
{
Resource {
filter: self
.filter
.and_then(filter.into_factory().map_init_err(|_| ())),
middleware: self.middleware,
rdef: self.rdef,
name: self.name,
state: self.state,
guards: self.guards,
routes: self.routes,
default: self.default,
}
}
pub fn wrap<U>(self, mw: U) -> Resource<Err, Stack<M, U>, T> {
Resource {
middleware: Stack::new(self.middleware, mw),
filter: self.filter,
rdef: self.rdef,
name: self.name,
state: self.state,
guards: self.guards,
routes: self.routes,
default: self.default,
}
}
pub fn default_service<F, S>(mut self, f: F) -> Self
where
F: IntoServiceFactory<S, WebRequest<Err>>,
S: ServiceFactory<WebRequest<Err>, Response = WebResponse, Error = Err::Container>
+ 'static,
S::InitError: fmt::Debug,
{
self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
chain_factory(f.into_factory())
.map_init_err(|e| log::error!("Cannot construct default service: {:?}", e)),
)))));
self
}
}
impl<Err, M, T> WebServiceFactory<Err> for Resource<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
> + 'static,
M: Middleware<ResourcePipeline<T::Service, Err>> + 'static,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
Err: ErrorRenderer,
{
fn register(mut self, config: &mut WebServiceConfig<Err>) {
let guards = if self.guards.is_empty() {
None
} else {
Some(std::mem::take(&mut self.guards))
};
let mut rdef = if config.is_root() || !self.rdef.is_empty() {
ResourceDef::new(insert_slash(self.rdef.clone()))
} else {
ResourceDef::new(self.rdef.clone())
};
if let Some(ref name) = self.name {
rdef.name_mut().clone_from(name);
}
let state = self.state.take().map(|state| {
AppState::new(
state,
Some(config.state().clone()),
config.state().config().clone(),
)
});
let router_factory = ResourceRouterFactory {
state,
routes: self.routes,
default: self.default.borrow_mut().take(),
};
config.register_service(
rdef,
guards,
ResourceServiceFactory {
middleware: self.middleware,
filter: self.filter,
routing: router_factory,
},
None,
)
}
}
impl<Err, M, F>
IntoServiceFactory<
ResourceServiceFactory<Err, M, ServiceChainFactory<F, WebRequest<Err>>>,
WebRequest<Err>,
> for Resource<Err, M, F>
where
F: ServiceFactory<
WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
> + 'static,
M: Middleware<ResourcePipeline<F::Service, Err>> + 'static,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
Err: ErrorRenderer,
{
fn into_factory(
self,
) -> ResourceServiceFactory<Err, M, ServiceChainFactory<F, WebRequest<Err>>> {
let router_factory = ResourceRouterFactory {
state: None,
routes: self.routes,
default: self.default.borrow_mut().take(),
};
ResourceServiceFactory {
middleware: self.middleware,
filter: self.filter,
routing: router_factory,
}
}
}
pub struct ResourceServiceFactory<Err: ErrorRenderer, M, F> {
middleware: M,
filter: F,
routing: ResourceRouterFactory<Err>,
}
impl<Err, M, F> ServiceFactory<WebRequest<Err>> for ResourceServiceFactory<Err, M, F>
where
M: Middleware<ResourcePipeline<F::Service, Err>> + 'static,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
> + 'static,
Err: ErrorRenderer,
{
type Response = WebResponse;
type Error = Err::Container;
type Service = M::Service;
type InitError = ();
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
let filter = self.filter.create(()).await?;
let routing = self.routing.create(()).await?;
Ok(self.middleware.create(chain(filter).and_then(routing)))
}
}
struct ResourceRouterFactory<Err: ErrorRenderer> {
routes: Vec<Route<Err>>,
default: Option<Rc<HttpNewService<Err>>>,
state: Option<AppState>,
}
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for ResourceRouterFactory<Err> {
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
type Service = ResourceRouter<Err>;
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
let default = if let Some(ref default) = self.default {
Some(default.create(()).await?)
} else {
None
};
Ok(ResourceRouter {
default,
state: self.state.clone(),
routes: self.routes.iter().map(|route| route.service()).collect(),
})
}
}
pub struct ResourceRouter<Err: ErrorRenderer> {
state: Option<AppState>,
routes: Vec<RouteService<Err>>,
default: Option<HttpService<Err>>,
}
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ResourceRouter<Err> {
type Response = WebResponse;
type Error = Err::Container;
async fn call(
&self,
mut req: WebRequest<Err>,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
for route in self.routes.iter() {
if route.check(&mut req) {
if let Some(ref state) = self.state {
req.set_state_container(state.clone());
}
return ctx.call(route, req).await;
}
}
if let Some(ref default) = self.default {
ctx.call(default, req).await
} else {
Ok(WebResponse::new(
Response::MethodNotAllowed().finish(),
req.into_parts().0,
))
}
}
}
#[cfg(test)]
mod tests {
use crate::http::header::{self, HeaderValue};
use crate::http::{Method, StatusCode};
use crate::time::{sleep, Millis};
use crate::web::middleware::DefaultHeaders;
use crate::web::test::{call_service, init_service, TestRequest};
use crate::web::{self, guard, request::WebRequest, App, DefaultError, HttpResponse};
use crate::{service::fn_service, util::Ready};
#[crate::rt_test]
async fn test_filter() {
let filter = std::rc::Rc::new(std::cell::Cell::new(false));
let filter2 = filter.clone();
let srv = init_service(
App::new().service(
web::resource("/test")
.filter(fn_service(move |req: WebRequest<_>| {
filter2.set(true);
Ready::Ok(req)
}))
.route(web::get().to(|| async { HttpResponse::Ok() })),
),
)
.await;
let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
assert!(filter.get());
}
#[crate::rt_test]
async fn test_middleware() {
let srv = init_service(
App::new().service(
web::resource("/test")
.name("test")
.wrap(
DefaultHeaders::new()
.header(header::CONTENT_TYPE, HeaderValue::from_static("0001")),
)
.route(web::get().to(|| async { HttpResponse::Ok() })),
),
)
.await;
let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(),
HeaderValue::from_static("0001")
);
}
#[crate::rt_test]
async fn test_to() {
let srv = init_service(App::new().service(web::resource("/test").to(|| async {
sleep(Millis(100)).await;
HttpResponse::Ok()
})))
.await;
let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
}
#[crate::rt_test]
async fn test_pattern() {
let srv = init_service(App::new().service(
web::resource(["/test", "/test2"]).to(|| async { HttpResponse::Ok() }),
))
.await;
let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test2").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
}
#[crate::rt_test]
async fn test_default_resource() {
let srv = init_service(
App::new()
.service(
web::resource("/test")
.route(web::get().to(|| async { HttpResponse::Ok() })),
)
.default_service(|r: WebRequest<DefaultError>| async move {
Ok(r.into_response(HttpResponse::BadRequest()))
}),
)
.await;
let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test")
.method(Method::POST)
.to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
let srv = init_service(
App::new().service(
web::resource("/test")
.route(web::get().to(|| async { HttpResponse::Ok() }))
.default_service(|r: WebRequest<DefaultError>| async move {
Ok(r.into_response(HttpResponse::BadRequest()))
}),
),
)
.await;
let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test")
.method(Method::POST)
.to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}
#[crate::rt_test]
async fn test_resource_guards() {
let srv = init_service(
App::new()
.service(
web::resource("/test/{p}")
.guard(guard::Get())
.to(|| async { HttpResponse::Ok() }),
)
.service(
web::resource("/test/{p}")
.guard(guard::Put())
.to(|| async { HttpResponse::Created() }),
)
.service(
web::resource("/test/{p}")
.guard(guard::Delete())
.to(|| async { HttpResponse::NoContent() }),
),
)
.await;
let req = TestRequest::with_uri("/test/it")
.method(Method::GET)
.to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test/it")
.method(Method::PUT)
.to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::CREATED);
let req = TestRequest::with_uri("/test/it")
.method(Method::DELETE)
.to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
}
#[crate::rt_test]
async fn test_state() {
let srv = init_service(
App::new().state(1i32).state(1usize).state('-').service(
web::resource("/test")
.state(10usize)
.state('*')
.guard(guard::Get())
.to(
|data1: web::types::State<usize>,
data2: web::types::State<char>,
data3: web::types::State<i32>| {
assert_eq!(*data1, 10);
assert_eq!(*data2, '*');
assert_eq!(*data3, 1);
async { HttpResponse::Ok() }
},
),
),
)
.await;
let req = TestRequest::get().uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
}
}