Skip to main content

rocket/
server.rs

1use std::io;
2use std::sync::Arc;
3use std::sync::atomic::{AtomicBool, Ordering};
4use std::time::Duration;
5use std::pin::{pin, Pin};
6
7use yansi::Paint;
8use bytes::Bytes;
9use tokio::sync::{mpsc, oneshot};
10use tokio::time::{sleep, sleep_until, Instant};
11use tokio_stream::wrappers::ReceiverStream;
12use futures::stream::StreamExt;
13use futures::future::{FutureExt, Future, BoxFuture};
14use http_body_util::{Either, Empty, StreamBody};
15use hyper_util::rt::TokioIo;
16
17#[cfg(feature = "http2")]
18use hyper_util::rt::{TokioExecutor, TokioTimer};
19#[cfg(feature = "http2")]
20use hyper_util::server::conn::auto::Builder;
21#[cfg(not(feature = "http2"))]
22use crate::http::hyper::server::conn::http1::Builder;
23
24use crate::{route, Rocket, Orbit, Request, Response, Data, Config};
25use crate::form::Form;
26use crate::outcome::Outcome;
27use crate::error::{Error, ErrorKind};
28use crate::ext::{AsyncReadExt, CancellableListener, LingeringIo};
29use crate::request::ConnectionMeta;
30use crate::data::IoHandler;
31
32use crate::http::{hyper, uncased, Method, Status, Header};
33use crate::http::hyper::body::Frame;
34use crate::http::private::{TcpListener, Listener, Connection, Incoming};
35
36// A token returned to force the execution of one method before another.
37pub(crate) struct RequestToken;
38
39type HttpBody = Either<
40    Empty<Bytes>,
41    StreamBody<ReceiverStream<io::Result<Frame<Bytes>>>>,
42>;
43
44async fn handle<Fut, T, F>(name: Option<&str>, run: F) -> Option<T>
45    where F: FnOnce() -> Fut, Fut: Future<Output = T>,
46{
47    use std::panic::AssertUnwindSafe;
48
49    macro_rules! panic_info {
50        ($name:expr, $e:expr) => {{
51            match $name {
52                Some(name) => error_!("Handler {} panicked.", name.primary()),
53                None => error_!("A handler panicked.")
54            };
55
56            info_!("This is an application bug.");
57            info_!("A panic in Rust must be treated as an exceptional event.");
58            info_!("Panicking is not a suitable error handling mechanism.");
59            info_!("Unwinding, the result of a panic, is an expensive operation.");
60            info_!("Panics will degrade application performance.");
61            info_!("Instead of panicking, return `Option` and/or `Result`.");
62            info_!("Values of either type can be returned directly from handlers.");
63            warn_!("A panic is treated as an internal server error.");
64            $e
65        }}
66    }
67
68    let run = AssertUnwindSafe(run);
69    let fut = std::panic::catch_unwind(move || run())
70        .map_err(|e| panic_info!(name, e))
71        .ok()?;
72
73    AssertUnwindSafe(fut)
74        .catch_unwind()
75        .await
76        .map_err(|e| panic_info!(name, e))
77        .ok()
78}
79
80// This function tries to hide all of the Hyper-ness from Rocket. It essentially
81// converts Hyper types into Rocket types, then calls the `dispatch` function,
82// which knows nothing about Hyper. Because responding depends on the
83// `HyperResponse` type, this function does the actual response processing.
84async fn hyper_service_fn(
85    rocket: Arc<Rocket<Orbit>>,
86    conn: ConnectionMeta,
87    upgraded: Arc<AtomicBool>,
88    mut hyp_req: hyper::Request<hyper::Body>,
89) -> Result<hyper::Response<HttpBody>, io::Error> {
90    // This future must return a hyper::Response, but the response body might
91    // borrow from the request. Instead, write the body in another future that
92    // sends the response metadata (and a body channel) prior.
93    let (tx, rx) = oneshot::channel();
94    let version = hyp_req.version();
95
96    #[cfg(not(broken_fmt))]
97    debug!("received request: {:#?}", hyp_req);
98
99    tokio::spawn(async move {
100        // We move the request next, so get the upgrade future now.
101        let pending_upgrade = hyper::upgrade::on(&mut hyp_req);
102
103        // Convert a Hyper request into a Rocket request.
104        let (h_parts, mut h_body) = hyp_req.into_parts();
105        match Request::from_hyp(&rocket, &h_parts, Some(conn)) {
106            Ok(mut req) => {
107                // Convert into Rocket `Data`, dispatch request, write response.
108                let mut data = Data::from(&mut h_body);
109                let token = rocket.preprocess_request(&mut req, &mut data).await;
110                let mut response = rocket.dispatch(token, &req, data).await;
111                let upgrade = response.take_upgrade(req.headers().get("upgrade"));
112                if let Ok(Some((proto, handler))) = upgrade {
113                    rocket.handle_upgrade(
114                        response, proto, handler, pending_upgrade, upgraded, tx, version
115                    ).await;
116                } else {
117                    if upgrade.is_err() {
118                        warn_!("Request wants upgrade but no I/O handler matched.");
119                        info_!("Request is not being upgraded.");
120                    }
121
122                    rocket.send_response(response, tx, version).await;
123                }
124            },
125            Err(e) => {
126                warn!("Bad incoming HTTP request.");
127                e.errors.iter().for_each(|e| warn_!("Error: {}.", e));
128                warn_!("Dispatching salvaged request to catcher: {}.", e.request);
129
130                let response = rocket.handle_error(Status::BadRequest, &e.request).await;
131                rocket.send_response(response, tx, version).await;
132            }
133        }
134    });
135
136    // Receive the response written to `tx` by the task above.
137    rx.await.map_err(|e| io::Error::new(io::ErrorKind::BrokenPipe, e))
138}
139
140impl Rocket<Orbit> {
141    /// Wrapper around `_send_response` to log a success or error.
142    #[inline]
143    async fn send_response(
144        &self,
145        response: Response<'_>,
146        tx: oneshot::Sender<hyper::Response<HttpBody>>,
147        version: hyper::Version,
148    ) {
149        let remote_hungup = |e: &io::Error| match e.kind() {
150            | io::ErrorKind::BrokenPipe
151            | io::ErrorKind::ConnectionReset
152            | io::ErrorKind::ConnectionAborted => true,
153            _ => false,
154        };
155
156        match self._send_response(response, tx, version).await {
157            Ok(()) => info_!("{}", "Response succeeded.".green()),
158            Err(e) if remote_hungup(&e) => warn_!("Remote left: {}.", e),
159            Err(e) => warn_!("Failed to write response: {}.", e),
160        }
161    }
162
163    /// Attempts to create a hyper response from `response` and send it to `tx`.
164    #[inline]
165    async fn _send_response(
166        &self,
167        mut response: Response<'_>,
168        tx: oneshot::Sender<hyper::Response<HttpBody>>,
169        version: hyper::Version,
170    ) -> io::Result<()> {
171        if response.headers().contains("Transfer-Encoding") {
172            response.remove_header("Content-Length");
173        } else if let Some(size) = response.body_mut().size().await {
174            response.set_raw_header("Content-Length", size.to_string());
175        }
176
177        let mut hyp_res = hyper::Response::builder();
178
179        hyp_res = hyp_res.status(response.status().code);
180        for header in response.headers().iter() {
181            let name = header.name.as_str();
182            let value = header.value.as_bytes();
183            hyp_res = hyp_res.header(name, value);
184        }
185
186        let send_headers = |body| {
187            let hyp_response = hyp_res.body(body)
188                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
189
190            #[cfg(not(broken_fmt))]
191            debug!("sending response: {:#?}", hyp_response);
192
193            tx.send(hyp_response).map_err(|_| {
194                let msg = "client disconnect before response started";
195                io::Error::new(io::ErrorKind::BrokenPipe, msg)
196            })
197        };
198
199        // Send empty HTTP/2 responses with just the headers. An empty DATA
200        // frame makes h2 reject a 304 with a nonzero Content-Length.
201        if version == hyper::Version::HTTP_2 && response.body().is_empty() {
202            return send_headers(Either::Left(Empty::new()));
203        }
204
205        // For HTTP/1, use a channel even without a body. Hyper otherwise
206        // removes Content-Length from 304 responses.
207        let (sender, receiver) = mpsc::channel(1);
208        let hyp_body = StreamBody::new(ReceiverStream::new(receiver));
209        send_headers(Either::Right(hyp_body))?;
210
211        let body = response.body_mut();
212        let max_chunk_size = body.max_chunk_size();
213        let mut stream = body.into_bytes_stream(max_chunk_size);
214        while let Some(next) = tokio::select! {
215            biased;
216            next = stream.next() => next,
217            _ = sender.closed() => return Err(io::Error::new(
218                io::ErrorKind::BrokenPipe, "client disconnect during response body"
219            )),
220        } {
221            let bytes = match next {
222                Ok(bytes) => bytes,
223                Err(e) => {
224                    // Send the error so Hyper aborts the response. Dropping the
225                    // sender would instead end the response successfully.
226                    let _ = sender.send(Err(io::Error::new(e.kind(), e.to_string()))).await;
227                    return Err(e);
228                }
229            };
230
231            sender.send(Ok(Frame::data(bytes))).await
232                .map_err(|e| io::Error::new(io::ErrorKind::BrokenPipe, e))?;
233        }
234
235        Ok(())
236    }
237
238    async fn handle_upgrade<'r>(
239        &self,
240        mut response: Response<'r>,
241        proto: uncased::Uncased<'r>,
242        io_handler: Pin<Box<dyn IoHandler + 'r>>,
243        pending_upgrade: hyper::upgrade::OnUpgrade,
244        upgraded: Arc<AtomicBool>,
245        tx: oneshot::Sender<hyper::Response<HttpBody>>,
246        version: hyper::Version,
247    ) {
248        info_!("Upgrading connection to {}.", Paint::white(&proto).bold());
249        response.set_status(Status::SwitchingProtocols);
250        response.set_raw_header("Connection", "Upgrade");
251        response.set_raw_header("Upgrade", proto.clone().into_cow());
252        self.send_response(response, tx, version).await;
253
254        match pending_upgrade.await {
255            Ok(io_stream) => {
256                info_!("Upgrade successful.");
257
258                // The connection now belongs to the I/O handler, which may
259                // shut down writes and keep reading. Don't linger on shutdown.
260                upgraded.store(true, Ordering::Release);
261                if let Err(e) = io_handler.io(io_stream.into()).await {
262                    if e.kind() == io::ErrorKind::BrokenPipe {
263                        warn!("Upgraded {} I/O handler was closed.", proto);
264                    } else {
265                        error!("Upgraded {} I/O handler failed: {}", proto, e);
266                    }
267                }
268            },
269            Err(e) => {
270                warn!("Response indicated upgrade, but upgrade failed.");
271                warn_!("Upgrade error: {}", e);
272            }
273        }
274    }
275
276    /// Preprocess the request for Rocket things. Currently, this means:
277    ///
278    ///   * Rewriting the method in the request if _method form field exists.
279    ///   * Run the request fairings.
280    ///
281    /// Keep this in-sync with derive_form when preprocessing form fields.
282    pub(crate) async fn preprocess_request(
283        &self,
284        req: &mut Request<'_>,
285        data: &mut Data<'_>
286    ) -> RequestToken {
287        // Check if this is a form and if the form contains the special _method
288        // field which we use to reinterpret the request's method.
289        let (min_len, max_len) = ("_method=get".len(), "_method=delete".len());
290        let peek_buffer = data.peek(max_len).await;
291        let is_form = req.content_type().map_or(false, |ct| ct.is_form());
292
293        if is_form && req.method() == Method::Post && peek_buffer.len() >= min_len {
294            let method = std::str::from_utf8(peek_buffer).ok()
295                .and_then(|raw_form| Form::values(raw_form).next())
296                .filter(|field| field.name == "_method")
297                .and_then(|field| field.value.parse().ok());
298
299            if let Some(method) = method {
300                req._set_method(method);
301            }
302        }
303
304        // Run request fairings.
305        self.fairings.handle_request(req, data).await;
306
307        RequestToken
308    }
309
310    #[inline]
311    pub(crate) async fn dispatch<'s, 'r: 's>(
312        &'s self,
313        _token: RequestToken,
314        request: &'r Request<'s>,
315        data: Data<'r>
316    ) -> Response<'r> {
317        info!("{}:", request);
318
319        // Remember if the request is `HEAD` for later body stripping.
320        let was_head_request = request.method() == Method::Head;
321
322        // Route the request and run the user's handlers.
323        let mut response = self.route_and_process(request, data).await;
324
325        // Add a default 'Server' header if it isn't already there.
326        // TODO: If removing Hyper, write out `Date` header too.
327        if let Some(ident) = request.rocket().config.ident.as_str() {
328            if !response.headers().contains("Server") {
329                response.set_header(Header::new("Server", ident));
330            }
331        }
332
333        // Run the response fairings.
334        self.fairings.handle_response(request, &mut response).await;
335
336        if response.status() == Status::NoContent {
337            // A 204 response must not have a body or either framing header.
338            response.remove_header("Content-Length");
339            response.remove_header("Transfer-Encoding");
340            *response.body_mut() = crate::response::Body::unsized_none();
341        } else if was_head_request || response.status() == Status::NotModified {
342            // HEAD and 304 responses have no body, but can have a length.
343            response.strip_body();
344        }
345
346        response
347    }
348
349    async fn route_and_process<'s, 'r: 's>(
350        &'s self,
351        request: &'r Request<'s>,
352        data: Data<'r>
353    ) -> Response<'r> {
354        let mut response = match self.route(request, data).await {
355            Outcome::Success(response) => response,
356            Outcome::Forward((data, _)) if request.method() == Method::Head => {
357                info_!("Autohandling {} request.", "HEAD".primary().bold());
358
359                // Dispatch the request again with Method `GET`.
360                request._set_method(Method::Get);
361                match self.route(request, data).await {
362                    Outcome::Success(response) => response,
363                    Outcome::Error(status) => self.handle_error(status, request).await,
364                    Outcome::Forward((_, status)) => self.handle_error(status, request).await,
365                }
366            }
367            Outcome::Forward((_, status)) => self.handle_error(status, request).await,
368            Outcome::Error(status) => self.handle_error(status, request).await,
369        };
370
371        // Set the cookies. Note that error responses will only include cookies
372        // set by the error handler. See `handle_error` for more.
373        let delta_jar = request.cookies().take_delta_jar();
374        for cookie in delta_jar.delta() {
375            response.adjoin_header(cookie);
376        }
377
378        response
379    }
380
381    /// Tries to find a `Responder` for a given `request`. It does this by
382    /// routing the request and calling the handler for each matching route
383    /// until one of the handlers returns success or error, or there are no
384    /// additional routes to try (forward). The corresponding outcome for each
385    /// condition is returned.
386    #[inline]
387    async fn route<'s, 'r: 's>(
388        &'s self,
389        request: &'r Request<'s>,
390        mut data: Data<'r>,
391    ) -> route::Outcome<'r> {
392        // Go through all matching routes until we fail or succeed or run out of
393        // routes to try, in which case we forward with the last status.
394        let mut status = Status::NotFound;
395        for route in self.router.route(request) {
396            // Retrieve and set the requests parameters.
397            info_!("Matched: {}", route);
398            request.set_route(route);
399
400            let name = route.name.as_deref();
401            let outcome = handle(name, || route.handler.handle(request, data)).await
402                .unwrap_or(Outcome::Error(Status::InternalServerError));
403
404            // Check if the request processing completed (Some) or if the
405            // request needs to be forwarded. If it does, continue the loop
406            // (None) to try again.
407            info_!("{}", outcome.log_display());
408            match outcome {
409                o@Outcome::Success(_) | o@Outcome::Error(_) => return o,
410                Outcome::Forward(forwarded) => (data, status) = forwarded,
411            }
412        }
413
414        error_!("No matching routes for {}.", request);
415        Outcome::Forward((data, status))
416    }
417
418    /// Invokes the handler with `req` for catcher with status `status`.
419    ///
420    /// In order of preference, invoked handler is:
421    ///   * the user's registered handler for `status`
422    ///   * the user's registered `default` handler
423    ///   * Rocket's default handler for `status`
424    ///
425    /// Return `Ok(result)` if the handler succeeded. Returns `Ok(Some(Status))`
426    /// if the handler ran to completion but failed. Returns `Ok(None)` if the
427    /// handler panicked while executing.
428    async fn invoke_catcher<'s, 'r: 's>(
429        &'s self,
430        status: Status,
431        req: &'r Request<'s>
432    ) -> Result<Response<'r>, Option<Status>> {
433        // For now, we reset the delta state to prevent any modifications
434        // from earlier, unsuccessful paths from being reflected in error
435        // response. We may wish to relax this in the future.
436        req.cookies().reset_delta();
437
438        if let Some(catcher) = self.router.catch(status, req) {
439            warn_!("Responding with registered {} catcher.", catcher);
440            let name = catcher.name.as_deref();
441            handle(name, || catcher.handler.handle(status, req)).await
442                .map(|result| result.map_err(Some))
443                .unwrap_or_else(|| Err(None))
444        } else {
445            let code = status.code.blue().bold();
446            warn_!("No {} catcher registered. Using Rocket default.", code);
447            Ok(crate::catcher::default_handler(status, req))
448        }
449    }
450
451    // Invokes the catcher for `status`. Returns the response on success.
452    //
453    // On catcher error, the 500 error catcher is attempted. If _that_ errors,
454    // the (infallible) default 500 error cather is used.
455    pub(crate) async fn handle_error<'s, 'r: 's>(
456        &'s self,
457        mut status: Status,
458        req: &'r Request<'s>
459    ) -> Response<'r> {
460        // Dispatch to the `status` catcher.
461        if let Ok(r) = self.invoke_catcher(status, req).await {
462            return r;
463        }
464
465        // If it fails and it's not a 500, try the 500 catcher.
466        if status != Status::InternalServerError {
467            error_!("Catcher failed. Attempting 500 error catcher.");
468            status = Status::InternalServerError;
469            if let Ok(r) = self.invoke_catcher(status, req).await {
470                return r;
471            }
472        }
473
474        // If it failed again or if it was already a 500, use Rocket's default.
475        error_!("{} catcher failed. Using Rocket default 500.", status.code);
476        crate::catcher::default_handler(Status::InternalServerError, req)
477    }
478
479    pub(crate) async fn default_tcp_http_server<C>(mut self, ready: C) -> Result<Self, Error>
480        where C: for<'a> Fn(&'a Self) -> BoxFuture<'a, ()>
481    {
482        use std::net::ToSocketAddrs;
483
484        // Determine the address we're going to serve on.
485        let addr = format!("{}:{}", self.config.address, self.config.port);
486        let mut addr = addr.to_socket_addrs()
487            .map(|mut addrs| addrs.next().expect(">= 1 socket addr"))
488            .map_err(|e| Error::new(ErrorKind::Io(e)))?;
489
490        #[cfg(feature = "tls")]
491        if self.config.tls_enabled() {
492            if let Some(ref config) = self.config.tls {
493                use crate::http::tls::TlsListener;
494
495                let conf = config.to_native_config().map_err(ErrorKind::Io)?;
496                let l = TlsListener::bind(addr, conf).await.map_err(ErrorKind::Bind)?;
497                addr = l.local_addr().unwrap_or(addr);
498                self.config.address = addr.ip();
499                self.config.port = addr.port();
500                ready(&mut self).await;
501                return self.http_server(l).await;
502            }
503        }
504
505        let l = TcpListener::bind(addr).await.map_err(ErrorKind::Bind)?;
506        addr = l.local_addr().unwrap_or(addr);
507        self.config.address = addr.ip();
508        self.config.port = addr.port();
509        ready(&mut self).await;
510        self.http_server(l).await
511    }
512
513    // TODO.async: Solidify the Listener APIs and make this function public
514    pub(crate) async fn http_server<L>(self, listener: L) -> Result<Self, Error>
515        where L: Listener + Send, <L as Listener>::Connection: Send + Unpin + 'static
516    {
517        // Emit a warning if we're not running inside of Rocket's async runtime.
518        if self.config.profile == Config::DEBUG_PROFILE {
519            tokio::task::spawn_blocking(|| {
520                let this  = std::thread::current();
521                if !this.name().map_or(false, |s| s.starts_with("rocket-worker")) {
522                    warn!("Rocket is executing inside of a custom runtime.");
523                    info_!("Rocket's runtime is enabled via `#[rocket::main]` or `#[launch]`.");
524                    info_!("Forced shutdown is disabled. Runtime settings may be suboptimal.");
525                }
526            });
527        }
528
529        // Set up cancellable I/O from the given listener. Shutdown occurs when
530        // `Shutdown` (`TripWire`) resolves. This can occur directly through a
531        // notification or indirectly through an external signal which, when
532        // received, results in triggering the notify.
533        let shutdown = self.shutdown();
534        let sig_stream = self.config.shutdown.signal_stream();
535        let grace = self.config.shutdown.grace as u64;
536        let mercy = self.config.shutdown.mercy as u64;
537
538        // Start a task that listens for external signals and notifies shutdown.
539        if let Some(mut stream) = sig_stream {
540            let shutdown = shutdown.clone();
541            tokio::spawn(async move {
542                while let Some(sig) = stream.next().await {
543                    if shutdown.0.tripped() {
544                        warn!("Received {}. Shutdown already in progress.", sig);
545                    } else {
546                        warn!("Received {}. Requesting shutdown.", sig);
547                    }
548
549                    shutdown.0.trip();
550                }
551            });
552        }
553
554        let rocket = Arc::new(self);
555        let listener = CancellableListener::new(shutdown.clone(), listener, grace, mercy);
556        let server = rocket.clone().serve(listener);
557
558        // This deserves some explanation.
559        //
560        // This is largely to deal with Hyper's dreadful and largely nonexistent
561        // handling of shutdown, in general, nevermind graceful.
562        //
563        // When Hyper receives a "graceful shutdown" request, it stops accepting
564        // new requests. That's it. It continues to process existing requests
565        // and outgoing responses forever and never cancels them. As a result,
566        // Rocket must take it upon itself to cancel any existing I/O.
567        //
568        // To do so, Rocket wraps all connections in a `CancellableIo` struct,
569        // an internal structure that gracefully closes I/O when it receives a
570        // signal. That signal is the `shutdown` future. When the future
571        // resolves, `CancellableIo` begins to terminate in grace, mercy, and
572        // finally force close phases. Since all connections are wrapped in
573        // `CancellableIo`, this eventually ends all I/O.
574        //
575        // At that point, unless a user spawned an infinite, stand-alone task
576        // that isn't monitoring `Shutdown`, all tasks should resolve. This
577        // means that all instances of the shared `Arc<Rocket>` are dropped and
578        // we can return the owned instance of `Rocket`.
579        //
580        // The accept loop, however, resolves as soon as shutdown is requested,
581        // without waiting for the connection tasks or their ongoing responses.
582        // That is, `server` resolves even when there are running tasks that are
583        // generating a response. So, `server` resolving implies little to
584        // nothing about the state of connections. As a result, we wait until
585        // all tasks are complete, thus all references to `Arc<Rocket>` are
586        // dropped and we can get a unique reference. Since all connections
587        // should be closed after grace + mercy, we wait at most grace + mercy +
588        // some buffer.
589        tokio::pin!(server);
590        tokio::select! {
591            biased;
592
593            _ = shutdown => {
594                // Run shutdown fairings. We compute `sleep()` for the timeout
595                // beforehand to ensure we don't add shutdown fairing completion
596                // time, which is arbitrary, to the grace and mercy periods.
597                info!("Shutdown requested. Waiting for pending I/O...");
598                let shutdown_timer = sleep(Duration::from_secs(grace + mercy + 1));
599                rocket.fairings.handle_shutdown(&*rocket).await;
600
601                tokio::pin!(shutdown_timer);
602                tokio::select! {
603                    biased;
604
605                    result = &mut server => {
606                        if let Err(e) = result {
607                            warn!("Server failed while shutting down: {}", e);
608                            return Err(Error::shutdown(rocket.clone(), e));
609                        }
610
611                        let deadline = shutdown_timer.deadline();
612                        while Arc::strong_count(&rocket) != 1 && Instant::now() < deadline {
613                            let next = Instant::now() + Duration::from_millis(10);
614                            sleep_until(next.min(deadline)).await;
615                        }
616
617                        match Arc::try_unwrap(rocket) {
618                            Ok(rocket) => {
619                                info!("Graceful shutdown completed successfully.");
620                                Ok(rocket)
621                            }
622                            Err(rocket) => {
623                                warn!("Shutdown failed: outstanding background I/O.");
624                                Err(Error::shutdown(rocket, None))
625                            }
626                        }
627                    }
628                    _ = &mut shutdown_timer => {
629                        warn!("Shutdown failed: server executing after timeouts.");
630                        return Err(Error::shutdown(rocket.clone(), None));
631                    },
632                }
633            }
634            result = &mut server => {
635                match result {
636                    Ok(()) => {
637                        info!("Server shutdown nominally.");
638                        Ok(Arc::try_unwrap(rocket).map_err(|r| Error::shutdown(r, None))?)
639                    }
640                    Err(e) => {
641                        info!("Server failed prior to shutdown: {}:", e);
642                        Err(Error::shutdown(rocket.clone(), e))
643                    }
644                }
645            }
646        }
647    }
648
649    async fn serve<L>(self: Arc<Self>, listener: L) -> io::Result<()>
650        where L: Listener + Send,
651              L::Connection: Send + Unpin + 'static
652    {
653        #[cfg(feature = "http2")]
654        let mut builder = Builder::new(TokioExecutor::new());
655        #[cfg(not(feature = "http2"))]
656        let mut builder = Builder::new();
657
658        #[cfg(feature = "http2")]
659        let mut http1 = builder.http1();
660        #[cfg(not(feature = "http2"))]
661        let http1 = &mut builder;
662
663        let keep_alive = self.config.keep_alive;
664        http1.keep_alive(keep_alive != 0)
665            .preserve_header_case(true)
666            .header_read_timeout(None);
667
668        #[cfg(feature = "http2")]
669        builder.http2()
670            .max_concurrent_streams(None)
671            .max_header_list_size(16 << 20)
672            .timer(TokioTimer::new())
673            .keep_alive_timeout(Duration::from_secs(20))
674            .keep_alive_interval(match keep_alive {
675                0 => None,
676                n => Some(Duration::from_secs(n as u64)),
677            });
678
679        let server = Arc::new(builder);
680        let linger = Duration::from_secs(self.config.linger as u64);
681        let incoming = Incoming::new(listener).nodelay(true).take_until(self.shutdown());
682        let mut incoming = pin!(incoming);
683
684        while let Some(conn) = incoming.next().await.transpose()? {
685            let (rocket, server) = (self.clone(), server.clone());
686            let shutdown = rocket.shutdown();
687            tokio::spawn(async move {
688                let connection = ConnectionMeta {
689                    remote: conn.peer_address(),
690                    client_certificates: conn.peer_certificates(),
691                };
692                let upgraded = Arc::new(AtomicBool::new(false));
693                let service = hyper::service::service_fn({
694                    let upgraded = upgraded.clone();
695                    move |req| {
696                        hyper_service_fn(rocket.clone(), connection.clone(), upgraded.clone(), req)
697                    }
698                });
699
700                let io = TokioIo::new(LingeringIo::new(conn, linger, upgraded));
701                #[cfg(feature = "http2")]
702                let mut server = pin!(server.serve_connection_with_upgrades(io, service));
703                #[cfg(not(feature = "http2"))]
704                let mut server = pin!(server.serve_connection(io, service).with_upgrades());
705
706                let result = tokio::select! {
707                    biased;
708                    _ = shutdown => {
709                        server.as_mut().graceful_shutdown();
710                        server.await
711                    },
712                    result = &mut server => result,
713                };
714
715                if let Err(e) = result {
716                    let e: Box<dyn std::error::Error + Send + Sync> = e.into();
717                    warn!("Connection failed: {}", e);
718                    let mut source = e.source();
719                    while let Some(e) = source {
720                        warn_!("Error: {}", e);
721                        source = e.source();
722                    }
723                }
724            });
725        }
726
727        Ok(())
728    }
729}