56080c4767
This is part of the overall strategy I would like to take when approaching issue #11165. The only two I/O objects that reasonably want to be "split" are the network stream objects. Everything else can be "split" by just creating another version. The initial idea I had was the literally split the object into a reader and a writer half, but that would just introduce lots of clutter with extra interfaces that were a little unnnecssary, or it would return a ~Reader and a ~Writer which means you couldn't access things like the remote peer name or local socket name. The solution I found to be nicer was to just clone the stream itself. The clone is just a clone of the handle, nothing fancy going on at the kernel level. Conceptually I found this very easy to wrap my head around (everything else supports clone()), and it solved the "split" problem at the same time. The cloning support is pretty specific per platform/lib combination: * native/win32 - uses some specific WSA apis to clone the SOCKET handle * native/unix - uses dup() to get another file descriptor * green/all - This is where things get interesting. When we support full clones of a handle, this implies that we're allowing simultaneous writes and reads to happen. It turns out that libuv doesn't support two simultaneous reads or writes of the same object. It does support *one* read and *one* write at the same time, however. Some extra infrastructure was added to just block concurrent writers/readers until the previous read/write operation was completed. I've added tests to the tcp/unix modules to make sure that this functionality is supported everywhere.
89 lines
2.5 KiB
Rust
89 lines
2.5 KiB
Rust
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
//! Synchronous, in-memory pipes.
|
|
//!
|
|
//! Currently these aren't particularly useful, there only exists bindings
|
|
//! enough so that pipes can be created to child processes.
|
|
|
|
use prelude::*;
|
|
use io::IoResult;
|
|
use libc;
|
|
use rt::rtio::{RtioPipe, LocalIo};
|
|
|
|
pub struct PipeStream {
|
|
priv obj: ~RtioPipe,
|
|
}
|
|
|
|
impl PipeStream {
|
|
/// Consumes a file descriptor to return a pipe stream that will have
|
|
/// synchronous, but non-blocking reads/writes. This is useful if the file
|
|
/// descriptor is acquired via means other than the standard methods.
|
|
///
|
|
/// This operation consumes ownership of the file descriptor and it will be
|
|
/// closed once the object is deallocated.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```rust
|
|
/// # #[allow(unused_must_use)];
|
|
/// use std::libc;
|
|
/// use std::io::pipe::PipeStream;
|
|
///
|
|
/// let mut pipe = PipeStream::open(libc::STDERR_FILENO);
|
|
/// pipe.write(bytes!("Hello, stderr!"));
|
|
/// ```
|
|
pub fn open(fd: libc::c_int) -> IoResult<PipeStream> {
|
|
LocalIo::maybe_raise(|io| {
|
|
io.pipe_open(fd).map(|obj| PipeStream { obj: obj })
|
|
})
|
|
}
|
|
|
|
pub fn new(inner: ~RtioPipe) -> PipeStream {
|
|
PipeStream { obj: inner }
|
|
}
|
|
}
|
|
|
|
impl Clone for PipeStream {
|
|
fn clone(&self) -> PipeStream {
|
|
PipeStream { obj: self.obj.clone() }
|
|
}
|
|
}
|
|
|
|
impl Reader for PipeStream {
|
|
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { self.obj.read(buf) }
|
|
}
|
|
|
|
impl Writer for PipeStream {
|
|
fn write(&mut self, buf: &[u8]) -> IoResult<()> { self.obj.write(buf) }
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
iotest!(fn partial_read() {
|
|
use os;
|
|
use io::pipe::PipeStream;
|
|
|
|
let os::Pipe { input, out } = os::pipe();
|
|
let out = PipeStream::open(out);
|
|
let mut input = PipeStream::open(input);
|
|
let (p, c) = Chan::new();
|
|
spawn(proc() {
|
|
let mut out = out;
|
|
out.write([10]).unwrap();
|
|
p.recv(); // don't close the pipe until the other read has finished
|
|
});
|
|
|
|
let mut buf = [0, ..10];
|
|
input.read(buf).unwrap();
|
|
c.send(());
|
|
})
|
|
}
|