(try|async)_io with NamedPipes working example

[keithmattix]

I'm trying to use named pipes with either try_io or async_io and can't seem to get very far. I've tried using mio and std::fs::File with the raw_handle of a named pipe in order to perform efficient reads, but each time I run the code, the read returns a WouldBlock error and the readiness flag never goes back to true. I'm attaching some code here to give folks an idea of what I'm talking about, but I'm hoping @amab8901 or someone more familiar with this workflow than I am can help me out and/or add an example to the docs.

let client = loop {
    match ClientOptions::new()
            .pipe_mode(PipeMode::Message)
            .open(PIPE_NAME) {
        Ok(client) => break client,
        Err(e) => {
            println!("Failed to connect to pipe: {}", e);
            std::thread::sleep(std::time::Duration::from_secs(1));
        }
    }
};

let res = {
    // async_io takes care of WouldBlock error, so no need for loop here
    self.client
        .async_io(tokio::io::Interest::READABLE, || { // Only executes once because ready() never returns true again
            // We're using ManuallyDrop to prevent the file from being closed on drop
            // This is because the file is our handle to the named pipe and it
            // needs to have the same lifetime as the client object
            // let mut file = unsafe { std::mem::ManuallyDrop::new(File::from_raw_handle(handle)) };

            unsafe {
                let handle = std::mem::ManuallyDrop::new(self.client.as_raw_handle()); // TODO: we're taking the raw handle of a borrowed value here, is this correct?
                let mut h = std::mem::ManuallyDrop::new(mio::windows::NamedPipe::from_raw_handle(*handle));
                let res = h.read_vectored(&mut iov); // Instantly returns WouldBlock
                match res { // TODO: May need to use syscalls directly, but we'll see if this works
                    Ok(n) => {
                        println!("Read {:?} bytes from pipe", n);
                        Ok(n)
                    },
                    Err(ref e) => {
                        println!("Error reading from pipe: {}", e);
                        Err(tokio::io::ErrorKind::WouldBlock.into())
                    },
                }
            }
        }).await
};

[keithmattix]

Ah, this may be because I'm creating a mio named pipe without an event loop associated with it

[keithmattix]

Ah, I missed that try_read_vectored is nonblocking; I should just use that instead of re-implementing this manually