Skip to main content

rocket/
server.rs

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        // If this future is dropped before the response is ready, e.g. because
53        // the client disconnected, the request is spawned to run to completion,
54        // response fairings included, and its response is discarded. Either
55        // way, it's cancelled when the shutdown grace period ends, which is
56        // when I/O is cut off for clients that are still connected.
57        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        // TODO: Should upgrades be handled in dispatch?
63        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        // Send an empty HTTP/2 response as headers alone: h2 rejects a 304 with
78        // a nonzero content-length followed by an empty DATA frame. HTTP/1
79        // takes the body path because hyper otherwise drops that header.
80        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                // A connection upgraded by a `101` response belongs to its I/O
186                // handler, which may shut down writes and keep reading, so it
187                // must not linger.
188                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                // Accept request headers as large as hyper accepts for HTTP/2.
236                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                // The client may never let the control streams open, so stop
241                // waiting when shutdown starts.
242                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                        // The client sent `GOAWAY` and every request is done here.
251                        // As at shutdown, wait for it to close the connection.
252                        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                            // Send `GOAWAY` with the ID of the first request that
260                            // won't be processed (RFC 9114 ยง5.2): the one after the
261                            // last accepted. `accept()` isn't called again, so no
262                            // request at or above that ID is accepted. Only the
263                            // client knows when it has received every response, so
264                            // wait for it to close the connection.
265                            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                        // Limit the time to read headers as `serve12` does for HTTP/1.
278                        // The request was accepted before any `GOAWAY`, so it's
279                        // served if its headers arrive within the grace period.
280                        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                        // `service()` times out when the shutdown grace period ends.
293                        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                        // A body may wait indefinitely for data, so stop waiting when
301                        // the connection closes or the grace period ends.
302                        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        // Refuse new connections and give existing ones a chance to close.
313        // Waiting in a task lets shutdown fairings start now. The task holds
314        // on to `self`, so `try_wait_shutdown()` still waits for it.
315        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}