vertigo_cli/serve/
serve_run.rs1use axum::{
2 body::BoxBody,
3 extract::{Json, RawQuery},
4 http::{header::HeaderMap, HeaderValue, StatusCode, Uri},
5 response::Response,
6 routing::get,
7 Router,
8};
9use reqwest::header;
10use serde_json::Value;
11use std::time::{Duration, Instant};
12use tower_http::services::ServeDir;
13
14use crate::serve::mount_path::MountPathConfig;
15use crate::{
16 commons::ErrorCode,
17 serve::{server_state::ServerState, ServeOptsInner},
18};
19use axum::body::Body;
20
21use super::ServeOpts;
22
23pub async fn run(opts: ServeOpts, port_watch: Option<u16>) -> Result<(), ErrorCode> {
24 log::info!("serve params => {opts:#?}");
25
26 let ServeOptsInner {
27 host,
28 port,
29 proxy,
30 mount_point,
31 env,
32 wasm_preload,
33 disable_hydration,
34 } = opts.inner;
35
36 let mount_config = MountPathConfig::new(
37 mount_point,
38 opts.common.dest_dir,
39 wasm_preload,
40 disable_hydration,
41 )?;
42
43 ServerState::init(mount_config.clone(), port_watch, env)?;
44
45 let serve_mount_path = mount_config.dest_http_root();
46 let serve_dir = ServeDir::new(mount_config.dest_dir());
47
48 let mut app = Router::new()
49 .nest_service(&serve_mount_path, serve_dir)
50 .layer(axum::middleware::map_response(set_cache_header));
51
52 for (path, target) in proxy {
53 app = install_proxy(app, path, target);
54 }
55
56 let app = app.fallback(handler);
57
58 let Ok(addr) = format!("{host}:{port}").parse() else {
59 log::error!("Incorrect listening address");
60 return Err(ErrorCode::ServeCantOpenPort);
61 };
62
63 let ret = axum::Server::bind(&addr)
64 .serve(app.into_make_service())
65 .await;
66
67 if let Err(err) = ret {
68 log::error!("Can't bind/serve on {addr}: {err}");
69 Err(ErrorCode::ServeCantOpenPort)
70 } else {
71 log::info!("Listening on http://{addr}");
72 Ok(())
73 }
74}
75
76async fn get_response(target_url: String) -> Response<BoxBody> {
77 let response = match reqwest::get(target_url.clone()).await {
78 Ok(response) => response,
79 Err(error) => {
80 let message = format!("Error fetching from url={target_url} error={error}");
81
82 let mut response = message.into_response();
83 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
84
85 return response;
86 }
87 };
88
89 let headers = response.headers().clone();
90 let status = response.status();
91 let body = match response.bytes().await {
92 Ok(body) => body.to_vec(),
93 Err(error) => {
94 let message = format!("Error fetching body from url={target_url} error={error}");
95
96 let mut response = message.into_response();
97 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
98
99 return response;
100 }
101 };
102
103 use axum::response::IntoResponse;
104 let mut response: Response<BoxBody> = body.into_response();
105
106 *response.headers_mut() = headers;
107 *response.status_mut() = status;
108
109 response
110}
111
112async fn post_response(target_url: String, headers: HeaderMap, body: Value) -> Response<BoxBody> {
113 let client = reqwest::Client::new();
114
115 let Ok(body) = serde_json::to_vec(&body)
116 .inspect_err(|err| log::error!("Error serializing request body: {err}"))
117 else {
118 let mut resp = Response::default();
119 *resp.status_mut() = StatusCode::from_u16(600).unwrap_or_default();
120 return resp;
121 };
122
123 let response = match client
124 .post(target_url.clone())
125 .headers(headers)
126 .body(body)
127 .send()
128 .await
129 {
130 Ok(response) => response,
131 Err(error) => {
132 let message = format!("Error fetching from url={target_url} error={error}");
133
134 let mut response = message.into_response();
135 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
136
137 return response;
138 }
139 };
140
141 let headers = response.headers().clone();
142 let status = response.status();
143 let body = match response.bytes().await {
144 Ok(body) => body.to_vec(),
145 Err(error) => {
146 let message = format!("Error fetching body from url={target_url} error={error}");
147
148 let mut response = message.into_response();
149 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
150
151 return response;
152 }
153 };
154
155 use axum::response::IntoResponse;
156 let mut response: Response<BoxBody> = body.into_response();
157
158 *response.headers_mut() = headers;
159 *response.status_mut() = status;
160
161 response
162}
163
164fn install_proxy(app: Router<()>, path: String, target: String) -> Router<()> {
165 let router = Router::new().fallback(
166 get({
167 let path = path.clone();
168 let target = target.clone();
169
170 move |url: Uri| async move {
171 let from_url = format!("{path}{url}");
172 let target_url = format!("{target}{url}");
173 log::info!("proxy get {from_url} -> {target_url}");
174
175 get_response(target_url).await
176 }
177 })
178 .post({
179 let path = path.clone();
180
181 move |url: Uri, headers: HeaderMap, body: Json<Value>| async move {
182 let from_url = format!("{path}{url}");
183 let target_url = format!("{target}{url}");
184 let Json(body) = body;
185 log::info!("proxy post {from_url} -> {target_url}");
186
187 post_response(target_url, headers, body).await
188 }
189 }),
190 );
191
192 app.nest_service(path.as_str(), router)
193}
194
195#[axum::debug_handler]
196async fn handler(url: Uri, RawQuery(query): RawQuery) -> Response<Body> {
197 let state = ServerState::global();
198
199 let now = Instant::now();
200 let uri = {
201 let local_url = if state.mount_config.mount_point() != "/" {
203 url.path()
204 .trim_start_matches(state.mount_config.mount_point())
205 } else {
206 url.path()
207 };
208
209 match query {
210 Some(query) => format!("{local_url}?{query}"),
211 None => local_url.to_string(),
212 }
213 };
214
215 log::debug!("Incoming request: {uri}");
216 let mut response_state = state.request(&uri).await;
217
218 let time = now.elapsed();
219 log::log!(
220 if time > Duration::from_secs(1) {
221 log::Level::Warn
222 } else {
223 log::Level::Info
224 },
225 "Response for request: {} {}ms {url}",
226 response_state.status,
227 time.as_millis()
228 );
229
230 if let Some(port_watch) = state.port_watch {
231 response_state.add_watch_script(port_watch);
232 }
233
234 if StatusCode::from_u16(response_state.status)
235 .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
236 .is_server_error()
237 {
238 log::error!("WASM status: {}", response_state.status);
239
240 match String::from_utf8(response_state.body.clone()) {
241 Ok(messagee) => {
242 log::error!("WASM response: text={}", messagee);
243 }
244 Err(_) => {
245 log::error!("WASM response: bytes={:#?}", response_state.body);
246 }
247 }
248 }
249
250 response_state.into()
251}
252
253async fn set_cache_header<B: Send>(mut response: Response<B>) -> Response<B> {
254 response.headers_mut().insert(
255 header::CACHE_CONTROL,
256 HeaderValue::from_static("public, max-age=31536000"),
257 );
258 response
259}