exercises

poll.rs (5564B)

---

 //! This contains the main abstraction, which is a thin layer over `epoll`.
 //! There are two main abstractions over epoll. One is a structure called
 //! `Poll` and the other is called `Registry`
 
 use crate::ffi;
 /// Its convenient to use `io::Result` type since most errors will stem from one
 /// of our calls into the operating system, and an operating system error can
 /// be mapped to an `io::Error` type
 use std::{
     io::{self, Result},
     net::TcpStream,
     os::fd::AsRawFd,
 };
 
 type Events = Vec<ffi::Event>;
 
 /// Poll is a struct that represents the event queue itself.
 pub struct Poll {
     registry: Registry,
 }
 
 impl Poll {
     /// Creates a new event queue
     pub fn new() -> Result<Self> {
         let res = unsafe { ffi::epoll_create(1) };
         if res < 0 {
             return Err(io::Error::last_os_error());
         }
 
         Ok(Self {
             registry: Registry { raw_fd: res },
         })
     }
 
     /// Returns a reference to the registry that can be used to register
     /// interest to be notified about new events
     pub fn registry(&self) -> &Registry {
         &self.registry
     }
 
     /// Blocks the thread it's called on until an event is ready or it times
     /// out, whichever occurs first
     pub fn poll(&mut self, events: &mut Events, timeout: Option<i32>) -> Result<()> {
         // The first thing we do is to get the raw file descriptor for
         // the event queue and store it in the fd variable.
         let fd = self.registry.raw_fd;
 
         // Next is our timeout. If it’s Some, we unwrap that value,
         // and if it’s None, we set it to –1, which is the value
         // that tells the operating system that we want to block
         // until an event occurs even though that might never happen.
         let timeout = timeout.unwrap_or(-1);
 
         // At the top of the file, we defined Events as a type alias
         // for Vec<ffi::Event>, so the next thing we do is to get
         // the capacity of that Vec. It’s important that we don’t
         // rely on Vec::len since that reports how many items we have
         // in the Vec. Vec::capacity reports the space we’ve allocated
         // and that’s what we’re after.
         let max_events = events.capacity() as i32;
 
         // Next up is the call to ffi::epoll_wait. This call will return
         // successfully if it has a value of 0 or larger, telling us
         // how many events have occurred.
         let res = unsafe { ffi::epoll_wait(fd, events.as_mut_ptr(), max_events, timeout) };
 
         // Note: We would get a value of 0 if a timeout elapses before
         // an event has happened.
         if res < 0 {
             return Err(io::Error::last_os_error());
         };
 
         // The last thing we do is to make an unsafe call to
         // events.set_len(res as usize). This function is unsafe since
         // we could potentially set the length so that we would access
         // memory that’s not been initialized yet in safe Rust.
         // We know from the guarantee the operating system gives us
         // that the number of events it returns is pointing to valid
         // data in our Vec, so this is safe in our case.
         unsafe {
             events.set_len(res as usize);
         };
         Ok(())
     }
 }
 
 /// While `Poll` represents the event queue, `Registry` is a handle that allows
 /// us to register interest in new events
 pub struct Registry {
     raw_fd: i32,
 }
 
 impl Registry {
     /// `Registry` will only have one method: `register`
     /// https://docs.rs/mio/0.8.8/mio/struct.Registry.html
     /// The `interests` argument will indicate what kind of events we want our
     /// event queue to keep track of.
     ///
     /// The register function takes a &TcpStream as a source,
     /// a token of type usize, and a bitmask named interests,
     /// which is of type i32.
     pub fn register(&self, source: &TcpStream, token: usize, interests: i32) -> Result<()> {
         // The first thing we do is to create an ffi::Event object.
         // The events field is simply set to the bitmask we received
         // and named interests, and epoll_data is set to the value
         // we passed in the token argument.
         let mut event = ffi::Event {
             events: interests as u32,
             epoll_data: token,
         };
 
         // The operation we want to perform on the epoll queue is
         // adding interest in events on a new file descriptor.
         // Therefore, we set the op argument to the ffi::EPOLL_CTL_ADD
         // constant value.
         let op = ffi::EPOLL_CTL_ADD;
 
         // Next up is the call to ffi::epoll_ctl. We pass in the file
         // descriptor to the epoll instance first, then we pass in
         // the op argument to indicate what kind of operation we want
         // to perform. The last two arguments are the file descriptor
         // we want the queue to track and the Event object we created
         // to indicate what kind of events we’re interested in getting
         // notifications for.
         let res = unsafe { ffi::epoll_ctl(self.raw_fd, op, source.as_raw_fd(), &mut event) };
 
         if res < 0 {
             return Err(io::Error::last_os_error());
         }
         Ok(())
     }
 }
 
 impl Drop for Registry {
     fn drop(&mut self) {
         // The Drop implementation simply calls ffi::close on the epoll
         // file descriptor.
         let res = unsafe { ffi::close(self.raw_fd) };
         if res < 0 {
             let err = io::Error::last_os_error();
             eprintln!("ERROR: {err:?}");
         }
     }
 }