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?
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.