exercises

main.rs (4430B)

---

 use std::{
     io::{self, Read, Result, Write},
     net::TcpStream,
 };
 
 use ffi::Event;
 use poll::Poll;
 
 mod ffi;
 mod poll;
 
 fn get_req(path: &str) -> Vec<u8> {
     format!(
         "GET {path} HTTP/1.1\r\n\
         Host: localhost\r\n\
         Connection: close\r\n\
         \r\n"
     )
     .into_bytes()
 }
 
 fn handle_events(events: &[Event], streams: &mut [TcpStream]) -> Result<usize> {
     let mut handled_events = 0;
     for event in events {
         // We retrieve the token that identifies which TcpStream
         // we received an event for
         let index = event.token();
         let mut data = vec![0u8; 4096];
 
         loop {
             match streams[index].read(&mut data) {
                 // If we get Ok(n) and the value is 0, we’ve drained the
                 // buffer; we consider the event as handled and break out
                 // of the loop.
                 Ok(0) => {
                     handled_events += 1;
                     break;
                 }
                 // If we get Ok(n) with a value larger than 0,
                 // we read the data to a String and print it out
                 // with some formatting.
                 Ok(n) => {
                     let txt = String::from_utf8_lossy(&data[..n]);
                     println!("RECEIVED: {:?}", event);
                     println!("{txt}\n------\n");
                 }
                 // WouldBlock indicates that the data transfer is not complete,
                 // but there is no data ready right now.
                 Err(e) if e.kind() == io::ErrorKind::WouldBlock => break,
                 Err(e) => return Err(e),
             }
         }
     }
 
     Ok(handled_events)
 }
 
 fn main() -> Result<()> {
     // The first thing we do is to create a new Poll instance.
     let mut poll = Poll::new()?;
     // We also specify what number of events we want to create
     // and handle in our example.
     let n_events = 5;
 
     // The next step is creating a variable to hold a collection of
     // Vec<TcpStream> objects.
     let mut streams = vec![];
     // We also store the address to our local delayserver in
     // a variable called addr.
     let addr = "localhost:8090";
 
     // The next part is where we create a set of requests that we issue to
     // our delayserver, which will eventually respond to us. For each request,
     // we expect a read event to happen sometime later on in the TcpStream
     // we sent the request on.
     for i in 0..n_events {
         // Setting the delay to (n_events - i) * 1000 simply sets the
         // first request we make to have the longest timeout,
         // so we should expect the responses to arrive in the reverse order
         // from which they were sent.
         let delay = (n_events - i) * 1000;
         let url_path = format!("/{delay}/request-{i}");
         let request = get_req(&url_path);
         let mut stream = std::net::TcpStream::connect(addr)?;
         stream.set_nonblocking(true)?;
 
         stream.write_all(&request)?;
         poll.registry()
             .register(&stream, i, ffi::EPOLLIN | ffi::EPOLLET)?;
 
         streams.push(stream);
     }
 
     // The next part of the main function is handling incoming events:
     //
     // First, create a variable called handled_events to track
     // how many events we have handled.
     let mut handled_events = 0;
     // We loop as long as the handled events are less than the number
     // of events we expect. Once all events are handled, we exit the loop.
     while handled_events < n_events {
         // It’s important that we create this using Vec::with_capacity
         // since the operating system will assume that we pass it
         // memory that we’ve allocated.
         let mut events = Vec::with_capacity(10);
         // this will actually tell the operating system to park our thread
         // and wake us up when an event has occurred.
         poll.poll(&mut events, None)?;
 
         if events.is_empty() {
             // If we’re woken up, but there are no events in the list,
             // it’s either a timeout or a spurious event (which could
             // happen, so we need a way to check whether a timeout has
             // actually elapsed if that’s important to us).
             println!("TIMEOUT (OR SPURIOUS EVENT NOTIFICATION)");
             continue;
         }
 
         handled_events += handle_events(&events, &mut streams)?;
     }
 
     println!("FINISHED");
     Ok(())
 }