Allow passing through the 2nd ctrl+c

[kpcyrd]

I'm considering adding a ctrl+c handler, but since I'm only setting a bool it might take a while until my program is actually picking it up. The application would feel broken since it can not be terminated in a reliable way even after pressing ctrl+c multiple times. I'm thinking about 2 possible solutions:

• inside the signal handler, allow passing through the signal so if ctrl+c is pressed, I would first check the value of the boolean, if it is true I set it to false, if it is false, I let the signal pass and terminate the process
• allow removing the signal handler. Before I start an action that should be cancelable, I register a signal handler and if ctrl+c is pressed I'm setting the boolean to false and unregister the signal handler so that the second ctrl+c isn't caught anymore (Related to allow to reset the ctrlc handler #24)

Basically I'm looking for behavior similar to this (implementation doesn't need to be identical as long as the behavior is the same):

from time import sleep
try:
    try:
        print('running...')
        sleep(20)
    except KeyboardInterrupt:
        # requesting shutdown
        print('exiting...')
        sleep(5)
except KeyboardInterrupt:
    # kill application instantly
    pass

[Detegr]

Can you just kill the process yourself from your handler when entering the handler a second time?
Something like this results in a similar behaviour than your python example:

extern crate ctrlc;
use std::process;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::Duration;

fn main() {
    let running = Arc::new(AtomicUsize::new(0));
    let r = running.clone();
    ctrlc::set_handler(move || {
        let prev = r.fetch_add(1, Ordering::SeqCst);
        if prev == 0 {
            println!("Exiting...");
        } else {
            process::exit(0);
        }
    }).expect("Error setting Ctrl-C handler");
    println!("Running...");
    for _ in 1..6 {
        thread::sleep(Duration::from_secs(5));
        if running.load(Ordering::SeqCst) > 0 {
            break;
        }
    }
}