1use std::{cell::RefCell, fmt, future::Future, rc::Rc};
2
3use actix_http::Extensions;
4use actix_router::{IntoPatterns, Patterns};
5use actix_service::{
6 apply, apply_fn_factory, boxed, fn_service, IntoServiceFactory, Service, ServiceFactory,
7 ServiceFactoryExt, Transform,
8};
9use futures_core::future::LocalBoxFuture;
10use futures_util::future::join_all;
11
12use crate::{
13 body::MessageBody,
14 data::Data,
15 dev::{ensure_leading_slash, AppService, ResourceDef},
16 guard::{self, Guard},
17 handler::Handler,
18 http::header,
19 route::{Route, RouteService},
20 service::{
21 BoxedHttpService, BoxedHttpServiceFactory, HttpServiceFactory, ServiceRequest,
22 ServiceResponse,
23 },
24 web, Error, FromRequest, HttpResponse, Responder,
25};
26
27pub struct Resource<T = ResourceEndpoint> {
52 endpoint: T,
53 rdef: Patterns,
54 name: Option<String>,
55 routes: Vec<Route>,
56 app_data: Option<Extensions>,
57 guards: Vec<Box<dyn Guard>>,
58 default: BoxedHttpServiceFactory,
59 factory_ref: Rc<RefCell<Option<ResourceFactory>>>,
60}
61
62impl Resource {
63 pub fn new<T: IntoPatterns>(path: T) -> Resource {
65 let factory_ref = Rc::new(RefCell::new(None));
66
67 Resource {
68 routes: Vec::new(),
69 rdef: path.patterns(),
70 name: None,
71 endpoint: ResourceEndpoint::new(Rc::clone(&factory_ref)),
72 factory_ref,
73 guards: Vec::new(),
74 app_data: None,
75 default: boxed::factory(fn_service(|req: ServiceRequest| async {
76 use crate::HttpMessage as _;
77
78 let allowed = req.extensions().get::<guard::RegisteredMethods>().cloned();
79
80 if let Some(methods) = allowed {
81 Ok(req.into_response(
82 HttpResponse::MethodNotAllowed()
83 .insert_header(header::Allow(methods.0))
84 .finish(),
85 ))
86 } else {
87 Ok(req.into_response(HttpResponse::MethodNotAllowed()))
88 }
89 })),
90 }
91 }
92}
93
94impl<T> Resource<T>
95where
96 T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>,
97{
98 pub fn name(mut self, name: &str) -> Self {
102 self.name = Some(name.to_string());
103 self
104 }
105
106 pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
128 self.guards.push(Box::new(guard));
129 self
130 }
131
132 pub(crate) fn add_guards(mut self, guards: Vec<Box<dyn Guard>>) -> Self {
133 self.guards.extend(guards);
134 self
135 }
136
137 pub fn route(mut self, route: Route) -> Self {
169 self.routes.push(route);
170 self
171 }
172
173 #[doc(alias = "manage")]
206 pub fn app_data<U: 'static>(mut self, data: U) -> Self {
207 self.app_data
208 .get_or_insert_with(Extensions::new)
209 .insert(data);
210
211 self
212 }
213
214 #[deprecated(since = "4.0.0", note = "Use `.app_data(Data::new(val))` instead.")]
218 pub fn data<U: 'static>(self, data: U) -> Self {
219 self.app_data(Data::new(data))
220 }
221
222 pub fn to<F, Args>(mut self, handler: F) -> Self
242 where
243 F: Handler<Args>,
244 Args: FromRequest + 'static,
245 F::Output: Responder + 'static,
246 {
247 self.routes.push(Route::new().to(handler));
248 self
249 }
250
251 #[doc(alias = "middleware")]
258 #[doc(alias = "use")] pub fn wrap<M, B>(
260 self,
261 mw: M,
262 ) -> Resource<
263 impl ServiceFactory<
264 ServiceRequest,
265 Config = (),
266 Response = ServiceResponse<B>,
267 Error = Error,
268 InitError = (),
269 >,
270 >
271 where
272 M: Transform<
273 T::Service,
274 ServiceRequest,
275 Response = ServiceResponse<B>,
276 Error = Error,
277 InitError = (),
278 > + 'static,
279 B: MessageBody,
280 {
281 Resource {
282 endpoint: apply(mw, self.endpoint),
283 rdef: self.rdef,
284 name: self.name,
285 guards: self.guards,
286 routes: self.routes,
287 default: self.default,
288 app_data: self.app_data,
289 factory_ref: self.factory_ref,
290 }
291 }
292
293 #[doc(alias = "middleware")]
301 #[doc(alias = "use")] pub fn wrap_fn<F, R, B>(
303 self,
304 mw: F,
305 ) -> Resource<
306 impl ServiceFactory<
307 ServiceRequest,
308 Config = (),
309 Response = ServiceResponse<B>,
310 Error = Error,
311 InitError = (),
312 >,
313 >
314 where
315 F: Fn(ServiceRequest, &T::Service) -> R + Clone + 'static,
316 R: Future<Output = Result<ServiceResponse<B>, Error>>,
317 B: MessageBody,
318 {
319 Resource {
320 endpoint: apply_fn_factory(self.endpoint, mw),
321 rdef: self.rdef,
322 name: self.name,
323 guards: self.guards,
324 routes: self.routes,
325 default: self.default,
326 app_data: self.app_data,
327 factory_ref: self.factory_ref,
328 }
329 }
330
331 pub fn default_service<F, U>(mut self, f: F) -> Self
354 where
355 F: IntoServiceFactory<U, ServiceRequest>,
356 U: ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse, Error = Error>
357 + 'static,
358 U::InitError: fmt::Debug,
359 {
360 self.default = boxed::factory(f.into_factory().map_init_err(|err| {
362 log::error!("Can not construct default service: {err:?}");
363 }));
364
365 self
366 }
367}
368
369macro_rules! route_shortcut {
370 ($method_fn:ident, $method_upper:literal) => {
371 #[doc = concat!(" Adds a ", $method_upper, " route.")]
372 #[doc = concat!(" .", stringify!($method_fn), "(|| async { \"Hello World!\" })")]
381 pub fn $method_fn<F, Args>(self, handler: F) -> Self
384 where
385 F: Handler<Args>,
386 Args: FromRequest + 'static,
387 F::Output: Responder + 'static,
388 {
389 self.route(web::$method_fn().to(handler))
390 }
391 };
392}
393
394impl<T> Resource<T>
396where
397 T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>,
398{
399 route_shortcut!(get, "GET");
400 route_shortcut!(post, "POST");
401 route_shortcut!(put, "PUT");
402 route_shortcut!(patch, "PATCH");
403 route_shortcut!(delete, "DELETE");
404 route_shortcut!(head, "HEAD");
405 route_shortcut!(trace, "TRACE");
406}
407
408impl<T, B> HttpServiceFactory for Resource<T>
409where
410 T: ServiceFactory<
411 ServiceRequest,
412 Config = (),
413 Response = ServiceResponse<B>,
414 Error = Error,
415 InitError = (),
416 > + 'static,
417 B: MessageBody + 'static,
418{
419 fn register(mut self, config: &mut AppService) {
420 let guards = if self.guards.is_empty() {
421 None
422 } else {
423 Some(std::mem::take(&mut self.guards))
424 };
425
426 let mut rdef = if config.is_root() || !self.rdef.is_empty() {
427 ResourceDef::new(ensure_leading_slash(self.rdef.clone()))
428 } else {
429 ResourceDef::new(self.rdef.clone())
430 };
431
432 if let Some(ref name) = self.name {
433 rdef.set_name(name);
434 }
435
436 *self.factory_ref.borrow_mut() = Some(ResourceFactory {
437 routes: self.routes,
438 default: self.default,
439 });
440
441 let resource_data = self.app_data.map(Rc::new);
442
443 let endpoint = apply_fn_factory(self.endpoint, move |mut req: ServiceRequest, srv| {
445 if let Some(ref data) = resource_data {
446 req.add_data_container(Rc::clone(data));
447 }
448
449 let fut = srv.call(req);
450
451 async { Ok(fut.await?.map_into_boxed_body()) }
452 });
453
454 config.register_service(rdef, guards, endpoint, None)
455 }
456}
457
458pub struct ResourceFactory {
459 routes: Vec<Route>,
460 default: BoxedHttpServiceFactory,
461}
462
463impl ServiceFactory<ServiceRequest> for ResourceFactory {
464 type Response = ServiceResponse;
465 type Error = Error;
466 type Config = ();
467 type Service = ResourceService;
468 type InitError = ();
469 type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
470
471 fn new_service(&self, _: ()) -> Self::Future {
472 let default_fut = self.default.new_service(());
474
475 let factory_fut = join_all(self.routes.iter().map(|route| route.new_service(())));
477
478 Box::pin(async move {
479 let default = default_fut.await?;
480 let routes = factory_fut
481 .await
482 .into_iter()
483 .collect::<Result<Vec<_>, _>>()?;
484
485 Ok(ResourceService { routes, default })
486 })
487 }
488}
489
490pub struct ResourceService {
491 routes: Vec<RouteService>,
492 default: BoxedHttpService,
493}
494
495impl Service<ServiceRequest> for ResourceService {
496 type Response = ServiceResponse;
497 type Error = Error;
498 type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
499
500 actix_service::always_ready!();
501
502 fn call(&self, mut req: ServiceRequest) -> Self::Future {
503 for route in &self.routes {
504 if route.check(&mut req) {
505 return route.call(req);
506 }
507 }
508
509 self.default.call(req)
510 }
511}
512
513#[doc(hidden)]
514pub struct ResourceEndpoint {
515 factory: Rc<RefCell<Option<ResourceFactory>>>,
516}
517
518impl ResourceEndpoint {
519 fn new(factory: Rc<RefCell<Option<ResourceFactory>>>) -> Self {
520 ResourceEndpoint { factory }
521 }
522}
523
524impl ServiceFactory<ServiceRequest> for ResourceEndpoint {
525 type Response = ServiceResponse;
526 type Error = Error;
527 type Config = ();
528 type Service = ResourceService;
529 type InitError = ();
530 type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
531
532 fn new_service(&self, _: ()) -> Self::Future {
533 self.factory.borrow().as_ref().unwrap().new_service(())
534 }
535}
536
537#[cfg(test)]
538mod tests {
539 use std::time::Duration;
540
541 use actix_rt::time::sleep;
542 use actix_utils::future::ok;
543
544 use super::*;
545 use crate::{
546 http::{header::HeaderValue, Method, StatusCode},
547 middleware::DefaultHeaders,
548 test::{call_service, init_service, TestRequest},
549 App, HttpMessage,
550 };
551
552 #[test]
553 fn can_be_returned_from_fn() {
554 fn my_resource_1() -> Resource {
555 web::resource("/test1").route(web::get().to(|| async { "hello" }))
556 }
557
558 fn my_resource_2() -> Resource<
559 impl ServiceFactory<
560 ServiceRequest,
561 Config = (),
562 Response = ServiceResponse<impl MessageBody>,
563 Error = Error,
564 InitError = (),
565 >,
566 > {
567 web::resource("/test2")
568 .wrap_fn(|req, srv| {
569 let fut = srv.call(req);
570 async { Ok(fut.await?.map_into_right_body::<()>()) }
571 })
572 .route(web::get().to(|| async { "hello" }))
573 }
574
575 fn my_resource_3() -> impl HttpServiceFactory {
576 web::resource("/test3").route(web::get().to(|| async { "hello" }))
577 }
578
579 App::new()
580 .service(my_resource_1())
581 .service(my_resource_2())
582 .service(my_resource_3());
583 }
584
585 #[actix_rt::test]
586 async fn test_middleware() {
587 let srv = init_service(
588 App::new().service(
589 web::resource("/test")
590 .name("test")
591 .wrap(
592 DefaultHeaders::new()
593 .add((header::CONTENT_TYPE, HeaderValue::from_static("0001"))),
594 )
595 .route(web::get().to(HttpResponse::Ok)),
596 ),
597 )
598 .await;
599 let req = TestRequest::with_uri("/test").to_request();
600 let resp = call_service(&srv, req).await;
601 assert_eq!(resp.status(), StatusCode::OK);
602 assert_eq!(
603 resp.headers().get(header::CONTENT_TYPE).unwrap(),
604 HeaderValue::from_static("0001")
605 );
606 }
607
608 #[actix_rt::test]
609 async fn test_middleware_fn() {
610 let srv = init_service(
611 App::new().service(
612 web::resource("/test")
613 .wrap_fn(|req, srv| {
614 let fut = srv.call(req);
615 async {
616 fut.await.map(|mut res| {
617 res.headers_mut()
618 .insert(header::CONTENT_TYPE, HeaderValue::from_static("0001"));
619 res
620 })
621 }
622 })
623 .route(web::get().to(HttpResponse::Ok)),
624 ),
625 )
626 .await;
627 let req = TestRequest::with_uri("/test").to_request();
628 let resp = call_service(&srv, req).await;
629 assert_eq!(resp.status(), StatusCode::OK);
630 assert_eq!(
631 resp.headers().get(header::CONTENT_TYPE).unwrap(),
632 HeaderValue::from_static("0001")
633 );
634 }
635
636 #[actix_rt::test]
637 async fn test_to() {
638 let srv = init_service(App::new().service(web::resource("/test").to(|| async {
639 sleep(Duration::from_millis(100)).await;
640 Ok::<_, Error>(HttpResponse::Ok())
641 })))
642 .await;
643 let req = TestRequest::with_uri("/test").to_request();
644 let resp = call_service(&srv, req).await;
645 assert_eq!(resp.status(), StatusCode::OK);
646 }
647
648 #[actix_rt::test]
649 async fn test_pattern() {
650 let srv = init_service(App::new().service(
651 web::resource(["/test", "/test2"]).to(|| async { Ok::<_, Error>(HttpResponse::Ok()) }),
652 ))
653 .await;
654 let req = TestRequest::with_uri("/test").to_request();
655 let resp = call_service(&srv, req).await;
656 assert_eq!(resp.status(), StatusCode::OK);
657 let req = TestRequest::with_uri("/test2").to_request();
658 let resp = call_service(&srv, req).await;
659 assert_eq!(resp.status(), StatusCode::OK);
660 }
661
662 #[actix_rt::test]
663 async fn test_default_resource() {
664 let srv = init_service(
665 App::new()
666 .service(
667 web::resource("/test")
668 .route(web::get().to(HttpResponse::Ok))
669 .route(web::delete().to(HttpResponse::Ok)),
670 )
671 .default_service(|r: ServiceRequest| {
672 ok(r.into_response(HttpResponse::BadRequest()))
673 }),
674 )
675 .await;
676 let req = TestRequest::with_uri("/test").to_request();
677 let resp = call_service(&srv, req).await;
678 assert_eq!(resp.status(), StatusCode::OK);
679
680 let req = TestRequest::with_uri("/test")
681 .method(Method::POST)
682 .to_request();
683 let resp = call_service(&srv, req).await;
684 assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
685 assert_eq!(
686 resp.headers().get(header::ALLOW).unwrap().as_bytes(),
687 b"GET, DELETE"
688 );
689
690 let srv = init_service(
691 App::new().service(
692 web::resource("/test")
693 .route(web::get().to(HttpResponse::Ok))
694 .default_service(|r: ServiceRequest| {
695 ok(r.into_response(HttpResponse::BadRequest()))
696 }),
697 ),
698 )
699 .await;
700
701 let req = TestRequest::with_uri("/test").to_request();
702 let resp = call_service(&srv, req).await;
703 assert_eq!(resp.status(), StatusCode::OK);
704
705 let req = TestRequest::with_uri("/test")
706 .method(Method::POST)
707 .to_request();
708 let resp = call_service(&srv, req).await;
709 assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
710 }
711
712 #[actix_rt::test]
713 async fn test_resource_guards() {
714 let srv = init_service(
715 App::new()
716 .service(
717 web::resource("/test/{p}")
718 .guard(guard::Get())
719 .to(HttpResponse::Ok),
720 )
721 .service(
722 web::resource("/test/{p}")
723 .guard(guard::Put())
724 .to(HttpResponse::Created),
725 )
726 .service(
727 web::resource("/test/{p}")
728 .guard(guard::Delete())
729 .to(HttpResponse::NoContent),
730 ),
731 )
732 .await;
733
734 let req = TestRequest::with_uri("/test/it")
735 .method(Method::GET)
736 .to_request();
737 let resp = call_service(&srv, req).await;
738 assert_eq!(resp.status(), StatusCode::OK);
739
740 let req = TestRequest::with_uri("/test/it")
741 .method(Method::PUT)
742 .to_request();
743 let resp = call_service(&srv, req).await;
744 assert_eq!(resp.status(), StatusCode::CREATED);
745
746 let req = TestRequest::with_uri("/test/it")
747 .method(Method::DELETE)
748 .to_request();
749 let resp = call_service(&srv, req).await;
750 assert_eq!(resp.status(), StatusCode::NO_CONTENT);
751 }
752
753 #[allow(deprecated)]
755 #[actix_rt::test]
756 async fn test_data() {
757 let srv = init_service(
758 App::new()
759 .data(1.0f64)
760 .data(1usize)
761 .app_data(web::Data::new('-'))
762 .service(
763 web::resource("/test")
764 .data(10usize)
765 .app_data(web::Data::new('*'))
766 .guard(guard::Get())
767 .to(
768 |data1: web::Data<usize>,
769 data2: web::Data<char>,
770 data3: web::Data<f64>| {
771 assert_eq!(**data1, 10);
772 assert_eq!(**data2, '*');
773 let error = f64::EPSILON;
774 assert!((**data3 - 1.0).abs() < error);
775 HttpResponse::Ok()
776 },
777 ),
778 ),
779 )
780 .await;
781
782 let req = TestRequest::get().uri("/test").to_request();
783 let resp = call_service(&srv, req).await;
784 assert_eq!(resp.status(), StatusCode::OK);
785 }
786
787 #[allow(deprecated)]
789 #[actix_rt::test]
790 async fn test_data_default_service() {
791 let srv =
792 init_service(
793 App::new().data(1usize).service(
794 web::resource("/test")
795 .data(10usize)
796 .default_service(web::to(|data: web::Data<usize>| {
797 assert_eq!(**data, 10);
798 HttpResponse::Ok()
799 })),
800 ),
801 )
802 .await;
803
804 let req = TestRequest::get().uri("/test").to_request();
805 let resp = call_service(&srv, req).await;
806 assert_eq!(resp.status(), StatusCode::OK);
807 }
808
809 #[actix_rt::test]
810 async fn test_middleware_app_data() {
811 let srv = init_service(
812 App::new().service(
813 web::resource("test")
814 .app_data(1usize)
815 .wrap_fn(|req, srv| {
816 assert_eq!(req.app_data::<usize>(), Some(&1usize));
817 req.extensions_mut().insert(1usize);
818 srv.call(req)
819 })
820 .route(web::get().to(HttpResponse::Ok))
821 .default_service(|req: ServiceRequest| async move {
822 let (req, _) = req.into_parts();
823
824 assert_eq!(req.extensions().get::<usize>(), Some(&1));
825
826 Ok(ServiceResponse::new(
827 req,
828 HttpResponse::BadRequest().finish(),
829 ))
830 }),
831 ),
832 )
833 .await;
834
835 let req = TestRequest::get().uri("/test").to_request();
836 let resp = call_service(&srv, req).await;
837 assert_eq!(resp.status(), StatusCode::OK);
838
839 let req = TestRequest::post().uri("/test").to_request();
840 let resp = call_service(&srv, req).await;
841 assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
842 }
843
844 #[actix_rt::test]
845 async fn test_middleware_body_type() {
846 let srv = init_service(
847 App::new().service(
848 web::resource("/test")
849 .wrap_fn(|req, srv| {
850 let fut = srv.call(req);
851 async { Ok(fut.await?.map_into_right_body::<()>()) }
852 })
853 .route(web::get().to(|| async { "hello" })),
854 ),
855 )
856 .await;
857
858 use actix_http::body::MessageBody as _;
860 let req = TestRequest::with_uri("/test").to_request();
861 let resp = call_service(&srv, req).await;
862 let body = resp.into_body();
863 assert_eq!(body.try_into_bytes().unwrap(), b"hello".as_ref());
864 }
865}