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::{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}