Lib.rs

Adapter of Linux' signalfd to be used with [mio] 0.7

use std::{thread, time::Duration};
use std::error::Error;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};

use mio::{Events, Interest, Poll, Token};
use pakr_signals::{Pid, Sig, SigSet};

use pakr_mio_signalfd::*;

const TOK: Token = Token(0);

fn main() -> Result<(), Box<dyn Error>> {
    const SIGS: &[Sig] = &[Sig::USR2, Sig::USR1, Sig::QUIT];

    // SigSet we are working with
    let sigs = SigSet::from(SIGS);

    // Make completion flags to be shared between threads
    let done = Arc::new(AtomicBool::new(false));
    let cdone = done.clone();

    // Disable default hadlers of signals we play with
    sigs.disable_default_handler()?;

    // Spawn background thread that will (slowny) bomb our process with signals
    let bomber = thread::spawn(move || {
        // Get my own PID
        let my_pid = Pid::own().unwrap();

        // Repeat some times
        for _ in 0..2 {
            // For each signal on the list
            for &sig in SIGS {
                // Sleep a second
                thread::sleep(Duration::from_secs(1));

                println!("Sending {:?}", sig);

                //  ... then self-send signal
                sig.send_to(my_pid).unwrap();
            }
        }
        // Tell we're done
        cdone.store(true, Ordering::Relaxed)
    });

    // Create a poll instance.
    let mut poll = Poll::new()?;

    // Create storage for events.
    let mut events = Events::with_capacity(128);

    // Create instance of signal watcher
    let mut watcher = SignalFd::new(&sigs)?;

    // Register watcher in mio registry. This handle is readable only
    poll.registry().register(
        &mut watcher,
        TOK,
        Interest::READABLE,
    )?;

    // Repeat while not told done
    while !done.load(Ordering::Relaxed) {

        // Poll Mio for events, blocking until we get an event or timeout on 3s.
        poll.poll(&mut events, Some(Duration::from_secs(3)))?;

        // Process each event.
        for event in events.iter() {
            // We can use the token we previously provided to `register` to
            // determine for which socket the event is.
            match event.token() {
                TOK => {
                    println!("Handled event");
                    while let Some(siginfo) = watcher.read()? {
                        println!("Got signal {:?}", Sig::from(siginfo.ssi_signo as i32));
                    }
                    println!("---");
                }

                // We don't expect any events with tokens other than those we provided.
                _ => { println!("Other event"); }
            }
        }
    }

    // Join with bomber thread
    bomber.join().unwrap();

    // Re-enable default handlers
    sigs.enable_default_handler()?;

    // We're done
    Ok(())
}