#async #graceful #shutdown

graceful-shutdown

Graceful Shutdown for async code

2 unstable releases

0.2.0 Nov 15, 2022
0.1.0 Feb 8, 2021

#1027 in Asynchronous

Download history 568/week @ 2023-08-17 793/week @ 2023-08-24 520/week @ 2023-08-31 711/week @ 2023-09-07 642/week @ 2023-09-14 560/week @ 2023-09-21 409/week @ 2023-09-28 1115/week @ 2023-10-05 819/week @ 2023-10-12 1656/week @ 2023-10-19 2278/week @ 2023-10-26 4625/week @ 2023-11-02 3756/week @ 2023-11-09 2268/week @ 2023-11-16 2534/week @ 2023-11-23 2697/week @ 2023-11-30

12,398 downloads per month
Used in 6 crates (via apalis-core)

Apache-2.0

21KB
294 lines

A library to make it easier to handle graceful shutdowns in async code.

This provides tools to wait for pending tasks to complete before finalizing shutdown.

Examples

use graceful_shutdown::Shutdown;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio::signal;
use tokio::{select, spawn};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let shutdown = Shutdown::new();
    let listener = TcpListener::bind("127.0.0.1:8000").await?;
    spawn(shutdown.shutdown_after(signal::ctrl_c()));
    loop {
       match shutdown.cancel_on_shutdown(listener.accept()).await {
           Some(Ok((mut conn, _))) => {
               spawn(shutdown.graceful(async move {
                   let mut buf = [0; 1024];
                   loop {
                       let n = match conn.read(&mut buf).await {
                           Ok(n) if n == 0 => return,
                           Ok(n) => n,
                           Err(e) => {
                               eprintln!("failed to read from socket; err = {:?}", e);
                               return;
                           }
                       };
                       if let Err(e) = conn.write_all(&buf[0..n]).await {
                           eprintln!("failed to write to socket; err = {:?}", e);
                           return;
                       }
                   }
               }));
           }
           Some(Err(e)) => {
               eprintln!("Error accepting connection; err = {:?}", e);
               shutdown.shutdown();
           }
           None => {
               eprintln!("Starting shutdown");
               break;
           }
       }
    }
    shutdown.await;
    Ok(())
}

Dependencies

~0–11MB
~107K SLoC