Skip to main content

vertigo_cli/serve/
vertigo_handler.rs

1use actix_web::{
2    HttpRequest,
3    http::{StatusCode, header},
4    web,
5};
6use std::time::Instant;
7
8use crate::serve::{
9    MountConfig, RequestHeaders, html::SSR_FETCH_HEADER, response_state::ResponseState,
10};
11
12use super::server_state::ServerState;
13
14/// Directly attach SSR mechanism to the actix web server (no static files mounting)
15///
16/// To root path:
17///
18/// ```no_run
19/// # use actix_web::web;
20/// # use vertigo_cli::serve::{MountConfigBuilder, vertigo_handler};
21/// # let mount_config = MountConfigBuilder::new("/", "/").build().unwrap();
22/// # let app = web::scope("/");
23/// app.default_service(vertigo_handler(&mount_config));
24/// ```
25///
26/// To custom mount point:
27///
28/// ```no_run
29/// # use actix_web::web;
30/// # use vertigo_cli::serve::{MountConfigBuilder, vertigo_handler};
31/// # let mount_config = MountConfigBuilder::new("/", "/").build().unwrap();
32/// # let app = web::scope("/");
33/// app.service(
34///     web::scope(mount_config.mount_point())
35///         .default_service(vertigo_handler(&mount_config)),
36/// );
37/// ```
38pub fn vertigo_handler(mount_config: &MountConfig) -> actix_web::Route {
39    let mount_point = mount_config.mount_point().to_string();
40
41    web::route().to(move |req: HttpRequest| {
42        let mount_point = mount_point.clone();
43        async move {
44            // Rendering a page for an SSR fetch could fetch the same URL again, endlessly
45            if req.headers().contains_key(SSR_FETCH_HEADER) {
46                log::error!(
47                    "SSR fetched {}, which only the SSR handler serves",
48                    req.uri()
49                );
50                return actix_web::HttpResponse::NotFound().finish();
51            }
52
53            let state = ServerState::global(&mount_point);
54            let now = Instant::now();
55            let url = req.uri();
56
57            let uri = {
58                let path = url.path();
59                // Strip mount point to get local url
60                let local_url = if state.mount_config.mount_point() != "/" {
61                    path.trim_start_matches(state.mount_config.mount_point())
62                } else {
63                    path
64                };
65
66                match url.query() {
67                    Some(query) => format!("{local_url}?{query}"),
68                    None => local_url.to_string(),
69                }
70            };
71
72            log::debug!("Incoming request: {uri}");
73            let cookie = request_cookie(&req);
74            let accept_language = request_accept_language(&req);
75            let headers = RequestHeaders {
76                cookie: cookie.as_deref(),
77                accept_language: accept_language.as_deref(),
78            };
79            let mut response_state = state.request_with_headers(&uri, headers).await;
80
81            let time = now.elapsed().as_millis();
82            let log_level = if time > 1000 {
83                log::Level::Warn
84            } else {
85                log::Level::Info
86            };
87            log::log!(
88                log_level,
89                "Response for request: {} {time}ms {uri}",
90                response_state.status,
91            );
92
93            if let Some(port_watch) = state.port_watch
94                && response_state.headers.get("content-type")
95                    == Some(&ResponseState::HTML.to_string())
96            {
97                response_state.add_watch_script(port_watch);
98            }
99
100            // Checking for error status to log
101            if StatusCode::from_u16(response_state.status)
102                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
103                .is_server_error()
104            {
105                log::error!("WASM status: {}", response_state.status);
106
107                match String::from_utf8(response_state.body.clone()) {
108                    Ok(messagee) => {
109                        log::error!("WASM response: text={}", messagee);
110                    }
111                    Err(_) => {
112                        log::error!("WASM response: bytes={:#?}", response_state.body);
113                    }
114                }
115            }
116
117            actix_web::HttpResponse::from(response_state)
118        }
119    })
120}
121
122/// `Cookie` header of the request, for [`ServerState::request_with_cookie`].
123///
124/// HTTP/2 may send the cookies as several header fields; they are joined with `; `
125/// (RFC 9113, section 8.2.3).
126pub fn request_cookie(req: &HttpRequest) -> Option<String> {
127    let parts: Vec<&str> = req
128        .headers()
129        .get_all(header::COOKIE)
130        .filter_map(|value| value.to_str().ok())
131        .collect();
132
133    (!parts.is_empty()).then(|| parts.join("; "))
134}
135
136/// `Accept-Language` header of the request, for [`ServerState::request_with_headers`].
137///
138/// Several header fields make one list, joined with `, ` (RFC 9110, section 5.3).
139pub fn request_accept_language(req: &HttpRequest) -> Option<String> {
140    let parts: Vec<&str> = req
141        .headers()
142        .get_all(header::ACCEPT_LANGUAGE)
143        .filter_map(|value| value.to_str().ok())
144        .collect();
145
146    (!parts.is_empty()).then(|| parts.join(", "))
147}
148
149#[cfg(test)]
150mod tests {
151    use actix_web::{http::header, test::TestRequest};
152
153    use super::{request_accept_language, request_cookie};
154
155    #[test]
156    fn no_cookie_header() {
157        assert_eq!(request_cookie(&TestRequest::get().to_http_request()), None);
158    }
159
160    #[test]
161    fn split_cookie_headers_are_joined() {
162        let req = TestRequest::get()
163            .append_header((header::COOKIE, "session=abc"))
164            .append_header((header::COOKIE, "theme=dark"))
165            .to_http_request();
166
167        assert_eq!(
168            request_cookie(&req).as_deref(),
169            Some("session=abc; theme=dark")
170        );
171    }
172
173    #[test]
174    fn split_accept_language_headers_are_one_list() {
175        let req = TestRequest::get()
176            .append_header((header::ACCEPT_LANGUAGE, "pl-PL,pl;q=0.9"))
177            .append_header((header::ACCEPT_LANGUAGE, "en;q=0.5"))
178            .to_http_request();
179
180        assert_eq!(
181            request_accept_language(&req).as_deref(),
182            Some("pl-PL,pl;q=0.9, en;q=0.5")
183        );
184        assert_eq!(
185            request_accept_language(&TestRequest::get().to_http_request()),
186            None
187        );
188    }
189}