Skip to main content

vertigo_cli/serve/
serve_run.rs

1use 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 the listener to free the port for actix
27                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    // By default through this server, so relative URLs hit `--proxy` like the browser's requests
67    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        // Already-encoded responses (what `install_proxy` forwards) carry a `Content-Encoding`
74        // and `Compress` leaves those alone.
75        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                        // `awc` decompresses the upstream body transparently, but
157                        // `into_http_response` copies the upstream headers across verbatim
158                        // so remove appropriate headers.
159                        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}