Gist to replicate issue with `PollOpt::oneshot` on Windows

windows-oneshot-test.rs

extern crate mio;

use std::io::Cursor;
use std::thread;
use std::thread::sleep;
use std::time::Duration;

use mio::*;
use mio::tcp::{TcpListener, TcpStream};

const LISTEN: Token = Token(0);
const PERFORM: Token = Token(1);
const ADDR: &'static str = "127.0.0.1:13265";

struct Server(TcpListener, Option<TcpStream>);

impl Handler for Server {
    type Timeout = ();
    type Message = ();

    fn ready(&mut self, event_loop: &mut EventLoop<Server>, token: Token, events: EventSet) {
        match token {
            LISTEN => {
                let Server(ref mut server, ref mut holder) = *self;
                let sock = server.accept().unwrap().unwrap().0;
                event_loop.register(
                    &sock,
                    PERFORM,
                    EventSet::writable(),
                    PollOpt::edge() | PollOpt::oneshot()).unwrap();
                *holder = Some(sock)
            }
            PERFORM => {
                if events.is_readable() {
                    println!("Server got readable");
                    let mut data: Cursor<Vec<u8>> = Cursor::new(Vec::new());
                    if let Ok(Some(_)) = self.1.as_mut().unwrap().try_read_buf(data.get_mut()) {
                        println!("Server read {:?}", data.get_ref());
                    }
                    event_loop.shutdown();
                }

                if events.is_writable() {
                    println!("Server got writable");
                    self.1.as_mut().unwrap().try_write(&mut [1, 2, 3u8]).unwrap();
                    
                    // REMOVE THIS LINE TO MAKE IT WORK
                    sleep(Duration::from_millis(200));

                    println!("Server finished writing");
                    
                    event_loop.reregister(
                        self.1.as_ref().unwrap(),
                        PERFORM,
                        EventSet::readable(),
                        PollOpt::edge() | PollOpt::oneshot()).unwrap();;
                }
            }
            _ => panic!("unexpected token"),
        }
    }
}

struct Client(TcpStream);

impl Handler for Client {
    type Timeout = ();
    type Message = ();

    fn ready(&mut self, event_loop: &mut EventLoop<Client>, token: Token, events: EventSet) {
        match token {
            PERFORM => {
                if events.is_readable() {
                    println!("Client got readable");
                    let mut data: Cursor<Vec<u8>> = Cursor::new(Vec::new());
                    if let Ok(Some(_)) = self.0.try_read_buf(data.get_mut()) {
                        println!("Client read {:?}", data.get_ref());
                    }
                    event_loop.reregister(
                        &self.0,
                        PERFORM,
                        EventSet::writable(),
                        PollOpt::edge() | PollOpt::oneshot()).unwrap();

                }

                if events.is_writable() {
                    println!("Client got writable");
                    self.0.try_write(&mut [4, 5, 6u8]).unwrap();
                    println!("Client finished writing");
                    event_loop.shutdown();
                }

            }
            _ => panic!("unexpected token"),
        }
    }
}

fn main () {

    let s = thread::spawn(move || {
        let addr = ADDR.parse().unwrap();
        let server = TcpListener::bind(&addr).unwrap();

        let mut event_loop = EventLoop::new().unwrap();

        event_loop.register(
            &server,
            LISTEN, EventSet::readable(),
            PollOpt::edge()).unwrap();
        event_loop.run(&mut Server(server, None)).unwrap();
    });

    // let server get started
    sleep(Duration::from_millis(100));

    let c = thread::spawn(move || {
        let addr = ADDR.parse().unwrap();
        let sock = TcpStream::connect(&addr).unwrap();
        let mut event_loop = EventLoop::new().unwrap();
        event_loop.register(
            &sock,
            PERFORM,
            EventSet::readable(),
            PollOpt::edge() | PollOpt::oneshot()).unwrap();
        event_loop.run(&mut Client(sock)).unwrap();
    });

    let _ = s.join();
    let _ = c.join();
}