tokio/examples/ctrl-c.rs

extern crate futures;
extern crate tokio_core;
extern crate tokio_signal;

use futures::{Future, Stream};
use tokio_core::reactor::Core;

/// how many signals to handle before exiting
const STOP_AFTER: u64 = 10;

fn main() {
    // set up a Tokio event loop
    let mut core = Core::new().unwrap();

    // tokio_signal provides a convenience builder for Ctrl+C
    // this even works cross-platform: linux and windows!
    //
    // `fn ctrl_c()` produces a `Future` of the actual stream-initialisation
    // the `flatten_stream()` convenience method lazily defers that
    // initialisation, allowing us to use it 'as if' it is already the
    // stream we want, reducing boilerplate Future-handling.
    let endless_stream = tokio_signal::ctrl_c().flatten_stream();
    // don't keep going forever: convert the endless stream to a bounded one.
    let limited_stream = endless_stream.take(STOP_AFTER);

    // how many Ctrl+C have we received so far?
    let mut counter = 0;

    println!(
        "This program is now waiting for you to press Ctrl+C {0} times.
  * If running via `cargo run --example ctrl-c`, Ctrl+C also kills it, \
    due to https://github.com/rust-lang-nursery/rustup.rs/issues/806
  * If running the binary directly, the Ctrl+C is properly trapped.
    Terminate by repeating Ctrl+C {0} times, or ahead of time by \
    opening a second terminal and issuing `pkill -sigkil ctrl-c`",
        STOP_AFTER
    );

    // Stream::for_each is a powerful primitive provided by the Futures crate.
    // It turns a Stream into a Future that completes after all stream-items
    // have been completed, or the first time the closure returns an error
    let future = limited_stream.for_each(|()| {
        // Note how we manipulate the counter without any fancy synchronisation.
        // The borrowchecker realises there can't be any conflicts, so the closure
        // can just capture it.
        counter += 1;
        println!(
            "Ctrl+C received {} times! {} more before exit",
            counter,
            STOP_AFTER - counter
        );

        // return Ok-result to continue handling the stream
        Ok(())
    });

    // Up until now, we haven't really DONE anything, just prepared
    // now it's time to actually schedule, and thus execute, the stream
    // on our event loop
    core.run(future).unwrap();

    println!("Stream ended, quiting the program.");
}

#[cfg(test)]
// `Child::kill` terminates the application instead of sending the equivalent to SIGKILL on windows
#[cfg(unix)]
mod tests {
    use super::*;

    use std::env;
    use std::path::Path;
    use std::process::Command;

    #[test]
    fn ctrl_c() {
        let args = env::args().collect::<Vec<_>>();
        let ctrl_c_child = "ctrl_c_child";
        if args.len() >= 3 && args.last().map(|s| &s[..]) == Some(ctrl_c_child) {
            super::main();
        } else {
            let ctrl_c_path = Path::new("target")
                .join("debug")
                .join("examples")
                .join("ctrl-c");
            let mut child = Command::new(ctrl_c_path)
                .args(&["ctrl_c", "--nocapture", ctrl_c_child])
                .spawn()
                .unwrap();

            for i in 0..STOP_AFTER {
                println!("Kill {}", i);
                child.kill().unwrap();
            }
            child.wait().unwrap();
        }
    }
}