1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::any::type_name;

use actix_utils::future::{ready, Ready};
use actix_web::{dev::Payload, error, FromRequest, HttpRequest};
use derive_more::{AsMut, AsRef, Deref, DerefMut};
use tracing::log;

/// Application data wrapper and extractor for cheaply-cloned types.
///
/// Similar to Actix Web's `Data` wrapper but for `Clone` types that are already an `Arc` internally
/// or shares state using some other means when cloned.
///
/// Unlike `Data`, this wrapper clones `T` during extraction. Therefore, it is the user's
/// responsibility to ensure that clones of `T` do actually share the same state, otherwise state
/// may be unexpectedly different across multiple requests.
///
/// Note that if your type is an `Arc<T>` then it's recommended to use Actix Web's `Data::from(arc)`
/// conversion instead.
///
/// # Examples
///
/// ```
/// use actix_web::{web, App, HttpResponse, Responder};
/// use actix_web_lab::extract::ThinData;
///
/// // Use the `ThinData<T>` extractor to access a database connection pool.
/// async fn index(ThinData(db_pool): ThinData<DbPool>) -> impl Responder {
///     // database action ...
///
///     HttpResponse::Ok()
/// }
///
/// # type DbPool = ();
/// let db_pool = DbPool::default();
///
/// App::new()
///     .app_data(ThinData(db_pool.clone()))
///     .service(web::resource("/").get(index))
/// # ;
/// ```
#[derive(Debug, Clone, AsRef, AsMut, Deref, DerefMut)]
pub struct ThinData<T>(pub T);

impl<T: Clone + 'static> FromRequest for ThinData<T> {
    type Error = actix_web::Error;
    type Future = Ready<Result<Self, Self::Error>>;

    #[inline]
    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
        ready(req.app_data::<Self>().cloned().ok_or_else(|| {
            log::debug!(
                "Failed to extract `ThinData<{}>` for `{}` handler. For the ThinData extractor to work \
                correctly, wrap the data with `ThinData()` and pass it to `App::app_data()`. \
                Ensure that types align in both the set and retrieve calls.",
                type_name::<T>(),
                req.match_name().unwrap_or_else(|| req.path())
            );

            error::ErrorInternalServerError(
                "Requested application data is not configured correctly. \
                View/enable debug logs for more details.",
            )
        }))
    }
}

#[cfg(test)]
mod tests {
    use std::{
        ops::AddAssign,
        sync::{Arc, Mutex},
    };

    use actix_web::{
        http::StatusCode,
        test::{call_service, init_service, TestRequest},
        web, App, HttpResponse,
    };

    use super::*;

    type TestT = Arc<Mutex<u32>>;

    #[actix_web::test]
    async fn thin_data() {
        let test_data = TestT::default();

        let app = init_service(App::new().app_data(ThinData(test_data.clone())).service(
            web::resource("/").to(|td: ThinData<TestT>| {
                td.lock().unwrap().add_assign(1);
                HttpResponse::Ok()
            }),
        ))
        .await;

        for _ in 0..3 {
            let req = TestRequest::default().to_request();
            let resp = call_service(&app, req).await;
            assert_eq!(resp.status(), StatusCode::OK);
        }

        assert_eq!(*test_data.lock().unwrap(), 3);
    }

    #[actix_web::test]
    async fn thin_data_missing() {
        let app = init_service(
            App::new().service(web::resource("/").to(|_: ThinData<u32>| HttpResponse::Ok())),
        )
        .await;

        let req = TestRequest::default().to_request();
        let resp = call_service(&app, req).await;
        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
    }
}