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::{MountConfig, html::SSR_FETCH_HEADER, response_state::ResponseState};
9
10use super::server_state::ServerState;
11
12pub 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 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 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 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
115pub 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}