vertigo_cli/serve/
serve_run.rs

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