vertigo_cli/serve/
vertigo_handler.rs1use 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
14pub 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 if is_ssr_fetch(&req) {
45 log::error!(
46 "SSR fetched {}, which only the SSR handler serves",
47 req.uri()
48 );
49 return actix_web::HttpResponse::NotFound().finish();
50 }
51
52 let state = ServerState::global(&mount_point);
53 let now = Instant::now();
54 let url = req.uri();
55
56 let uri = {
57 let path = url.path();
58 let local_url = if state.mount_config.mount_point() != "/" {
60 path.trim_start_matches(state.mount_config.mount_point())
61 } else {
62 path
63 };
64
65 match url.query() {
66 Some(query) => format!("{local_url}?{query}"),
67 None => local_url.to_string(),
68 }
69 };
70
71 log::debug!("Incoming request: {uri}");
72 let cookie = request_cookie(&req);
73 let accept_language = request_accept_language(&req);
74 let headers = RequestHeaders {
75 cookie: cookie.as_deref(),
76 accept_language: accept_language.as_deref(),
77 };
78 let mut response_state = state.request_with_headers(&uri, headers).await;
79
80 let time = now.elapsed().as_millis();
81 let log_level = if time > 1000 {
82 log::Level::Warn
83 } else {
84 log::Level::Info
85 };
86 log::log!(
87 log_level,
88 "Response for request: {} {time}ms {uri}",
89 response_state.status,
90 );
91
92 if let Some(port_watch) = state.port_watch
93 && response_state.headers.get("content-type")
94 == Some(&ResponseState::HTML.to_string())
95 {
96 response_state.add_watch_script(port_watch);
97 }
98
99 if StatusCode::from_u16(response_state.status)
101 .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
102 .is_server_error()
103 {
104 log::error!("WASM status: {}", response_state.status);
105
106 match String::from_utf8(response_state.body.clone()) {
107 Ok(messagee) => {
108 log::error!("WASM response: text={}", messagee);
109 }
110 Err(_) => {
111 log::error!("WASM response: bytes={:#?}", response_state.body);
112 }
113 }
114 }
115
116 actix_web::HttpResponse::from(response_state)
117 }
118 })
119}
120
121pub fn is_ssr_fetch(req: &HttpRequest) -> bool {
150 req.headers().contains_key(SSR_FETCH_HEADER)
151}
152
153pub fn request_cookie(req: &HttpRequest) -> Option<String> {
158 let parts: Vec<&str> = req
159 .headers()
160 .get_all(header::COOKIE)
161 .filter_map(|value| value.to_str().ok())
162 .collect();
163
164 (!parts.is_empty()).then(|| parts.join("; "))
165}
166
167pub fn request_accept_language(req: &HttpRequest) -> Option<String> {
171 let parts: Vec<&str> = req
172 .headers()
173 .get_all(header::ACCEPT_LANGUAGE)
174 .filter_map(|value| value.to_str().ok())
175 .collect();
176
177 (!parts.is_empty()).then(|| parts.join(", "))
178}
179
180#[cfg(test)]
181mod tests {
182 use actix_web::{http::header, test::TestRequest};
183
184 use super::{is_ssr_fetch, request_accept_language, request_cookie};
185 use crate::serve::html::SSR_FETCH_HEADER;
186
187 #[test]
188 fn ssr_fetch_is_told_by_its_header() {
189 let ssr_fetch = TestRequest::get()
190 .append_header((SSR_FETCH_HEADER, "1"))
191 .to_http_request();
192
193 assert!(is_ssr_fetch(&ssr_fetch));
194 assert!(!is_ssr_fetch(&TestRequest::get().to_http_request()));
195 }
196
197 #[test]
198 fn no_cookie_header() {
199 assert_eq!(request_cookie(&TestRequest::get().to_http_request()), None);
200 }
201
202 #[test]
203 fn split_cookie_headers_are_joined() {
204 let req = TestRequest::get()
205 .append_header((header::COOKIE, "session=abc"))
206 .append_header((header::COOKIE, "theme=dark"))
207 .to_http_request();
208
209 assert_eq!(
210 request_cookie(&req).as_deref(),
211 Some("session=abc; theme=dark")
212 );
213 }
214
215 #[test]
216 fn split_accept_language_headers_are_one_list() {
217 let req = TestRequest::get()
218 .append_header((header::ACCEPT_LANGUAGE, "pl-PL,pl;q=0.9"))
219 .append_header((header::ACCEPT_LANGUAGE, "en;q=0.5"))
220 .to_http_request();
221
222 assert_eq!(
223 request_accept_language(&req).as_deref(),
224 Some("pl-PL,pl;q=0.9, en;q=0.5")
225 );
226 assert_eq!(
227 request_accept_language(&TestRequest::get().to_http_request()),
228 None
229 );
230 }
231}