The last part of main is simply to write FINISHED to the console to let us know we exited main at that point.
The last bit of code in this chapter is the handle_events function. This function takes two arguments, a slice of Event structs and a mutable slice of TcpStream objects.
Let’s take a look at the code before we explain it:
fn handle_events(events: &[Event], streams: &mut [TcpStream]) -> Result<usize> {
let mut handled_events = 0;
for event in events {
let index = event.token();
let mut data = vec![0u8; 4096];
loop {
match streams[index].read(&mut data) {
Ok(n) if n == 0 => {
handled_events += 1;
break;
}
Ok(n) => {
let txt = String::from_utf8_lossy(&data[..n]);
println!(“RECEIVED: {:?}”, event);
println!(“{txt}\n——\n”);
}
// Not ready to read in a non-blocking manner.
This could
// happen even if the event was reported as ready
Err(e) if e.kind() == io::ErrorKind::WouldBlock => break,
Err(e) => return Err(e),
}
}
}
Ok(handled_events)
}
The first thing we do is to create a variable, handled_events, to track how many events we consider handled on each wakeup. The next step is looping through the events we received.
In the loop, we retrieve the token that identifies which TcpStream we received an event for. As we explained earlier in this example, this token is the same as the index for that particular stream in the streams collection, so we can simply use it to index into our streams collection and retrieve the right TcpStream.
Before we start reading data, we create a buffer with a size of 4,096 bytes (you can, of course, allocate a larger or smaller buffer for this if you want to).
We create a loop since we might need to call read multiple times to be sure that we’ve actually drained the buffer. Remember how important it is to fully drain the buffer when using epoll in edge-triggered mode.
We match on the result of calling TcpStream::read since we want to take different actions based on the result:
- 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.
- 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. We do not break out of the loop yet since we have to call read until 0 is returned (or an error) to be sure that we’ve drained the buffers fully.
- If we get Err and the error is of the io::ErrorKind::WouldBlock type, we simply break out of the loop. We don’t consider the event handled yet since WouldBlock indicates that the data transfer is not complete, but there is no data ready right now.
- If we get any other error, we simply return that error and consider it a failure.
Note
There is one more error condition you’d normally want to cover, and that is io::ErrorKind::Interrupted. Reading from a stream could be interrupted by a signal from the operating system. This should be expected and probably not considered a failure. The way to handle this is the same as what we do when we get an error of the WouldBlock type.
If the read operation is successful, we return the number of events handled.
Leave a Reply