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 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 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 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
122pub 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
136pub 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}