Skip to main content

waveless_runtime/
server.rs

1// Waveless
2// Copyright (C) 2026 Oscar Alvarez Gonzalez
3
4use crate::*;
5
6#[instrument(skip_all)]
7pub async fn serve(
8    addr: Option<SocketAddr>,
9    tls_paths: Option<(PathBuf, PathBuf)>,
10    frontend: Option<
11        BoxCloneService<
12            Request<BoxBody<ConnBytes, eyre::Error>>,
13            Response<BoxBody<ConnBytes, eyre::Error>>,
14            Infallible,
15        >,
16    >,
17) -> Result<ResultContext> {
18    let _build_lock = RuntimeCx::acquire().build();
19
20    let listener = tokio::net::TcpListener::bind(
21        addr.unwrap_or(
22            _build_lock
23                .read()
24                .await
25                .executor()
26                .listening_addr()
27                .ok_or(eyre!("No server address was provided."))?,
28        ),
29    )
30    .await
31    .unwrap();
32
33    let tls_acceptor = match tls_paths {
34        Some((cert_path, key_path))
35            if try_exists(cert_path.to_owned()).await?
36                && try_exists(key_path.to_owned()).await? =>
37        {
38            let cert = CertificateDer::pem_file_iter(cert_path)?.collect::<Result<Vec<_>, _>>()?;
39            let key = PrivateKeyDer::from_pem_file(key_path)?;
40
41            let mut tls_config = rustls::ServerConfig::builder()
42                .with_no_client_auth()
43                .with_single_cert(cert, key)?;
44
45            tls_config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
46
47            Some(TlsAcceptor::from(Arc::new(tls_config)))
48        }
49        _ => None,
50    };
51
52    info!(
53        "Executing '{}' on {} at {}",
54        _build_lock.read().await.config().name(),
55        listener.local_addr().unwrap(),
56        chrono::Local::now()
57    );
58
59    let governor_conf = std::sync::Arc::new(
60        GovernorConfigBuilder::default()
61            .per_second(1)
62            .burst_size(1000) // TODO: Make this a parameter in the 'project.toml'.
63            .key_extractor(GlobalKeyExtractor) // TODO: Change this setting to allow IP-based rate limiting.
64            .finish()
65            .unwrap(),
66    );
67
68    // TODO: A POST request to an endpoint invalidates the caches of the GET endpoints with the same route.
69    let cache = CacheLayer::builder(InMemoryBackend::new(4096))
70        .ttl(Duration::from_secs(1)) // TODO: Make this a parameter in the 'project.toml'.
71        .stale_while_revalidate(Duration::from_secs(1))
72        .build();
73
74    // Cleans up the governor key pool.
75    let governor_limiter = governor_conf.limiter().to_owned();
76    tokio::spawn(async move {
77        tokio::time::sleep(Duration::from_secs(30)).await;
78        debug!(
79            "Cleaning up rate's limiter storage (size: {})",
80            governor_limiter.len()
81        );
82        governor_limiter.retain_recent();
83    });
84
85    let governor = tower_governor::GovernorLayer::new(governor_conf).error_handler(|err| {
86        Response::builder()
87            .status(http::StatusCode::TOO_MANY_REQUESTS)
88            .header("Content-Type", "application/json")
89            .body(json_conn_body(&json!({
90                "error": err.to_compact_string()
91            })))
92            .unwrap()
93    });
94
95    let compression = CompressionLayer::new().compress_when(predicate::SizeAbove::new(2048));
96
97    let endpoint_svc = ServiceBuilder::new()
98        .layer(ExecuteWrapperLayer)
99        .layer(RequestExtractorLayer)
100        .layer(SessionWatchdogLayer)
101        .layer(UpgradeCaptureLayer)
102        .layer(AuthCaptureLayer)
103        .service(ExecuteHandler);
104
105    let router = services::RouterService::new(endpoint_svc, frontend);
106
107    let svc = ServiceBuilder::new()
108        .layer(cache)
109        .layer(compression)
110        .layer(CorsLayer::permissive())
111        .layer(TimeoutLayer::with_status_code(
112            http::StatusCode::REQUEST_TIMEOUT,
113            Duration::from_secs(10),
114        ))
115        .layer(governor) // Rate limiting does not apply for cached requests.
116        .service(router);
117
118    let svc = TowerToHyperService::new(svc);
119
120    loop {
121        let (stream, _) = listener.accept().await?;
122
123        let tls_acceptor = tls_acceptor.clone();
124
125        let io = TokioIo::new(match tls_acceptor {
126            Some(tls_acceptor) => match tls_acceptor.accept(stream).await {
127                Ok(tls_stream) => tokio_util::either::Either::Left(tls_stream),
128                Err(err) => {
129                    error!("TLS handshake failed. {}", err);
130                    continue;
131                }
132            },
133            None => tokio_util::either::Either::Right(stream),
134        });
135
136        let svc = svc.to_owned();
137
138        tokio::task::spawn(async move {
139            let mut auto_http_builder = AutoHttpBuilder::new(ConnExecutor);
140
141            auto_http_builder.http1().keep_alive(true);
142
143            if let Err(err) = auto_http_builder
144                .serve_connection_with_upgrades(io, svc)
145                .await
146            {
147                error!(
148                    "Internal error occurred while building a new connection handler: {:?}",
149                    err
150                );
151            }
152        });
153    }
154}