Struct mio_signals::Signals

pub struct Signals { /* fields omitted */ }

Notification of process signals.

Notes

On Android and Linux this will block all signals in the signal set given when creating Signals, using sigprocmask(2). This means that the program is not interrupted, or in any way notified of signal until the assiocated Poll is polled.

On platforms that support kqueue(2) the signal handler action is set to SIG_IGN using sigaction(2), meaning that all signals will be ignored. Same as on Linux based systems; the program is not interrupted, or in any way notified of signal until the assiocated Poll is polled.

Implementation notes

On platforms that support kqueue(2) this will use the EVFILT_SIGNAL event filter. On Android and Linux it uses signalfd(2).

Examples

use std::io;

use mio::{Poll, Events, Interest, Token};
use mio_signals::{Signals, Signal, SignalSet};

const SIGNAL: Token = Token(10);

fn main() -> io::Result<()> {
    let mut poll = Poll::new()?;
    let mut events = Events::with_capacity(128);

    // Create a `Signals` instance that will catch signals for us.
    let mut signals = Signals::new(SignalSet::all())?;
    // And register it with our `Poll` instance.
    poll.registry().register(&mut signals, SIGNAL, Interest::READABLE)?;

    loop {
        poll.poll(&mut events, None)?;

        for event in events.iter() {
            match event.token() {
                // Because we're using edge triggers (default in Mio) we need
                // to keep calling `receive` until it returns `Ok(None)`.
                SIGNAL => loop {
                    match signals.receive()? {
                        Some(Signal::Interrupt) => println!("Got interrupt signal"),
                        Some(Signal::Terminate) => println!("Got terminate signal"),
                        Some(Signal::Quit) => println!("Got quit signal"),
                        None => break,
                    }
                },
                _ => println!("Got unexpected event: {:?}", event),
            }
        }
    }
}

Methods

impl Signals

pub fn new(signals: SignalSet) -> Result<Signals>

Create a new signal notifier.

pub fn receive(&mut self) -> Result<Option<Signal>>

Receive a signal, if any.

If no signal is available this returns Ok(None).

Trait Implementations

impl Debug for Signals

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Source for Signals

fn register(
    &mut self,
    registry: &Registry,
    token: Token,
    interests: Interest
) -> Result<()>

Register self with the given Registry instance.

fn reregister(
    &mut self,
    registry: &Registry,
    token: Token,
    interests: Interest
) -> Result<()>

Re-register self with the given Registry instance.

fn deregister(&mut self, registry: &Registry) -> Result<()>

Deregister self from the given Registry instance.