vertigo_cli/serve/
serve_run.rs1use actix_proxy::IntoHttpResponse;
2use actix_web::{
3 App, HttpRequest, HttpResponse, HttpServer,
4 dev::{ServiceFactory, ServiceRequest},
5 http::header,
6 middleware::{Compress, Condition},
7 rt::System,
8 web,
9};
10use std::{num::NonZeroUsize, time::Duration};
11
12use crate::commons::{
13 ErrorCode,
14 spawn::{ServerOwner, term_signal},
15};
16use crate::serve::{html::local_origin, http_client::http_client, mount_path::MountConfig};
17
18use super::{
19 ServeOpts, ServeOptsInner, server_state::ServerState, vertigo_install::vertigo_install,
20};
21
22async fn wait_for_port(addr: &str, port: u16) {
23 for i in 0..20 {
24 match std::net::TcpListener::bind(addr) {
25 Ok(listener) => {
26 drop(listener);
28 break;
29 }
30 Err(_) => {
31 log::warn!(
32 "Port {} is still in use, waiting 1s... ({}/20)",
33 port,
34 i + 1
35 );
36 tokio::time::sleep(Duration::from_secs(1)).await;
37 }
38 }
39 }
40}
41
42pub async fn run(opts: ServeOpts, port_watch: Option<u16>) -> Result<(), ErrorCode> {
43 log::info!("serve params => {opts:#?}");
44
45 let ServeOptsInner {
46 host,
47 port,
48 proxy,
49 mount_point,
50 env,
51 wasm_preload,
52 disable_hydration,
53 ssr_fetch_base,
54 pretty_html,
55 disable_compression,
56 threads,
57 } = opts.inner;
58
59 let mut mount_config = MountConfig::new(
60 mount_point,
61 opts.common.dest_dir,
62 env,
63 wasm_preload,
64 disable_hydration,
65 )?;
66 mount_config.ssr_fetch_base = Some(ssr_fetch_base.unwrap_or_else(|| local_origin(&host, port)));
68 mount_config.pretty_html = pretty_html;
69
70 ServerState::init_with_watch(&mount_config, port_watch)?;
71
72 let app = move || {
73 let mut app = App::new().wrap(Condition::new(!disable_compression, Compress::default()));
76
77 for (path, target) in &proxy {
78 app = install_proxy(app, path.clone(), target.clone());
79 }
80
81 app.configure(|cfg| {
82 vertigo_install(cfg, &mount_config);
83 })
84 };
85
86 let addr = format!("{host}:{port}");
87
88 wait_for_port(&addr, port).await;
89
90 let server =
91 HttpServer::new(app)
92 .workers(threads.unwrap_or_else(|| {
93 std::thread::available_parallelism().map_or(2, NonZeroUsize::get)
94 }))
95 .bind(addr.clone())
96 .map_err(|err| {
97 log::error!("Can't bind/serve on {addr}: {err}");
98 ErrorCode::ServeCantOpenPort
99 })?;
100
101 let server = server
102 .disable_signals()
103 .client_disconnect_timeout(Duration::from_secs(2))
104 .shutdown_timeout(5)
105 .run();
106
107 let handle = server.handle();
108 let handle2 = server.handle();
109
110 std::thread::spawn(move || System::new().block_on(server));
111
112 tokio::select! {
113 _ = ServerOwner { handle } => {},
114 msg = term_signal() => {
115 log::info!("{msg} received, shutting down");
116 handle2.stop(false).await;
117 }
118 }
119
120 Ok(())
121}
122
123fn install_proxy<T>(app: App<T>, path: String, target: String) -> App<T>
124where
125 T: ServiceFactory<ServiceRequest, Config = (), Error = actix_web::Error, InitError = ()>,
126{
127 app.service(web::scope(&path).default_service(web::to({
128 move |req: HttpRequest, body: web::Bytes| {
129 let path = path.clone();
130 let target = target.clone();
131 async move {
132 let method = req.method();
133 let uri = req.uri();
134 let current_path = uri.path();
135 let tail = current_path.strip_prefix(&path).unwrap_or(current_path);
136 let query = uri.query().map(|q| format!("?{}", q)).unwrap_or_default();
137
138 let target_url = format!("{target}{tail}{query}");
139
140 log::info!("proxy {method} {path}{tail} -> {target_url}");
141
142 let request = http_client().request_from(&target_url, req.head());
143
144 let response = if !body.is_empty() {
145 request.send_body(body)
146 } else {
147 request.send()
148 };
149
150 match response.await {
151 Ok(response) => {
152 let mut response = response.into_http_response();
153
154 let headers = response.headers_mut();
155
156 if headers.remove(header::CONTENT_ENCODING).next().is_some() {
160 headers.remove(header::CONTENT_LENGTH);
161 }
162
163 response
164 }
165 Err(error) => {
166 let message = format!("Error fetching from url={target_url} error={error}");
167 HttpResponse::InternalServerError().body(message)
168 }
169 }
170 }
171 }
172 })))
173}