---

yaml
---
r: 146173
b: refs/heads/try2
c: 816e46d
h: refs/heads/master
i:
  146171: 97e2529
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 262b958a4bedf419335069c95f054a22da48a88a
+refs/heads/try2: 816e46dd633cf4cc5741dde6ce3bffd4a9ba67a7
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/rt/io/pipe.rs

@@ -16,13 +16,45 @@
 use prelude::*;
 use super::{Reader, Writer};
 use rt::io::{io_error, EndOfFile};
-use rt::rtio::RtioPipe;
+use rt::io::native::file;
+use rt::rtio::{RtioPipe, with_local_io};
 
 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
+    ///
+    ///     use std::libc;
+    ///     use std::rt::io::pipe;
+    ///
+    ///     let mut pipe = PipeStream::open(libc::STDERR_FILENO);
+    ///     pipe.write(bytes!("Hello, stderr!"));
+    ///
+    /// # Failure
+    ///
+    /// If the pipe cannot be created, an error will be raised on the
+    /// `io_error` condition.
+    pub fn open(fd: file::fd_t) -> Option<PipeStream> {
+        do with_local_io |io| {
+            match io.pipe_open(fd) {
+                Ok(obj) => Some(PipeStream { obj: obj }),
+                Err(e) => {
+                    io_error::cond.raise(e);
+                    None
+                }
+            }
+        }
+    }
+
     pub fn new(inner: ~RtioPipe) -> PipeStream {
         PipeStream { obj: inner }
     }

branches/try2/src/libstd/run.rs

@@ -322,6 +322,7 @@ mod tests {
     use path::Path;
     use run;
     use str;
+    use task::spawn;
     use unstable::running_on_valgrind;
     use rt::io::native::file;
     use rt::io::{Writer, Reader};
@@ -394,6 +395,7 @@ mod tests {
     }
 
     #[test]
+    #[ignore] // FIXME(#10016) cat never sees stdin close
     fn test_pipes() {
 
         let pipe_in = os::pipe();
@@ -412,13 +414,14 @@ mod tests {
         os::close(pipe_out.out);
         os::close(pipe_err.out);
 
-        let expected = ~"test";
-        writeclose(pipe_in.out, expected);
+        do spawn {
+            writeclose(pipe_in.out, ~"test");
+        }
         let actual = readclose(pipe_out.input);
         readclose(pipe_err.input);
         proc.finish();
 
-        assert_eq!(expected, actual);
+        assert_eq!(~"test", actual);
     }
 
     fn writeclose(fd: c_int, s: &str) {

branches/try2/src/test/run-pass/core-run-destroy.rs

@@ -18,6 +18,7 @@
 use std::libc;
 use std::run;
 use std::str;
+use std::rt::io;
 
 #[test]
 fn test_destroy_once() {
@@ -29,7 +30,9 @@ fn test_destroy_once() {
 fn test_destroy_twice() {
     let mut p = run::Process::new("echo", [], run::ProcessOptions::new());
     p.destroy(); // this shouldnt crash...
-    p.destroy(); // ...and nor should this (and nor should the destructor)
+    do io::io_error::cond.trap(|_| {}).inside {
+        p.destroy(); // ...and nor should this (and nor should the destructor)
+    }
 }
 
 fn test_destroy_actually_kills(force: bool) {