1use std::io;
2use std::pin::pin;
3use std::sync::Arc;
4use std::sync::atomic::{AtomicBool, Ordering};
5use std::time::Duration;
6
7use hyper::service::service_fn;
8use hyper_util::rt::{TokioExecutor, TokioIo, TokioTimer};
9use hyper_util::server::conn::auto::Builder;
10use futures::{Future, TryFutureExt};
11use tokio::io::{AsyncRead, AsyncWrite};
12use tracing::Instrument;
13
14use crate::{Ignite, Orbit, Request, Rocket};
15use crate::request::ConnectionMeta;
16use crate::erased::{ErasedRequest, ErasedResponse, ErasedIoHandler};
17use crate::listener::{Listener, Connection, BouncedExt, CancellableExt, Lingering};
18use crate::error::log_server_error;
19use crate::data::{IoStream, RawStream};
20use crate::util::{spawn_inspect, Detach, FutureExt, ReaderStream};
21use crate::trace::{Trace, TraceAll};
22
23type Result<T, E = crate::Error> = std::result::Result<T, E>;
24
25impl Rocket<Orbit> {
26 #[tracing::instrument("request", skip_all, fields(
27 method = %parts.method,
28 uri = %parts.uri,
29 autohandled
30 ))]
31 async fn service<T: for<'a> Into<RawStream<'a>> + Send + 'static>(
32 self: Arc<Self>,
33 parts: http::request::Parts,
34 stream: T,
35 upgrade: Option<hyper::upgrade::OnUpgrade>,
36 connection: ConnectionMeta,
37 ) -> io::Result<hyper::Response<ReaderStream<ErasedResponse>>> {
38 connection.trace_debug();
39 let version = parts.version;
40 let grace = self.shutdown.grace.clone();
41 let request = ErasedRequest::new(self, parts, |rocket, parts| {
42 Request::from_hyp(rocket, parts, connection).unwrap_or_else(|e| e)
43 });
44
45 span_debug!("request headers" => request.inner().headers().iter().trace_all_debug());
46 let response = request.into_response(
47 stream,
48 |rocket, request, data| Box::pin(rocket.preprocess(request, data)),
49 |token, rocket, request, data| Box::pin(rocket.dispatch(token, request, data))
50 );
51
52 let response = Detach::new(response.race(grace).in_current_span());
58 let Some(mut response) = response.await.left() else {
59 return Err(io::Error::new(io::ErrorKind::TimedOut, "shutdown grace period elapsed"));
60 };
61
62 response.inner().trace_info();
64 span_debug!("response headers" => response.inner().headers().iter().trace_all_debug());
65 let io_handler = response.make_io_handler(Rocket::extract_io_handler);
66 if let (Some((proto, handler)), Some(upgrade)) = (io_handler, upgrade) {
67 let upgrade = upgrade.map_ok(IoStream::from).map_err(io::Error::other);
68 tokio::task::spawn(io_handler_task(proto, upgrade, handler));
69 }
70
71 let mut builder = hyper::Response::builder();
72 builder = builder.status(response.inner().status().code);
73 for header in response.inner().headers().iter() {
74 builder = builder.header(header.name().as_str(), header.value());
75 }
76
77 if version == http::Version::HTTP_2 && response.inner().body().is_empty() {
81 return builder.body(ReaderStream::empty(response)).map_err(io::Error::other);
82 }
83
84 let chunk_size = response.inner().body().max_chunk_size();
85 builder.body(ReaderStream::with_capacity(response, chunk_size)).map_err(io::Error::other)
86 }
87}
88
89#[tracing::instrument("upgrade", skip_all, fields(protocol = proto))]
90async fn io_handler_task<S>(proto: String, stream: S, mut handler: ErasedIoHandler)
91 where S: Future<Output = io::Result<IoStream>>
92{
93 let stream = match stream.await {
94 Ok(stream) => stream,
95 Err(e) => return warn!(error = %e, "i/o upgrade failed"),
96 };
97
98 debug!("i/o upgrade succeeded");
99 if let Err(e) = handler.take().io(stream).await {
100 match e.kind() {
101 io::ErrorKind::BrokenPipe => warn!("i/o handler closed"),
102 _ => warn!(error = %e, "i/o handler terminated unsuccessfully"),
103 }
104 }
105}
106
107impl Rocket<Ignite> {
108 pub(crate) async fn listen_and_serve<L, R>(
109 self,
110 listener: L,
111 orbit_callback: impl FnOnce(Rocket<Orbit>) -> R,
112 ) -> Result<Arc<Rocket<Orbit>>>
113 where L: Listener + 'static,
114 R: Future<Output = Result<Arc<Rocket<Orbit>>>>
115 {
116 let endpoint = listener.endpoint()?;
117
118 #[cfg(feature = "http3-preview")]
119 if let (Some(addr), Some(tls)) = (endpoint.tcp(), endpoint.tls_config()) {
120 use crate::error::ErrorKind;
121
122 let quic = crate::listener::quic::bind(addr, tls)
123 .map_err(|e| ErrorKind::Bind(Some(endpoint.clone()), Box::new(e)))
124 .await?;
125
126 let quic_endpoint = crate::listener::Endpoint::Quic(quic.local_addr()?).with_tls(tls);
127 let rocket = self.into_orbit(vec![quic_endpoint, endpoint]);
128 let rocket = orbit_callback(rocket).await?;
129
130 let http12 = tokio::task::spawn(rocket.clone().serve12(listener));
131 let http3 = tokio::task::spawn(rocket.clone().serve3(quic));
132 let (r1, r2) = futures::join!(http12, http3);
133 r1.map_err(|e| ErrorKind::Liftoff(Err(rocket.clone()), e))??;
134 r2.map_err(|e| ErrorKind::Liftoff(Err(rocket.clone()), e))??;
135 return Ok(rocket);
136 }
137
138 if cfg!(feature = "http3-preview") {
139 warn!("HTTP/3 cannot start without a valid TCP + TLS configuration.\n\
140 Falling back to HTTP/1 + HTTP/2 server.");
141 }
142
143 let rocket = self.into_orbit(vec![endpoint]);
144 let rocket = orbit_callback(rocket).await?;
145 rocket.clone().serve12(listener).await?;
146 Ok(rocket)
147 }
148}
149
150impl Rocket<Orbit> {
151 pub(crate) async fn serve12<L>(self: Arc<Self>, listener: L) -> Result<()>
152 where L: Listener + 'static,
153 L::Connection: AsyncRead + AsyncWrite
154 {
155 let mut builder = Builder::new(TokioExecutor::new());
156 let keep_alive = Duration::from_secs(self.config.keep_alive.into());
157 builder.http1()
158 .timer(TokioTimer::new())
159 .keep_alive(keep_alive > Duration::ZERO)
160 .preserve_header_case(true)
161 .header_read_timeout(Duration::from_secs(15));
162
163 #[cfg(feature = "http2")] {
164 builder.http2().timer(TokioTimer::new());
165 if keep_alive > Duration::ZERO {
166 builder.http2()
167 .timer(TokioTimer::new())
168 .keep_alive_interval(keep_alive / 4)
169 .keep_alive_timeout(keep_alive);
170 }
171 }
172
173 let linger = Duration::from_secs(self.config.linger.into());
174 let (listener, server) = (Arc::new(listener.bounced()), Arc::new(builder));
175 while let Some(accept) = listener.accept().race(self.shutdown()).await.left().transpose()? {
176 let (listener, rocket, server) = (listener.clone(), self.clone(), server.clone());
177 spawn_inspect(|e| log_server_error(&**e), async move {
178 let conn = listener.connect(accept).race_io(rocket.shutdown()).await?;
179 let meta = ConnectionMeta::new(
180 conn.endpoint(),
181 conn.certificates(),
182 conn.server_name()
183 );
184
185 let upgraded = Arc::new(AtomicBool::new(false));
189 let service = service_fn(|mut req| {
190 let upgrade = hyper::upgrade::on(&mut req);
191 let (parts, incoming) = req.into_parts();
192 let upgraded = upgraded.clone();
193 rocket.clone().service(parts, incoming, Some(upgrade), meta.clone())
194 .inspect_ok(move |response| {
195 if response.status() == http::StatusCode::SWITCHING_PROTOCOLS {
196 upgraded.store(true, Ordering::Release);
197 }
198 })
199 });
200
201 let io = conn.cancellable(rocket.shutdown.clone());
202 let io = TokioIo::new(Lingering::new(io, linger, upgraded.clone()));
203 let mut server = pin!(server.serve_connection_with_upgrades(io, service));
204 match server.as_mut().race(rocket.shutdown()).await.left() {
205 Some(result) => result,
206 None => {
207 server.as_mut().graceful_shutdown();
208 server.await
209 },
210 }
211 });
212 }
213
214 Ok(())
215 }
216
217 #[cfg(feature = "http3-preview")]
218 async fn serve3(self: Arc<Self>, endpoint: quinn::Endpoint) -> Result<()> {
219 use std::future::IntoFuture;
220 use std::io::ErrorKind::TimedOut;
221 use either::Either;
222 use crate::listener::{Endpoint, quic::{self, QuicRx, QuicTx}};
223
224 while let Some(Some(incoming)) = endpoint.accept().race(self.shutdown()).await.left() {
225 let rocket = self.clone();
226 spawn_inspect(quic::log_error, async move {
227 let conn = match incoming.into_future().race(rocket.shutdown()).await {
228 Either::Left(conn) => conn.map_err(io::Error::other)?,
229 Either::Right(_) => return Ok(()),
230 };
231
232 let remote = Endpoint::Quic(conn.remote_address()).assume_tls();
233 let (certs, sni) = (quic::certificates(&conn), quic::server_name(&conn));
234 let meta = ConnectionMeta::new(Ok(remote), certs, sni.as_deref());
235 let mut builder = h3::server::builder();
237 let h3 = builder.max_field_section_size(16 * 1024)
238 .build(h3_quinn::Connection::new(conn.clone()));
239
240 let mut h3: quic::Connection = match h3.race(rocket.shutdown()).await {
243 Either::Left(h3) => h3.map_err(io::Error::other)?,
244 Either::Right(_) => return Ok(()),
245 };
246
247 loop {
248 let resolver = match h3.accept().race(rocket.shutdown()).await {
249 Either::Left(Ok(Some(resolver))) => resolver,
250 Either::Left(Ok(None)) => {
253 conn.closed().race(rocket.shutdown.grace.clone()).await;
254 break;
255 }
256 Either::Left(Err(e)) if e.is_h3_no_error() => break,
257 Either::Left(Err(e)) => return Err(io::Error::other(e)),
258 Either::Right(_) => {
259 let grace = rocket.shutdown.grace.clone();
266 if let Either::Left(sent) = h3.shutdown(1).race(grace.clone()).await {
267 sent.map_err(io::Error::other)?;
268 conn.closed().race(grace).await;
269 }
270
271 break;
272 }
273 };
274
275 let (rocket, meta, conn) = (rocket.clone(), meta.clone(), conn.clone());
276 spawn_inspect(quic::log_error, async move {
277 let headers = resolver.resolve_request();
281 let headers = tokio::time::timeout(Duration::from_secs(15), headers);
282 let grace = rocket.shutdown.grace.clone();
283 let (req, stream) = match headers.race(grace).await {
284 Either::Left(Ok(headers)) => headers.map_err(io::Error::other)?,
285 Either::Left(Err(e)) => return Err(io::Error::new(TimedOut, e)),
286 Either::Right(_) => return Ok(()),
287 };
288
289 let (tx, rx) = stream.split();
290 let mut tx = QuicTx::new(tx, rocket.shutdown.grace.clone());
291 let rx = QuicRx(rx).cancellable(rocket.shutdown.clone());
292 let service = rocket.clone().service(req.into_parts().0, rx, None, meta);
294 let response = match service.await {
295 Ok(response) => response,
296 Err(e) if e.kind() == TimedOut => return Ok(()),
297 Err(e) => return Err(e),
298 };
299
300 let stop = rocket.shutdown.grace.clone().race(conn.closed());
303 let response = quic::send_response(&mut tx, response).race(stop).await;
304 response.left().unwrap_or(Ok(()))
305 });
306 }
307
308 Ok(())
309 });
310 }
311
312 endpoint.set_server_config(None);
316 tokio::spawn(async move {
317 endpoint.wait_idle().race(self.shutdown.mercy.clone()).await;
318 });
319
320 Ok(())
321 }
322}