vertigo_cli/serve/
serve_run.rs

1use 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        // Strip mount point to get local url
221        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}