Hyper 1.0.0-rc.3 - how to gracefully shutdown server connection after time delay?

[aaronriekenberg]

In a server using hyper 1.0.0-rc3, I want to shutdown incoming connections from clients after a time delay (say 2 minutes).

Based on this example which uses graceful_shutdown() on a server connection, I have roughly the below code. It seems to work as expected to close connections after time delay.

Some questions:

1. Suppose an in-flight request on this connection is in progress when the sleep time period elapses. Is calling conn.graceful_shutdown() sufficient to handle this? Does the conn need to be polled for events after this? The hyper documentation for graceful_shutdown says This Connection should continue to be polled until shutdown can finish - I am not certain what this means.

2. Is a loop needed around the tokio::select! to handle an in-flight request and resume polling the conn? Have been reading tokio select tutorial and trying to understand what is happening in detail here.

Below is a small snippet of my code.

Thanks!

        let service = service_fn(|hyper_request| {
            // logic to handle requests
        });

        let mut conn = hyper::server::conn::http1::Builder::new().serve_connection(stream, service);

        let mut conn = Pin::new(&mut conn);

        tokio::select! {
            res = &mut conn => {
                match res {
                    Ok(()) => debug!("after polling conn, no error"),
                    Err(e) =>  warn!("error serving connection: {:?}", e),
                }
            }
            _ = tokio::time::sleep(CONNECTION_MAX_LIFETIME_DURATION) => {
                info!("got timeout_interval, calling conn.graceful_shutdown");
                conn.graceful_shutdown();
            }
        }

[aaronriekenberg]

After more testing - have come up with below code:

1. When connection is first opened, wait for CONNECTION_MAX_LIFETIME_DURATION = 2 mins to time out connection
2. After CONNECTION_MAX_LIFETIME_DURATION call conn.graceful_shutdown()
3. Do a second loop on the tokio::select! in case of in-progress request when CONNECTION_MAX_LIFETIME_DURATION elapsed
4. Wait for CONNECTION_GRACEFUL_SHUTDOWN_DURATION = 5 seconds on second loop to give time for graceful shutdown

In tests have observed:

1. I can force an in-process request when the first iteration (2 minute timer) elapses, and the request finishes during the second iteration (5 second timer) - I see response returned successfully to the caller
2. If no in-flight request is in progress after the 2 minute timer elapses, on the second iteration through the loop polling conn returns Ok immediately.

I think this works well for my needs. Thanks for any inputs - hope this is a reasonable solution! 😄

Updated code in my application: https://github.com/aaronriekenberg/rust-hyper-server/blob/main/src/server/connection.rs#L103-L122

const CONNECTION_MAX_LIFETIME_DURATION: Duration = Duration::from_secs(120);

const CONNECTION_GRACEFUL_SHUTDOWN_DURATION: Duration = Duration::from_secs(5);

const CONNECTION_TIMEOUT_DURATIONS: &[Duration] = &[
    CONNECTION_MAX_LIFETIME_DURATION,
    CONNECTION_GRACEFUL_SHUTDOWN_DURATION,
];

let mut conn = HyperHTTP1Builder::new().serve_connection(stream, service);

let mut conn = Pin::new(&mut conn);

for (iter, sleep_duration) in CONNECTION_TIMEOUT_DURATIONS.iter().enumerate() {
    info!("iter = {} sleep_duration = {:?}", iter, sleep_duration);
    tokio::select! {
        res = conn.as_mut() => {
            match res {
                Ok(()) => info!("after polling conn, no error"),
                Err(e) =>  warn!("error serving connection: {:?}", e),
            };
            break;
        }
        _ = tokio::time::sleep(sleep_duration) => {
            info!("iter = {} got timeout_interval, calling conn.graceful_shutdown",iter);
            conn.as_mut().graceful_shutdown();
        }
    }
}