Skip to content

Commit 0dfdff2

Browse files
alexregalexreg
committed
More clean-up.
1 parent d244fa3 commit 0dfdff2

File tree

4 files changed

+57
-50
lines changed

4 files changed

+57
-50
lines changed

‎README.md

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,14 +4,15 @@ A simple wrapper for handling Unix process signals.
44
## Example Usage
55
```rust
66
extern crate simple_signal;
7-
use simple_signal::{Signals, Signal};
7+
8+
use simple_signal::{self, Signal};
89
use std::sync::atomic::{AtomicBool, Ordering};
910
use std::sync::Arc;
1011

1112
fn main() {
1213
let running = Arc::new(AtomicBool::new(true));
1314
let r = running.clone();
14-
Signals::set_handler(&[Signal::Int, Signal::Term], move |_signals| {
15+
simple_signal::set_handler(&[Signal::Int, Signal::Term], move |_signals| {
1516
r.store(false, Ordering::SeqCst);
1617
});
1718
println!("Waiting for a signal...");

‎examples/readme_example.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
11
extern crate simple_signal;
22

3-
use simple_signal::{Signals, Signal};
3+
use simple_signal::{Signal};
4+
use std::sync::{Arc};
45
use std::sync::atomic::{AtomicBool, Ordering};
5-
use std::sync::Arc;
66

77
fn main() {
88
let running = Arc::new(AtomicBool::new(true));
99
let r = running.clone();
10-
Signals::set_handler(&[Signal::Int, Signal::Term], move |_signals| {
10+
simple_signal::set_handler(&[Signal::Int, Signal::Term], move |_signals| {
1111
r.store(false, Ordering::SeqCst);
1212
});
1313
println!("Waiting for a signal...");

‎examples/simple.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,11 +2,11 @@
22

33
extern crate simple_signal;
44

5-
use simple_signal::{Signals, Signal};
5+
use simple_signal::{Signal};
66
use std::thread;
77

88
fn main() {
9-
Signals::set_handler(&[Signal::Int, Signal::Term], |signals| println!("Caught: {:?}", signals));
9+
simple_signal::set_handler(&[Signal::Int, Signal::Term], |signals| println!("Caught: {:?}", signals));
1010
loop {
1111
thread::yield_now();
1212
}

‎src/lib.rs

Lines changed: 49 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
//! A simple easy to use wrapper around unix signals.
1+
//! A simple wrapper for handling Unix process signals.
22
33
#![cfg_attr(feature="nightly", feature(static_condvar))]
44
#![cfg_attr(feature="nightly", feature(static_mutex))]
@@ -8,6 +8,7 @@
88
extern crate lazy_static;
99

1010
use std::sync::atomic::Ordering;
11+
use std::thread;
1112

1213
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
1314
pub enum Signal {
@@ -32,6 +33,7 @@ mod features {
3233
pub static MUTEX: StaticMutex = MUTEX_INIT;
3334
pub static MASK: AtomicUsize = ATOMIC_USIZE_INIT;
3435
}
36+
3537
#[cfg(not(feature="nightly"))]
3638
mod features {
3739
use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
@@ -42,13 +44,16 @@ mod features {
4244
}
4345
pub static MASK: AtomicUsize = ATOMIC_USIZE_INIT;
4446
}
47+
4548
use self::features::*;
4649

4750
#[cfg(unix)]
4851
mod platform {
4952
extern crate libc;
53+
5054
use self::libc::{c_int, signal, sighandler_t};
5155
use self::libc::{SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGABRT, SIGFPE, SIGKILL, SIGSEGV, SIGPIPE, SIGALRM, SIGTERM};
56+
use std::mem;
5257
use std::sync::atomic::Ordering;
5358
use super::Signal;
5459

@@ -72,11 +77,12 @@ mod platform {
7277
let prev_mask = super::features::MASK.load(Ordering::Relaxed);
7378
let new_mask = prev_mask | mask;
7479
if super::features::MASK.compare_and_swap(prev_mask, new_mask, Ordering::Relaxed) == new_mask {
75-
break
80+
break;
7681
}
7782
}
7883
super::features::CVAR.notify_all();
7984
}
85+
8086
#[inline]
8187
pub unsafe fn set_os_handler(sig: Signal) {
8288
let os_sig = match sig {
@@ -93,58 +99,58 @@ mod platform {
9399
Signal::Term => SIGTERM,
94100
};
95101

96-
signal(os_sig, ::std::mem::transmute::<_, sighandler_t>(handler as extern "C" fn(_)));
102+
signal(os_sig, mem::transmute::<_, sighandler_t>(handler as extern "C" fn(_)));
97103
}
98104
}
99105

100106
use self::platform::*;
101107

102-
pub struct Signals;
103-
impl Signals {
104-
/// Sets up some signals handler
105-
/// # Example
106-
/// ```
107-
/// use simple_signal::{Signals, Signal};
108-
/// Signals::set_handler(&[Signal::Int, Signal::Term], |signals| println!("Caught: {:?}", signals));
109-
/// ```
110-
pub fn set_handler<F>(signals: &[Signal], user_handler: F) where F: Fn(&[Signal]) + 'static + Send {
111-
for &signal in signals.iter() {
112-
unsafe { set_os_handler(signal) }
113-
}
114-
::std::thread::spawn(move || {
115-
let mut signals = Vec::new();
116-
loop {
117-
let mask = MASK.load(Ordering::Relaxed);
118-
if mask == 0 {
119-
let _ = CVAR.wait(MUTEX.lock().unwrap());
120-
continue
121-
}
122-
signals.clear();
123-
if mask & 1 != 0 { signals.push(Signal::Hup) }
124-
if mask & 2 != 0 { signals.push(Signal::Int) }
125-
if mask & 4 != 0 { signals.push(Signal::Quit) }
126-
if mask & 8 != 0 { signals.push(Signal::Ill) }
127-
if mask & 16 != 0 { signals.push(Signal::Abrt) }
128-
if mask & 32 != 0 { signals.push(Signal::Fpe) }
129-
if mask & 64 != 0 { signals.push(Signal::Kill) }
130-
if mask & 128 != 0 { signals.push(Signal::Segv) }
131-
if mask & 256 != 0 { signals.push(Signal::Pipe) }
132-
if mask & 512 != 0 { signals.push(Signal::Alrm) }
133-
if mask & 1024 != 0 { signals.push(Signal::Term) }
134-
MASK.store(0, Ordering::Relaxed);
135-
user_handler(&signals);
136-
}
137-
});
108+
/// Sets up a signal handler.
109+
///
110+
/// # Example
111+
/// ```
112+
/// use simple_signal::{self, Signal};
113+
/// simple_signal::set_handler(&[Signal::Int, Signal::Term], |signals| println!("Caught: {:?}", signals));
114+
/// ```
115+
pub fn set_handler<F>(signals: &[Signal], user_handler: F) where F: Fn(&[Signal]) + 'static + Send {
116+
for &signal in signals.iter() {
117+
unsafe { set_os_handler(signal) }
138118
}
119+
thread::spawn(move || {
120+
let mut signals = Vec::new();
121+
loop {
122+
let mask = MASK.load(Ordering::Relaxed);
123+
if mask == 0 {
124+
let _ = CVAR.wait(MUTEX.lock().unwrap());
125+
thread::yield_now();
126+
continue;
127+
}
128+
signals.clear();
129+
if mask & 1 != 0 { signals.push(Signal::Hup) }
130+
if mask & 2 != 0 { signals.push(Signal::Int) }
131+
if mask & 4 != 0 { signals.push(Signal::Quit) }
132+
if mask & 8 != 0 { signals.push(Signal::Ill) }
133+
if mask & 16 != 0 { signals.push(Signal::Abrt) }
134+
if mask & 32 != 0 { signals.push(Signal::Fpe) }
135+
if mask & 64 != 0 { signals.push(Signal::Kill) }
136+
if mask & 128 != 0 { signals.push(Signal::Segv) }
137+
if mask & 256 != 0 { signals.push(Signal::Pipe) }
138+
if mask & 512 != 0 { signals.push(Signal::Alrm) }
139+
if mask & 1024 != 0 { signals.push(Signal::Term) }
140+
MASK.store(0, Ordering::Relaxed);
141+
user_handler(&signals);
142+
}
143+
});
139144
}
140145

