waveless_runtime/
server.rs1use 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) .key_extractor(GlobalKeyExtractor) .finish()
65 .unwrap(),
66 );
67
68 let cache = CacheLayer::builder(InMemoryBackend::new(4096))
70 .ttl(Duration::from_secs(1)) .stale_while_revalidate(Duration::from_secs(1))
72 .build();
73
74 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) .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}