imp(timer): initial epoll/timerfd implementation

Author: omarabid

examples/internals-timer.rs

@@ -28,7 +28,7 @@ fn main() {
     std::thread::spawn(move || {
         while let result = rx.recv() {
             match result {
-                Ok(time) => println!("Thread 2 Notification: {}", time),
+                Ok(time) => println!("Thread 1 Notification: {}", time),
                 Err(err) => {
                     println!("Error Thread 1");
                     break;

src/timer/epoll.rs

@@ -20,7 +20,113 @@ pub struct Timer {
 
 impl Timer {
     pub fn initialize(self) -> Self {
-        self
+        let txs = Arc::clone(&self.txs);
+
+        // TODO: use ? instead of unwrap, requires changing Timer initialize function
+        let timer_fd = Timer::set_timerfd().unwrap();
+        let epoll_fd = Timer::create_epollfd(timer_fd).unwrap();
+
+        let handle = Some(thread::spawn(move || {
+            loop {
+                // Exit thread if there are no listeners
+                if txs.lock()?.len() == 0 {
+                    // TODO: should close file descriptor
+                    return Ok(());
+                }
+
+                // Fire @ 10th sec
+                Timer::epoll_wait(timer_fd, epoll_fd).unwrap();
+
+                // Get current time
+                let current = std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)?
+                    .as_secs();
+
+                // Iterate through Senders
+                txs.lock()?.iter().for_each(|tx| {
+                    // Send event to attached Sender
+                    tx.send(current).unwrap();
+                });
+            }
+        }));
+
+        Self { handle, ..self }
+    }
+
+    fn set_timerfd() -> Result<libc::c_int> {
+        let clockid: libc::clockid_t = libc::CLOCK_REALTIME;
+        let clock_flags: libc::c_int = libc::TFD_NONBLOCK;
+
+        // TODO: handler error (-1)
+        let tfd = unsafe { libc::timerfd_create(clockid, clock_flags) };
+
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)?
+            .as_secs();
+
+        let rem = 10u64.checked_sub(now.checked_rem(10).unwrap()).unwrap();
+
+        let first_fire = now + rem;
+
+        let mut new_value = libc::itimerspec {
+            it_interval: libc::timespec {
+                tv_sec: 10,
+                tv_nsec: 0,
+            },
+            it_value: libc::timespec {
+                tv_sec: first_fire as i64,
+                tv_nsec: 0,
+            },
+        };
+
+        let mut old_value = libc::itimerspec {
+            it_interval: libc::timespec {
+                tv_sec: 0,
+                tv_nsec: 0,
+            },
+            it_value: libc::timespec {
+                tv_sec: 0,
+                tv_nsec: 0,
+            },
+        };
+
+        let set_flags = libc::TFD_TIMER_ABSTIME;
+
+        // TODO: handler error (-1)
+        let sfd = unsafe { libc::timerfd_settime(tfd, set_flags, &mut new_value, &mut old_value) };
+
+        Ok(tfd)
+    }
+
+    fn create_epollfd(timer_fd: libc::c_int) -> Result<libc::c_int> {
+        // TODO: handler error (-1)
+        let epoll_fd = unsafe { libc::epoll_create1(0) };
+
+        let mut event = libc::epoll_event {
+            events: libc::EPOLLIN as u32,
+            u64: 1,
+        };
+
+        let epoll_flags = libc::EPOLL_CTL_ADD;
+
+        // TODO: handler error (-1)
+        let ctl_fd = unsafe { libc::epoll_ctl(epoll_fd, epoll_flags, timer_fd, &mut event) };
+
+        Ok(epoll_fd)
+    }
+
+    fn epoll_wait(timer_fd: libc::c_int, epoll_fd: libc::c_int) -> Result<()> {
+        let mut events = Vec::with_capacity(1);
+
+        // TODO: handler error (-1)
+        let wait = unsafe { libc::epoll_wait(epoll_fd, events.as_mut_ptr(), 1, -1) };
+        let mut buffer: u64 = 0;
+        let bufptr: *mut _ = &mut buffer;
+
+        // TODO: handler error (-1)
+        let read = unsafe { libc::read(timer_fd, bufptr as *mut libc::c_void, 8) };
+
+        Ok(())
     }
 
     /// Attach an mpsc::Sender to Timer