fix issue PacktPublishing#4

Author: cfsamson

ch04/a-epoll/src/main.rs

@@ -1,4 +1,5 @@
 //! # FIXES:
+//! The number is identical to the number in the GitHub issue tracker
 //!
 //! ## FIX ISSUE #4:
 //! See:https://github.com/PacktPublishing/Asynchronous-Programming-in-Rust/issues/4
@@ -38,6 +39,7 @@ fn get_req(path: &str) -> String {
 fn handle_events(
     events: &[Event],
     streams: &mut [TcpStream],
+    // FIX #4: accepts a set of handled events as argument
     handled: &mut HashSet<usize>,
 ) -> Result<usize> {
     let mut handled_events = 0;
@@ -67,7 +69,7 @@ fn handle_events(
                 Err(e) if e.kind() == io::ErrorKind::WouldBlock => break,
                 // this was not in the book example, but it's a error condition
                 // you probably want to handle in some way (either by breaking
-                // out of the loop or trying a new read call immidiately)
+                // out of the loop or trying a new read call immediately)
                 Err(e) if e.kind() == io::ErrorKind::Interrupted => break,
                 Err(e) => return Err(e),
             }

ch04/b-epoll-mio/src/main.rs

@@ -1,3 +1,36 @@
+//! # FIXES:
+//! 
+//! The number is identical to the number in the GitHub issue tracker
+//!
+//! ## FIX ISSUE #4:
+//! 
+//! See:https://github.com/PacktPublishing/Asynchronous-Programming-in-Rust/issues/4
+//! Some users reported false event notification causing the counter to increase
+//! due to the OS reporting a READ event after we already read the TcpStream to EOF.
+//! This caused the counter to increment on the same TcpStream twice and thereby
+//! exiting the program before all events were handled.
+//!
+//! The fix for this is to account for false wakeups which is an easy fix but requires
+//! a few changes to the example. I've added an explicit comment: "FIX #4", the places
+//! I made a change so it's easy to spot the differences to the example code in the book.
+//! 
+//! ## TROUBLESHOOTING (KNOWN POTENTIAL ISSUE)
+//! 
+//! ### EXAMPLE DOESN'T WORK AS EXPECTED - PROBLEM WITH DNS LOOKUP
+//! If you first run this example on Linux under WSL and then immediately run it on
+//! Windows, I've observed issues with the DNS lookup for "localhost" being so slow
+//! that it defeats the purpose of the example. This issue could potentially also
+//! happen under other scenarios than the one mentioned here and the fix will be
+//! the same regardless.
+//! 
+//! I don't consider this a bug with our code but a surprising behavior of the 
+//! WSL/Windows network stack. Anyway, if you encounter this, the fix is simple: 
+//! 
+//! Change `let addr = "localhost:8080";` to `let addr = "127.0.0.1:8080";`.
+//!
+
+// FIX #4 (import `HashSet``)
+use std::collections::HashSet;
 use std::io::{self, Read, Result, Write};
 
 use mio::event::Event;
@@ -13,7 +46,7 @@ fn get_req(path: &str) -> String {
     )
 }
 
-fn handle_events(events: &[Event], streams: &mut [TcpStream]) -> Result<usize> {
+fn handle_events(events: &[Event], streams: &mut [TcpStream], handled: &mut HashSet<usize>) -> Result<usize> {
     let mut handled_events = 0;
     for event in events {
         // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -24,6 +57,13 @@ fn handle_events(events: &[Event], streams: &mut [TcpStream]) -> Result<usize> {
         loop {
             match streams[index].read(&mut data) {
                 Ok(n) if n == 0 => {
+                    // FIX #4
+                    // `insert` returns false if the value already existed in the set. We
+                    // handle it here since we must be sure that the TcpStream is fully
+                    // drained due to using edge triggered epoll.
+                    if !handled.insert(index) {
+                        break;
+                    }
                     handled_events += 1;
                     break;
                 }
@@ -34,6 +74,10 @@ fn handle_events(events: &[Event], streams: &mut [TcpStream]) -> Result<usize> {
                     println!("{txt}\n------\n");
                 }
                 Err(e) if e.kind() == io::ErrorKind::WouldBlock => break,
+                // this was not in the book example, but it's a error condition
+                // you probably want to handle in some way (either by breaking
+                // out of the loop or trying a new read call immediately)
+                Err(e) if e.kind() == io::ErrorKind::Interrupted => break,
                 Err(e) => return Err(e),
             }
         }
@@ -73,6 +117,9 @@ fn main() -> Result<()> {
 
         streams.push(stream);
     }
+    
+    // FIX #4: store the handled IDs
+    let mut handled_ids = HashSet::new();
 
     let mut handled_events = 0;
     while handled_events < n_events {
@@ -92,8 +139,9 @@ fn main() -> Result<()> {
         // Events collection
         let events: Vec<Event> = events.into_iter().map(|e| e.clone()).collect();
         // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-        handled_events += handle_events(&events, &mut streams)?;
+        
+        // ------------------------------------------------------⌄ FIX #4 (new signature)
+        handled_events += handle_events(&events, &mut streams, &mut handled_ids)?;
     }
 
     println!("FINISHED");