mio pipes example

main.rs

extern crate os_pipe;
extern crate mio;
extern crate nix;

use os_pipe::*;
use mio::*;
use mio::unix::EventedFd;
use nix::fcntl::*;
use std::io::prelude::*;
use std::os::unix::io::*;

fn main() {
    const READER: Token = Token(0);
    const WRITER: Token = Token(1);

    let Pipe { mut reader, writer } = pipe().unwrap();
    let reader_raw = reader.as_raw_fd();
    fcntl(reader_raw, FcntlArg::F_SETFL(O_NONBLOCK)).unwrap();
    let writer_raw = writer.as_raw_fd();
    fcntl(writer_raw, FcntlArg::F_SETFL(O_NONBLOCK)).unwrap();
    let reader_evented = EventedFd(&reader_raw);
    let writer_evented = EventedFd(&writer_raw);
    let mut writer_opt = Some(writer);

    let poll = Poll::new().unwrap();
    let mut events = Events::with_capacity(1024);

    poll.register(&reader_evented, READER, Ready::all(), PollOpt::level()).unwrap();
    poll.register(&writer_evented, WRITER, Ready::all(), PollOpt::level()).unwrap();

    let mut input = vec![0u8; 150_000];
    let mut output = vec![0u8; 150_000];

    loop {
        poll.poll(&mut events, None).unwrap();
        println!("\npoll returned, events: {}", events.len());

        for event in events.iter() {
            match event.token() {
                READER => {
                    println!("{:?}", event);
                    if event.kind().is_readable() {
                        let n = reader.read(&mut output[..]).unwrap();
                        println!("read {}", n);
                    }
                    if event.kind().is_hup() {
                        println!("pipe closed");
                        return;
                    }
                }
                WRITER => {
                    println!("{:?}", event);
                    if event.kind().is_writable() {
                        {
                            let writer = writer_opt.as_mut().unwrap();
                            println!("writing...");
                            let n = writer.write(&input[..]).unwrap();
                            input.drain(0..n);
                            println!("wrote {}", n);
                        }
                        if input.len() == 0 {
                            poll.deregister(&writer_evented).unwrap();
                            writer_opt.take(); // drops
                            println!("closed writer");
                        }
                    }
                }
                _ => {
                    panic!("unknown token");
                }
            }
        }
    }
}