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