Added SyncChannel and split into modules

SyncChannel can be a lazily created as statics to give to signal
handlers which can use them to signal events have occurred to the
main program thread.

Author: kitsuneninetails

Cargo.toml

@@ -5,3 +5,6 @@ authors = ["Michael Micucci <[email protected]>"]
 
 [dependencies]
 libc = "*"
+
+[dev-dependencies]
+lazy_static = "*"

src/channel.rs

@@ -0,0 +1,94 @@
+use std::sync::mpsc::{Sender, Receiver, channel, TryRecvError};
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub enum ChannelError {
+    SyncError(String),
+    SendError,
+    RecvError,
+    
+}
+
+pub struct SyncChannel<T> {
+    _s: Arc<Mutex<Sender<T>>>,
+    _r: Arc<Mutex<Receiver<T>>>
+}
+
+impl<T> SyncChannel<T> {
+    pub fn new() -> Self {
+        let (s, r) = channel::<T>();
+        SyncChannel { _s: Arc::new(Mutex::new(s)), _r: Arc::new(Mutex::new(r)) }
+    }
+    
+    pub fn send(&self, data: T) -> Result<(), ChannelError> {
+        self._s.lock()
+            .map_err(|e| { ChannelError::SyncError(format!("Mutex poisoned: {:?}", e)) })?
+            .send(data)
+            .map_err(|_| { ChannelError::SendError })
+    }
+    
+    pub fn recv(&self) -> Result<T, ChannelError> {
+        self._r.lock()
+            .map_err(|e| { ChannelError::SyncError(format!("Mutex poisoned: {:?}", e)) })?
+            .recv()
+            .map_err(|_| { ChannelError::RecvError })
+    }
+    
+    pub fn try_recv(&self) -> Result<Option<T>, ChannelError> {
+        match self._r.lock()
+            .map_err(|e| { ChannelError::SyncError(format!("Mutex poisoned: {:?}", e)) })?
+            .try_recv() {
+            
+            Err(TryRecvError::Empty) => Ok(None),
+            Err(_) => Err(ChannelError::RecvError),
+            Ok(d) => Ok(Some(d))
+        }
+        
+    }
+}
+
+impl<T> Clone for SyncChannel<T> {
+    fn clone(&self) -> Self {
+        SyncChannel {
+            _r: self._r.clone(),
+            _s: self._s.clone(),
+        }
+    }
+}
+unsafe impl<T> Send for SyncChannel<T> {}
+unsafe impl<T> Sync for SyncChannel<T> {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::thread;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    
+    #[test]
+    fn test_channels() {
+        let ch: SyncChannel<i32> = SyncChannel::new();
+        let ch_clone = ch.clone();
+        thread::spawn(move || {
+            ch_clone.send(3)
+        });
+        assert_eq!(ch.recv().unwrap(), 3);
+    }
+    
+    #[test]
+    fn test_channels_try_recv() {
+        let ch: SyncChannel<i32> = SyncChannel::new();
+        let ch_clone = ch.clone();
+        let switch = Arc::new(AtomicBool::new(false));
+        let sw_clone = switch.clone();
+        assert_eq!(ch.try_recv().unwrap(), None);
+        
+        thread::spawn(move || {
+            ch_clone.send(3).unwrap();
+            sw_clone.store(true, Ordering::Relaxed);
+        });
+        loop {
+            if switch.load(Ordering::Relaxed) { break; }
+        }
+        assert_eq!(ch.try_recv().unwrap(), Some(3));
+    }
+}

src/lib.rs

@@ -1,81 +1,5 @@
 extern crate libc;
+#[cfg(test)] #[macro_use] extern crate lazy_static;
 
