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