Function notify

pub fn notify(signals: &[Signal]) -> Receiver<Signal>

Create a new channel subscribed to the given signals.

The channel returned is never closed.

This is a convenience function for subscribing to multiple signals at once. See the documentation of notify_on for details.

The channel returned has a small buffer to prevent signals from being dropped.

THIS MUST BE CALLED BEFORE ANY OTHER THREADS ARE SPAWNED IN YOUR PROCESS.

Example

use chan_signal::Signal;

let signal = chan_signal::notify(&[Signal::INT, Signal::TERM]);

// Blocks until this process is sent an INT or TERM signal.
// Since the channel is never closed, we can unwrap the received value.
signal.recv().unwrap();

Examples found in repository

examples/simple.rs (line 11)

fn main() {
    let signal = notify(&[Signal::INT]);
    println!("Send a INT signal my way!");
    // block until we get a signal
    assert_eq!(signal.recv(), Some(Signal::INT));
    println!("Thanks :]");
}

examples/sleep.rs (line 10)

fn main() {
    let signal = notify(&[Signal::INT]);
    println!("Send a INT signal my way!");
    thread::spawn(move || thread::sleep(Duration::from_secs(10)));
    // block until we get a signal
    assert_eq!(signal.recv(), Some(Signal::INT));
    println!("Thanks :]");
}

examples/test_block_specific.rs (line 8)

fn main() {
    let r_usr1 = chan_signal::notify(&[Signal::USR1, Signal::ALRM]);
    kill_this(Signal::USR1);
    kill_this(Signal::ALRM);
    assert_eq!(r_usr1.recv(), Some(Signal::USR1));
    assert_eq!(r_usr1.recv(), Some(Signal::ALRM));

    let (s, r_usr2) = chan::sync(1);
    chan_signal::notify_on(&s, Signal::USR2);
    kill_this(Signal::USR2);
    assert_eq!(r_usr2.recv(), Some(Signal::USR2));

    // The following will terminate the process, as it is NOT blocked
    // by the main thread.
    kill_this(Signal::TERM);
    unreachable!();
}

examples/select.rs (line 12)

fn main() {
    // Signal gets a value when the OS sent a INT or TERM signal.
    let signal = chan_signal::notify(&[Signal::INT, Signal::TERM]);
    // When our work is complete, send a sentinel value on `sdone`.
    let (sdone, rdone) = chan::sync(0);
    // Run work.
    thread::spawn(move || run(sdone));

    // Wait for a signal or for work to be done.
    chan_select! {
        signal.recv() -> signal => {
            println!("received signal: {:?}", signal)
        },
        rdone.recv() => {
            println!("Program completed normally.");
        }
    }
}

examples/read_names.rs (line 29)

fn main() {
    // It is imperative that we start listening for signals as soon as
    // possible. In particular, if `notify` is called after another thread
    // has spawned, then signal masking won't be applied to it and signal
    // handling won't work.
    //
    // See "Signal mask and pending signals" section of signal(7).
    let signal = notify(&[Signal::INT, Signal::TERM]);
    match run(signal) {
        Ok(mut names) => {
            names.sort();
            println!("You entered {} names: {}",
                     names.len(), names.connect(", "));
        }
        Err(err) => {
            writeln!(&mut io::stderr(), "{}", err).unwrap();
            process::exit(1);
        }
    }
}