rust_asio 0.3.1

Asynchronous I/O library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use std::io;
use {IoObject, IoService, Handler};
use backbone::{RawFd, AsRawFd, IoActor, AsIoActor};
use backbone::ops::{cancel_io};
use backbone::signalfd::{sigset_t, signalfd_read, signalfd_async_read,
                         signalfd_init, signalfd_add, signalfd_del, signalfd_reset};

pub use backbone::signalfd::Signal;

pub struct SignalSet {
    io: IoActor,
    mask: sigset_t,
}

impl SignalSet {
    pub fn new<T: IoObject>(io: &T) -> io::Result<SignalSet> {
        let (fd, mask) = try!(signalfd_init());
        Ok(SignalSet {
            io: IoActor::new(io, fd),
            mask: mask,
        })
    }

    pub fn add(&mut self, signal: Signal) -> io::Result<()> {
        signalfd_add(&self.io, &mut self.mask, signal)
    }

    pub fn async_wait<F: Handler<Signal>>(&self, handler: F) {
        signalfd_async_read(self, handler)
    }

    pub fn cancel(&self) {
        cancel_io(self)
    }

    pub fn clear(&mut self) -> io::Result<()> {
        signalfd_reset(&self.io, &mut self.mask)
    }

    pub fn remove(&mut self, signal: Signal) -> io::Result<()> {
        signalfd_del(&self.io, &mut self.mask, signal)
    }

    pub fn wait(&self) -> io::Result<Signal> {
        signalfd_read(self)
    }
}

impl IoObject for SignalSet {
    fn io_service(&self) -> &IoService {
        self.io.io_service()
    }
}

impl AsRawFd for SignalSet {
    fn as_raw_fd(&self) -> RawFd {
        self.io.as_raw_fd()
    }
}

impl AsIoActor for SignalSet {
    fn as_io_actor(&self) -> &IoActor {
        &self.io
    }
}

impl Drop for SignalSet {
    fn drop(&mut self) {
        signalfd_reset(&self.io, &mut self.mask).unwrap();
    }
}

#[test]
fn test_signal_set() {
    use IoService;

    let io = &IoService::new();
    let mut sig = SignalSet::new(io).unwrap();
    sig.add(Signal::SIGHUP).unwrap();
    sig.add(Signal::SIGUSR1).unwrap();
    sig.remove(Signal::SIGUSR1).unwrap();
    sig.remove(Signal::SIGUSR2).unwrap();
}

#[test]
fn test_signal_set_wait() {
    use IoService;
    use libc;

    let io = &IoService::new();
    let mut sig = SignalSet::new(io).unwrap();
    sig.add(Signal::SIGHUP).unwrap();
    sig.add(Signal::SIGUSR1).unwrap();
    unsafe { libc::raise(libc::SIGHUP) };
    unsafe { libc::raise(libc::SIGUSR1) };
    assert_eq!(sig.wait().unwrap(), Signal::SIGHUP);
    assert_eq!(sig.wait().unwrap(), Signal::SIGUSR1);
}