Start migrating stream I/O away from ~fn()

Author: alexcrichton

src/librustuv/lib.rs

@@ -66,8 +66,9 @@ pub use self::idle::IdleWatcher;
 pub use self::timer::TimerWatcher;
 pub use self::async::AsyncWatcher;
 pub use self::process::Process;
-pub use self::pipe::Pipe;
+pub use self::pipe::PipeWatcher;
 pub use self::signal::SignalWatcher;
+pub use self::tty::TtyWatcher;
 
 mod macros;
 
@@ -87,6 +88,7 @@ pub mod process;
 pub mod pipe;
 pub mod tty;
 pub mod signal;
+pub mod stream;
 
 /// XXX: Loop(*handle) is buggy with destructors. Normal structs
 /// with dtors may not be destructured, but tuple structs can,
@@ -218,7 +220,6 @@ pub type ReadCallback = ~fn(StreamWatcher, int, Buf, Option<UvError>);
 pub type NullCallback = ~fn();
 pub type ConnectionCallback = ~fn(StreamWatcher, Option<UvError>);
 pub type FsCallback = ~fn(&mut FsRequest, Option<UvError>);
-pub type AsyncCallback = ~fn(AsyncWatcher, Option<UvError>);
 pub type UdpReceiveCallback = ~fn(UdpWatcher, int, Buf, SocketAddr, uint, Option<UvError>);
 pub type UdpSendCallback = ~fn(UdpWatcher, Option<UvError>);
 
@@ -231,7 +232,6 @@ struct WatcherData {
     connect_cb: Option<ConnectionCallback>,
     close_cb: Option<NullCallback>,
     alloc_cb: Option<AllocCallback>,
-    async_cb: Option<AsyncCallback>,
     udp_recv_cb: Option<UdpReceiveCallback>,
     udp_send_cb: Option<UdpSendCallback>,
 }

src/librustuv/pipe.rs

@@ -8,91 +8,234 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::libc;
 use std::c_str::CString;
+use std::cast;
+use std::libc;
+use std::rt::BlockedTask;
+use std::rt::io::IoError;
+use std::rt::local::Local;
+use std::rt::rtio::{RtioPipe, RtioUnixListener, RtioUnixAcceptor};
+use std::rt::sched::{Scheduler, SchedHandle};
+use std::rt::tube::Tube;
 
-use super::{Loop, UvError, Watcher, NativeHandle, status_to_maybe_uv_error};
-use super::ConnectionCallback;
-use net;
+use stream::StreamWatcher;
+use super::{Loop, UvError, NativeHandle, uv_error_to_io_error, UvHandle};
+use uvio::HomingIO;
 use uvll;
 
-pub struct Pipe(*uvll::uv_pipe_t);
+pub struct PipeWatcher {
+    stream: StreamWatcher,
+    home: SchedHandle,
+}
+
+pub struct PipeListener {
+    home: SchedHandle,
+    pipe: *uvll::uv_pipe_t,
+    priv closing_task: Option<BlockedTask>,
+    priv outgoing: Tube<Result<~RtioPipe, IoError>>,
+}
+
+pub struct PipeAcceptor {
+    listener: ~PipeListener,
+    priv incoming: Tube<Result<~RtioPipe, IoError>>,
+}
 
-impl Watcher for Pipe {}
+// PipeWatcher implementation and traits
 
