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