141146
#[cfg(test)]
142147
mod test {
143148
extern crate libc;
149+
144150
use std::sync::mpsc::sync_channel;
145151
use self::libc::c_int;
146152
use self::libc::{SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGABRT, SIGFPE, SIGKILL, SIGSEGV, SIGPIPE, SIGALRM, SIGTERM};
147-
use super::{Signal, Signals};
153+
use super::{Signal};
148154
use super::platform::handler;
149155

150156
fn to_os_signal(signal: Signal) -> c_int {
@@ -167,13 +173,13 @@ mod test {
167173
fn all_signals() {
168174
let signals = [Signal::Hup, Signal::Int, Signal::Quit, Signal::Abrt, Signal::Term];
169175
let (tx, rx) = sync_channel(0);
170-
Signals::set_handler(&signals, move |signals| tx.send(signals.to_owned()).unwrap());
171-
// check one by one
176+
super::set_handler(&signals, move |signals| tx.send(signals.to_owned()).unwrap());
177+
// Check all signals one-by-one.
172178
for &signal in signals.iter() {
173179
handler(to_os_signal(signal));
174180
assert_eq!(rx.recv().unwrap(), vec![signal]);
175181
}
176-
// check all simultaneously
182+
// Check all signals simultaneously.
177183
for &signal in signals.iter() {
178184
handler(to_os_signal(signal))
179185
}

0 commit comments

Comments
 (0)