-use std::mem::{transmute, uninitialized};
-
-pub use libc::{SIGINT, SIGTERM, SIGUSR1, SIGUSR2};
-pub use libc::{SIGHUP, SIGQUIT, SIGPIPE, SIGALRM, SIGTRAP};
-pub use libc::c_int as int;
-
-pub fn signal(signum: int, sig_handler: fn(int), flags: Option<int>) {
-    let int_sig_handler: libc::size_t = unsafe { transmute(sig_handler) };
-    signal_internal(signum, int_sig_handler, flags)
-}
-
-fn signal_internal(signum: int, sig_handler: libc::size_t, flags: Option<int>) {
-    let mut sigset: libc::sigset_t = unsafe { uninitialized() };
-    let _ = unsafe { libc::sigemptyset(&mut sigset as *mut libc::sigset_t) };
-    
-    let mut siga = unsafe { uninitialized::<libc::sigaction>() };
-    let mut oldact = unsafe { uninitialized::<libc::sigaction>() };
-    
-    siga.sa_sigaction = sig_handler;
-    siga.sa_mask = sigset;
-    siga.sa_flags = flags.map(|x| { x - libc::SA_SIGINFO }).unwrap_or(libc::SA_ONSTACK | libc::SA_RESTART);
-    siga.sa_restorer = None;
-    
-    unsafe { libc::sigaction(signum, &siga as *const libc::sigaction, &mut oldact as *mut libc::sigaction) };
-}
-
-pub fn default(signum: int) {
-    let int_sig_handler: libc::size_t = unsafe { transmute(libc::SIG_DFL) };
-    signal_internal(signum, int_sig_handler, None)
-}
-
-pub fn ignore(signum: int) {
-    let int_sig_handler: libc::size_t = unsafe { transmute(libc::SIG_IGN) };
-    signal_internal(signum, int_sig_handler, None)
-}
-
-pub fn kill(signal: int) {
-    unsafe { libc::kill(libc::getpid(), signal) };
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    
-    static mut HANDLER_RUN:u32 = 0;
-    
-    fn test_handler(_: int) {
-        println!("Handler running!");
-        unsafe { HANDLER_RUN = HANDLER_RUN + 1 };
-    }
-
-    #[test]
-    fn test_signals() {
-        signal(SIGUSR1, test_handler, None);
-
-        kill(SIGUSR1);
-        ::std::thread::sleep(::std::time::Duration::from_secs(1));
-        unsafe { assert_eq!(HANDLER_RUN, 1) } ;
-        
-        default(SIGUSR1);
-    
-        ignore(SIGUSR1);
-
-        kill(SIGUSR1);
-        ::std::thread::sleep(::std::time::Duration::from_secs(1));
-    
-        signal(SIGUSR1, test_handler, None);
-        signal(SIGUSR2, test_handler, None);
-
-        kill(SIGUSR1);
-        ::std::thread::sleep(::std::time::Duration::from_secs(1));
-        unsafe { assert_eq!(HANDLER_RUN, 2) } ;
-
-        kill(SIGUSR2);
-        ::std::thread::sleep(::std::time::Duration::from_secs(2));
-        unsafe { assert_eq!(HANDLER_RUN, 3) } ;
-    }
-    
-}
+pub mod channel;
+pub mod signal;

src/signal.rs

@@ -0,0 +1,79 @@
+use std::mem::{transmute, uninitialized};
+
+use libc;
+
+pub use libc::{SIGINT, SIGTERM, SIGUSR1, SIGUSR2};
+pub use libc::{SIGHUP, SIGQUIT, SIGPIPE, SIGALRM, SIGTRAP};
+pub use libc::c_int as int;
+
+pub fn signal(signum: int, sig_handler: fn(int), flags: Option<int>) {
+    let int_sig_handler: libc::size_t = unsafe { transmute(sig_handler) };
+    signal_internal(signum, int_sig_handler, flags)
+}
+
+fn signal_internal(signum: int, sig_handler: libc::size_t, flags: Option<int>) {
+    let mut sigset: libc::sigset_t = unsafe { uninitialized() };
+    let _ = unsafe { libc::sigemptyset(&mut sigset as *mut libc::sigset_t) };
+    
+    let mut siga = unsafe { uninitialized::<libc::sigaction>() };
+    let mut oldact = unsafe { uninitialized::<libc::sigaction>() };
+    
+    siga.sa_sigaction = sig_handler;
+    siga.sa_mask = sigset;
+    siga.sa_flags = flags.map(|x| { x - libc::SA_SIGINFO }).unwrap_or(libc::SA_ONSTACK | libc::SA_RESTART);
+    siga.sa_restorer = None;
+    
+    unsafe { libc::sigaction(signum, &siga as *const libc::sigaction, &mut oldact as *mut libc::sigaction) };
+}
+
+pub fn default(signum: int) {
+    let int_sig_handler: libc::size_t = unsafe { transmute(libc::SIG_DFL) };
+    signal_internal(signum, int_sig_handler, None)
+}
+
+pub fn ignore(signum: int) {
+    let int_sig_handler: libc::size_t = unsafe { transmute(libc::SIG_IGN) };
+    signal_internal(signum, int_sig_handler, None)
+}
+
+pub fn kill(signal: int) {
+    unsafe { libc::kill(libc::getpid(), signal) };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use channel::SyncChannel;
+    
+    lazy_static! {
+        static ref TERM_CH: SyncChannel<()> = SyncChannel::new();
+    }
+    
+    fn test_handler(_: int) {
+        TERM_CH.send(()).unwrap();
+    }
+    
+    #[test]
+    fn test_signals() {
+        signal(SIGUSR1, test_handler, None);
+        
+        kill(SIGUSR1);
+        TERM_CH.recv().unwrap();
+        
+        default(SIGUSR1);
+        
+        ignore(SIGUSR1);
+        
+        kill(SIGUSR1);
+        
+        signal(SIGUSR1, test_handler, None);
+        signal(SIGUSR2, test_handler, None);
+        
+        kill(SIGUSR1);
+        TERM_CH.recv().unwrap();
+        
+        kill(SIGUSR2);
+        TERM_CH.recv().unwrap();
+    }
+    
+}