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, 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        disable_compression,
55        threads,
56    } = opts.inner;
57
58    let mut mount_config = MountConfig::new(
59        mount_point,
60        opts.common.dest_dir,
61        env,
62        wasm_preload,
63        disable_hydration,
64    )?;
65    // By default through this server, so relative URLs hit `--proxy` like the browser's requests
66    mount_config.ssr_fetch_base = Some(ssr_fetch_base.unwrap_or_else(|| local_origin(&host, port)));
67
68    ServerState::init_with_watch(&mount_config, port_watch)?;
69
70    let app = move || {
71        // Already-encoded responses (what `install_proxy` forwards) carry a `Content-Encoding`
72        // and `Compress` leaves those alone.
73        let mut app = App::new().wrap(Condition::new(!disable_compression, Compress::default()));
74
75        for (path, target) in &proxy {
76            app = install_proxy(app, path.clone(), target.clone());
77        }
78
79        app.configure(|cfg| {
80            vertigo_install(cfg, &mount_config);
81        })
82    };
83
84    let addr = format!("{host}:{port}");
85
86    wait_for_port(&addr, port).await;
87
88    let server =
89        HttpServer::new(app)
90            .workers(threads.unwrap_or_else(|| {
91                std::thread::available_parallelism().map_or(2, NonZeroUsize::get)
92            }))
93            .bind(addr.clone())
94            .map_err(|err| {
95                log::error!("Can't bind/serve on {addr}: {err}");
96                ErrorCode::ServeCantOpenPort
97            })?;
98
99    let server = server
100        .disable_signals()
101        .client_disconnect_timeout(Duration::from_secs(2))
102        .shutdown_timeout(5)
103        .run();
104
105    let handle = server.handle();
106    let handle2 = server.handle();
107
108    std::thread::spawn(move || System::new().block_on(server));
109
110    tokio::select! {
111        _ = ServerOwner { handle } => {},
112        msg = term_signal() => {
113            log::info!("{msg} received, shutting down");
114            handle2.stop(false).await;
115        }
116    }
117
118    Ok(())
119}
120
121fn install_proxy<T>(app: App<T>, path: String, target: String) -> App<T>
122where
123    T: ServiceFactory<ServiceRequest, Config = (), Error = actix_web::Error, InitError = ()>,
124{
125    app.service(web::scope(&path).default_service(web::to({
126        move |req: HttpRequest, body: web::Bytes| {
127            let path = path.clone();
128            let target = target.clone();
129            async move {
130                let method = req.method();
131                let uri = req.uri();
132                let current_path = uri.path();
133                let tail = current_path.strip_prefix(&path).unwrap_or(current_path);
134                let query = uri.query().map(|q| format!("?{}", q)).unwrap_or_default();
135
136                let target_url = format!("{target}{tail}{query}");
137
138                log::info!("proxy {method} {path}{tail} -> {target_url}");
139
140                let request = awc::Client::new().request_from(&target_url, req.head());
141
142                let response = if !body.is_empty() {
143                    request.send_body(body)
144                } else {
145                    request.send()
146                };
147
148                match response.await {
149                    Ok(response) => {
150                        let mut response = response.into_http_response();
151
152                        let headers = response.headers_mut();
153
154                        // `awc` decompresses the upstream body transparently, but
155                        // `into_http_response` copies the upstream headers across verbatim
156                        // so remove appropriate headers.
157                        if headers.remove(header::CONTENT_ENCODING).next().is_some() {
158                            headers.remove(header::CONTENT_LENGTH);
159                        }
160
161                        response
162                    }
163                    Err(error) => {
164                        let message = format!("Error fetching from url={target_url} error={error}");
165                        HttpResponse::InternalServerError().body(message)
166                    }
167                }
168            }
169        }
170    })))
171}