How do I gracefully shutdown the Tokio runtime in response to a SIGTERM?

Question

I have a main function, where I create a Tokio runtime and run two futures on it.

use tokio;

fn main() {
    let mut runtime = tokio::runtime::Runtime::new().unwrap();

    runtime.spawn(MyMegaFutureNumberOne {});
    runtime.spawn(MyMegaFutureNumberTwo {});

    // Some code to 'join' them after receiving an OS signal
}

How do I receive a SIGTERM, wait for all unfinished tasks (NotReadys) and exit the application?

Not familiar enough with Tokio or signal handling to answer, but there's a [`tokio_signal`](https://github.com/tokio-rs/tokio/tree/master/tokio-signal) library in the main Tokio repo - perhaps that's one piece of the puzzle? — Joe Clay, Nov 24 '18 at 20:10
Based on your question's construction, an answer that shows how to do this without involving `SIGTERM` would not be accepted, correct? — Shepmaster, Nov 25 '18 at 15:36
Afaik, Linux server applications are usually stopped with an OS signal like SIGTERM (if you use systemctl or service) or SIGINT (from the terminal if it is running in one), so it is an idiomatic way. Therefore, signal handling is strongly preferred. Maybe it has something to do with the Runtime's shutdown_on_idle method, but I have no idea how to call it after handling a signal — hedgar2017, Nov 25 '18 at 17:49

score 11 · Accepted Answer · edited Nov 27 '18 at 19:21

Dealing with signals is tricky and it would be too broad to explain how to handle all possible cases. The implementation of signals is not standard across platforms, so my answer is specific to Linux. If you want to be more cross-platform, use the POSIX function sigaction combined with pause; this will offer you more control.

One way to achieve what you want is to use the tokio_signal crate to catch signals, like this: (doc example)

extern crate futures;
extern crate tokio;
extern crate tokio_signal;

use futures::prelude::*;
use futures::Stream;
use std::time::{Duration, Instant};
use tokio_signal::unix::{Signal, SIGINT, SIGTERM};

fn main() -> Result<(), Box<::std::error::Error>> {
    let mut runtime = tokio::runtime::Runtime::new()?;

    let sigint = Signal::new(SIGINT).flatten_stream();
    let sigterm = Signal::new(SIGTERM).flatten_stream();

    let stream = sigint.select(sigterm);

    let deadline = tokio::timer::Delay::new(Instant::now() + Duration::from_secs(5))
        .map(|()| println!("5 seconds are over"))
        .map_err(|e| eprintln!("Failed to wait: {}", e));

    runtime.spawn(deadline);

    let (item, _rest) = runtime
        .block_on_all(stream.into_future())
        .map_err(|_| "failed to wait for signals")?;

    let item = item.ok_or("received no signal")?;
    if item == SIGINT {
        println!("received SIGINT");
    } else {
        assert_eq!(item, SIGTERM);
        println!("received SIGTERM");
    }

    Ok(())
}

This program will wait for all current tasks to complete and will catch the selected signals. This doesn't seem to work on Windows as it instantly shuts down the program.

score 2 · Answer 2 · answered Sep 01 '21 at 07:06

2

The other answer is for Tokio version 0.1.x, which is very old. For Tokio version 1.x.y, the official Tokio tutorial has a page on this topic: Graceful shutdown

answered Sep 01 '21 at 07:06

Alice Ryhl

2,618
1
17
28

Thanks for the answer! At least when reading this today, the link suggested: `signal::ctrl_c()` Looking at the code, it seems to react to `SIGINT` on Unix system instead of `SIGTERM` like in the original question. This might be important on Kubernetes or similar. Waiting for `SIGTERM` would be something like: `tokio::signal::unix::signal(SignalKind::terminate()).unwrap().recv().await` – Peter Kolloch Mar 14 '22 at 16:59

How do I gracefully shutdown the Tokio runtime in response to a SIGTERM?

2 Answers2

Linked