-impl Pipe {
-    pub fn new(loop_: &Loop, ipc: bool) -> Pipe {
+impl PipeWatcher {
+    pub fn new(pipe: *uvll::uv_pipe_t) -> PipeWatcher {
+        PipeWatcher {
+            stream: StreamWatcher::new(pipe),
+            home: get_handle_to_current_scheduler!(),
+        }
+    }
+
+    pub fn alloc(loop_: &Loop, ipc: bool) -> *uvll::uv_pipe_t {
         unsafe {
             let handle = uvll::malloc_handle(uvll::UV_NAMED_PIPE);
-            assert!(handle.is_not_null());
+            assert!(!handle.is_null());
             let ipc = ipc as libc::c_int;
             assert_eq!(uvll::uv_pipe_init(loop_.native_handle(), handle, ipc), 0);
-            let mut ret: Pipe =
-                    NativeHandle::from_native_handle(handle);
-            ret.install_watcher_data();
-            ret
+            handle
         }
     }
 
-    pub fn as_stream(&self) -> net::StreamWatcher {
-        net::StreamWatcher(**self as *uvll::uv_stream_t)
+    pub fn open(loop_: &Loop, file: libc::c_int) -> Result<PipeWatcher, UvError>
+    {
+        let handle = PipeWatcher::alloc(loop_, false);
+        match unsafe { uvll::uv_pipe_open(handle, file) } {
+            0 => Ok(PipeWatcher::new(handle)),
+            n => {
+                unsafe { uvll::uv_close(handle, pipe_close_cb) }
+                Err(UvError(n))
+            }
+        }
     }
 
-    #[fixed_stack_segment] #[inline(never)]
-    pub fn open(&mut self, file: libc::c_int) -> Result<(), UvError> {
-        match unsafe { uvll::uv_pipe_open(self.native_handle(), file) } {
-            0 => Ok(()),
-            n => Err(UvError(n))
+    pub fn connect(loop_: &Loop, name: &CString) -> Result<PipeWatcher, UvError>
+    {
+        struct Ctx {
+            task: Option<BlockedTask>,
+            result: Option<Result<PipeWatcher, UvError>>,
         }
+        let mut cx = Ctx { task: None, result: None };
+        let req = unsafe { uvll::malloc_req(uvll::UV_CONNECT) };
+        unsafe { uvll::set_data_for_req(req, &cx as *Ctx) }
+
+        let sched: ~Scheduler = Local::take();
+        do sched.deschedule_running_task_and_then |_, task| {
+            cx.task = Some(task);
+            unsafe {
+                uvll::uv_pipe_connect(req,
+                                      PipeWatcher::alloc(loop_, false),
+                                      name.with_ref(|p| p),
+                                      connect_cb)
+            }
+        }
+        assert!(cx.task.is_none());
+        return cx.result.take().expect("pipe connect needs a result");
+
+        extern fn connect_cb(req: *uvll::uv_connect_t, status: libc::c_int) {
+            unsafe {
+                let cx: &mut Ctx = cast::transmute(uvll::get_data_for_req(req));
+                let stream = uvll::get_stream_handle_from_connect_req(req);
+                cx.result = Some(match status {
+                    0 => Ok(PipeWatcher::new(stream)),
+                    n => {
+                        uvll::free_handle(stream);
+                        Err(UvError(n))
+                    }
+                });
+                uvll::free_req(req);
+
+                let sched: ~Scheduler = Local::take();
+                sched.resume_blocked_task_immediately(cx.task.take_unwrap());
+            }
+        }
+    }
+}
+
+impl RtioPipe for PipeWatcher {
+    fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
+        let _m = self.fire_missiles();
+        self.stream.read(buf).map_err(uv_error_to_io_error)
+    }
+
+    fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
+        let _m = self.fire_missiles();
+        self.stream.write(buf).map_err(uv_error_to_io_error)
+    }
+}
+
+impl HomingIO for PipeWatcher {
+    fn home<'a>(&'a mut self) -> &'a mut SchedHandle { &mut self.home }
+}
+
+impl Drop for PipeWatcher {
+    fn drop(&mut self) {
+        let _m = self.fire_missiles();
+        self.stream.close(true); // close synchronously
     }
+}
+
+extern fn pipe_close_cb(handle: *uvll::uv_handle_t) {
+    unsafe { uvll::free_handle(handle) }
+}
 
-    #[fixed_stack_segment] #[inline(never)]
-    pub fn bind(&mut self, name: &CString) -> Result<(), UvError> {
-        do name.with_ref |name| {
-            match unsafe { uvll::uv_pipe_bind(self.native_handle(), name) } {
-                0 => Ok(()),
-                n => Err(UvError(n))
+// PipeListener implementation and traits
+
+impl PipeListener {
+    pub fn bind(loop_: &Loop, name: &CString) -> Result<~PipeListener, UvError> {
+        let pipe = PipeWatcher::alloc(loop_, false);
+        match unsafe { uvll::uv_pipe_bind(pipe, name.with_ref(|p| p)) } {
+            0 => {
+                let p = ~PipeListener {
+                    home: get_handle_to_current_scheduler!(),
+                    pipe: pipe,
+                    closing_task: None,
+                    outgoing: Tube::new(),
+                };
+                Ok(p.install())
+            }
+            n => {
+                unsafe { uvll::free_handle(pipe) }
+                Err(UvError(n))
             }
         }
     }
+}
 
-    #[fixed_stack_segment] #[inline(never)]
-    pub fn connect(&mut self, name: &CString, cb: ConnectionCallback) {
-        {
-            let data = self.get_watcher_data();
-            assert!(data.connect_cb.is_none());
-            data.connect_cb = Some(cb);
+impl RtioUnixListener for PipeListener {
+    fn listen(mut ~self) -> Result<~RtioUnixAcceptor, IoError> {
+        // create the acceptor object from ourselves
+        let incoming = self.outgoing.clone();
+        let mut acceptor = ~PipeAcceptor {
+            listener: self,
+            incoming: incoming,
+        };
+
+        let _m = acceptor.fire_missiles();
+        // XXX: the 128 backlog should be configurable
+        match unsafe { uvll::uv_listen(acceptor.listener.pipe, 128, listen_cb) } {
+            0 => Ok(acceptor as ~RtioUnixAcceptor),
+            n => Err(uv_error_to_io_error(UvError(n))),
         }
+    }
+}
 
-        let connect = net::ConnectRequest::new();
-        let name = do name.with_ref |p| { p };
+impl HomingIO for PipeListener {
+    fn home<'r>(&'r mut self) -> &'r mut SchedHandle { &mut self.home }
+}
 
-        unsafe {
-            uvll::uv_pipe_connect(connect.native_handle(),
-                               self.native_handle(),
-                               name,
-                               connect_cb)
+impl UvHandle<uvll::uv_pipe_t> for PipeListener {
+    fn uv_handle(&self) -> *uvll::uv_pipe_t { self.pipe }
+}
+
+extern fn listen_cb(server: *uvll::uv_stream_t, status: libc::c_int) {
+    let msg = match status {
+        0 => {
+            let loop_ = NativeHandle::from_native_handle(unsafe {
+                uvll::get_loop_for_uv_handle(server)
+            });
+            let client = PipeWatcher::alloc(&loop_, false);
+            assert_eq!(unsafe { uvll::uv_accept(server, client) }, 0);
+            Ok(~PipeWatcher::new(client) as ~RtioPipe)
         }
+        n => Err(uv_error_to_io_error(UvError(n)))
+    };
+
+    let pipe: &mut PipeListener = unsafe { UvHandle::from_uv_handle(&server) };
+    pipe.outgoing.send(msg);
+}
 
-        extern "C" fn connect_cb(req: *uvll::uv_connect_t, status: libc::c_int) {
-            let connect_request: net::ConnectRequest =
-                    NativeHandle::from_native_handle(req);
-            let mut stream_watcher = connect_request.stream();
-            connect_request.delete();
+impl Drop for PipeListener {
+    fn drop(&mut self) {
+        let (_m, sched) = self.fire_missiles_sched();
 
-            let cb = stream_watcher.get_watcher_data().connect_cb.take_unwrap();
-            let status = status_to_maybe_uv_error(status);
-            cb(stream_watcher, status);
+        do sched.deschedule_running_task_and_then |_, task| {
+            self.closing_task = Some(task);
+            unsafe { uvll::uv_close(self.pipe, listener_close_cb) }
         }
     }
+}
+
+extern fn listener_close_cb(handle: *uvll::uv_handle_t) {
+    let pipe: &mut PipeListener = unsafe { UvHandle::from_uv_handle(&handle) };
+    unsafe { uvll::free_handle(handle) }
 
+    let sched: ~Scheduler = Local::take();
+    sched.resume_blocked_task_immediately(pipe.closing_task.take_unwrap());
 }
 
-impl NativeHandle<*uvll::uv_pipe_t> for Pipe {
-    fn from_native_handle(handle: *uvll::uv_pipe_t) -> Pipe {
-        Pipe(handle)
-    }
-    fn native_handle(&self) -> *uvll::uv_pipe_t {
-        match self { &Pipe(ptr) => ptr }
+// PipeAcceptor implementation and traits
+
+impl RtioUnixAcceptor for PipeAcceptor {
+    fn accept(&mut self) -> Result<~RtioPipe, IoError> {
+        let _m = self.fire_missiles();
+        self.incoming.recv()
     }
 }
+
+impl HomingIO for PipeAcceptor {
+    fn home<'r>(&'r mut self) -> &'r mut SchedHandle { self.listener.home() }
+}

src/librustuv/process.rs

@@ -21,8 +21,9 @@ use std::rt::sched::{Scheduler, SchedHandle};
 use std::vec;
 
 use super::{Loop, NativeHandle, UvHandle, UvError, uv_error_to_io_error};
-use uvio::{HomingIO, UvPipeStream, UvUnboundPipe};
+use uvio::HomingIO;
 use uvll;
+use pipe::PipeWatcher;
 
 pub struct Process {
     handle: *uvll::uv_process_t,
@@ -42,7 +43,7 @@ impl Process {
     /// Returns either the corresponding process object or an error which
     /// occurred.
     pub fn spawn(loop_: &Loop, config: ProcessConfig)
-                -> Result<(~Process, ~[Option<~UvPipeStream>]), UvError>
+                -> Result<(~Process, ~[Option<PipeWatcher>]), UvError>
     {
         let cwd = config.cwd.map(|s| s.to_c_str());
         let io = config.io;
@@ -121,7 +122,7 @@ extern fn on_exit(handle: *uvll::uv_process_t,
 
 unsafe fn set_stdio(dst: *uvll::uv_stdio_container_t,
                     io: &StdioContainer,
-                    loop_: &Loop) -> Option<~UvPipeStream> {
+                    loop_: &Loop) -> Option<PipeWatcher> {
     match *io {
         Ignored => {
             uvll::set_stdio_container_flags(dst, uvll::STDIO_IGNORE);
@@ -140,11 +141,10 @@ unsafe fn set_stdio(dst: *uvll::uv_stdio_container_t,
             if writable {
                 flags |= uvll::STDIO_WRITABLE_PIPE as libc::c_int;
             }
-            let pipe = UvUnboundPipe::new(loop_);
-            let handle = pipe.pipe.as_stream().native_handle();
+            let pipe_handle = PipeWatcher::alloc(loop_, false);
             uvll::set_stdio_container_flags(dst, flags);
-            uvll::set_stdio_container_stream(dst, handle);
-            Some(~UvPipeStream::new(pipe))
+            uvll::set_stdio_container_stream(dst, pipe_handle);
+            Some(PipeWatcher::new(pipe_handle))
         }
     }
 }