rustuv: Deal with the rtio changes

Author: alexcrichton

src/librustuv/addrinfo.rs

@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ai = std::io::net::addrinfo;
 use libc::c_int;
 use libc;
 use std::mem;
 use std::ptr::null;
 use std::rt::task::BlockedTask;
+use std::rt::rtio;
 
 use net;
 use super::{Loop, UvError, Request, wait_until_woken_after, wakeup};
@@ -33,7 +33,9 @@ pub struct GetAddrInfoRequest;
 
 impl GetAddrInfoRequest {
     pub fn run(loop_: &Loop, node: Option<&str>, service: Option<&str>,
-               hints: Option<ai::Hint>) -> Result<Vec<ai::Info>, UvError> {
+               hints: Option<rtio::AddrinfoHint>)
+        -> Result<Vec<rtio::AddrinfoInfo>, UvError>
+    {
         assert!(node.is_some() || service.is_some());
         let (_c_node, c_node_ptr) = match node {
             Some(n) => {
@@ -54,20 +56,11 @@ impl GetAddrInfoRequest {
         };
 
         let hint = hints.map(|hint| {
-            let mut flags = 0;
-            each_ai_flag(|cval, aival| {
-                if hint.flags & (aival as uint) != 0 {
-                    flags |= cval as i32;
-                }
-            });
-            let socktype = 0;
-            let protocol = 0;
-
             libc::addrinfo {
-                ai_flags: flags,
+                ai_flags: 0,
                 ai_family: hint.family as c_int,
-                ai_socktype: socktype,
-                ai_protocol: protocol,
+                ai_socktype: 0,
+                ai_protocol: 0,
                 ai_addrlen: 0,
                 ai_canonname: null(),
                 ai_addr: null(),
@@ -119,22 +112,8 @@ impl Drop for Addrinfo {
     }
 }
 
-fn each_ai_flag(_f: |c_int, ai::Flag|) {
-    /* FIXME: do we really want to support these?
-    unsafe {
-        f(uvll::rust_AI_ADDRCONFIG(), ai::AddrConfig);
-        f(uvll::rust_AI_ALL(), ai::All);
-        f(uvll::rust_AI_CANONNAME(), ai::CanonName);
-        f(uvll::rust_AI_NUMERICHOST(), ai::NumericHost);
-        f(uvll::rust_AI_NUMERICSERV(), ai::NumericServ);
-        f(uvll::rust_AI_PASSIVE(), ai::Passive);
-        f(uvll::rust_AI_V4MAPPED(), ai::V4Mapped);
-    }
-    */
-}
-
 // Traverse the addrinfo linked list, producing a vector of Rust socket addresses
-pub fn accum_addrinfo(addr: &Addrinfo) -> Vec<ai::Info> {
+pub fn accum_addrinfo(addr: &Addrinfo) -> Vec<rtio::AddrinfoInfo> {
     unsafe {
         let mut addr = addr.handle;
 
@@ -143,35 +122,12 @@ pub fn accum_addrinfo(addr: &Addrinfo) -> Vec<ai::Info> {
             let rustaddr = net::sockaddr_to_addr(mem::transmute((*addr).ai_addr),
                                                  (*addr).ai_addrlen as uint);
 
-            let mut flags = 0;
-            each_ai_flag(|cval, aival| {
-                if (*addr).ai_flags & cval != 0 {
-                    flags |= aival as uint;
-                }
-            });
-
-            /* FIXME: do we really want to support these
-            let protocol = match (*addr).ai_protocol {
-                p if p == uvll::rust_IPPROTO_UDP() => Some(ai::UDP),
-                p if p == uvll::rust_IPPROTO_TCP() => Some(ai::TCP),
-                _ => None,
-            };
-            let socktype = match (*addr).ai_socktype {
-                p if p == uvll::rust_SOCK_STREAM() => Some(ai::Stream),
-                p if p == uvll::rust_SOCK_DGRAM() => Some(ai::Datagram),
-                p if p == uvll::rust_SOCK_RAW() => Some(ai::Raw),
-                _ => None,
-            };
-            */
-            let protocol = None;
-            let socktype = None;
-
-            addrs.push(ai::Info {
+            addrs.push(rtio::AddrinfoInfo {
                 address: rustaddr,
                 family: (*addr).ai_family as uint,
-                socktype: socktype,
-                protocol: protocol,
-                flags: flags,
+                socktype: 0,
+                protocol: 0,
+                flags: 0,
             });
             if (*addr).ai_next.is_not_null() {
                 addr = (*addr).ai_next;

src/librustuv/async.rs

@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use alloc::arc::Arc;
 use std::mem;
+use std::rt::exclusive::Exclusive;
 use std::rt::rtio::{Callback, RemoteCallback};
-use std::unstable::sync::Exclusive;
 
 use uvll;
 use super::{Loop, UvHandle};
@@ -22,12 +23,12 @@ pub struct AsyncWatcher {
 
     // A flag to tell the callback to exit, set from the dtor. This is
     // almost never contested - only in rare races with the dtor.
-    exit_flag: Exclusive<bool>
+    exit_flag: Arc<Exclusive<bool>>,
 }
 
 struct Payload {
     callback: Box<Callback:Send>,
-    exit_flag: Exclusive<bool>,
+    exit_flag: Arc<Exclusive<bool>>,
 }
 
 impl AsyncWatcher {
@@ -36,7 +37,7 @@ impl AsyncWatcher {
         assert_eq!(unsafe {
             uvll::uv_async_init(loop_.handle, handle, async_cb)
         }, 0);
-        let flag = Exclusive::new(false);
+        let flag = Arc::new(Exclusive::new(false));
         let payload = box Payload { callback: cb, exit_flag: flag.clone() };
         unsafe {
             let payload: *u8 = mem::transmute(payload);
@@ -80,9 +81,7 @@ extern fn async_cb(handle: *uvll::uv_async_t) {
     // could be called in the other thread, missing the final
     // callback while still destroying the handle.
 
-    let should_exit = unsafe {
-        payload.exit_flag.with_imm(|&should_exit| should_exit)
-    };
+    let should_exit = unsafe { *payload.exit_flag.lock() };
 
     payload.callback.call();
 
@@ -108,16 +107,13 @@ impl RemoteCallback for AsyncWatcher {
 
 impl Drop for AsyncWatcher {
     fn drop(&mut self) {
-        unsafe {
-            self.exit_flag.with(|should_exit| {
-                // NB: These two things need to happen atomically. Otherwise
-                // the event handler could wake up due to a *previous*
-                // signal and see the exit flag, destroying the handle
-                // before the final send.
-                *should_exit = true;
-                uvll::uv_async_send(self.handle)
-            })
-        }
+        let mut should_exit = unsafe { self.exit_flag.lock() };
+        // NB: These two things need to happen atomically. Otherwise
+        // the event handler could wake up due to a *previous*
+        // signal and see the exit flag, destroying the handle
+        // before the final send.
+        *should_exit = true;
+        unsafe { uvll::uv_async_send(self.handle) }
     }
 }
 

src/librustuv/file.rs

@@ -12,9 +12,9 @@ use libc::{c_int, c_char, c_void, ssize_t};
 use libc;
 use std::c_str::CString;
 use std::c_str;
-use std::io::{FileStat, IoError};
-use std::io;
 use std::mem;
+use std::os;
+use std::rt::rtio::{IoResult, IoError};
 use std::rt::rtio;
 use std::rt::task::BlockedTask;
 
@@ -56,21 +56,23 @@ impl FsRequest {
         })
     }
 
-    pub fn lstat(loop_: &Loop, path: &CString) -> Result<FileStat, UvError> {
+    pub fn lstat(loop_: &Loop, path: &CString)
+        -> Result<rtio::FileStat, UvError>
+    {
         execute(|req, cb| unsafe {
             uvll::uv_fs_lstat(loop_.handle, req, path.with_ref(|p| p),
                               cb)
         }).map(|req| req.mkstat())
     }
 
-    pub fn stat(loop_: &Loop, path: &CString) -> Result<FileStat, UvError> {
+    pub fn stat(loop_: &Loop, path: &CString) -> Result<rtio::FileStat, UvError> {
         execute(|req, cb| unsafe {
             uvll::uv_fs_stat(loop_.handle, req, path.with_ref(|p| p),
                              cb)
         }).map(|req| req.mkstat())
     }
 
-    pub fn fstat(loop_: &Loop, fd: c_int) -> Result<FileStat, UvError> {
+    pub fn fstat(loop_: &Loop, fd: c_int) -> Result<rtio::FileStat, UvError> {
         execute(|req, cb| unsafe {
             uvll::uv_fs_fstat(loop_.handle, req, fd, cb)
         }).map(|req| req.mkstat())
@@ -269,40 +271,30 @@ impl FsRequest {
         unsafe { uvll::get_ptr_from_fs_req(self.req) }
     }
 
-    pub fn mkstat(&self) -> FileStat {
+    pub fn mkstat(&self) -> rtio::FileStat {
         let stat = self.get_stat();
         fn to_msec(stat: uvll::uv_timespec_t) -> u64 {
             // Be sure to cast to u64 first to prevent overflowing if the tv_sec
             // field is a 32-bit integer.
             (stat.tv_sec as u64) * 1000 + (stat.tv_nsec as u64) / 1000000
         }
-        let kind = match (stat.st_mode as c_int) & libc::S_IFMT {
-            libc::S_IFREG => io::TypeFile,
-            libc::S_IFDIR => io::TypeDirectory,
-            libc::S_IFIFO => io::TypeNamedPipe,
-            libc::S_IFBLK => io::TypeBlockSpecial,
-            libc::S_IFLNK => io::TypeSymlink,
-            _ => io::TypeUnknown,
-        };
-        FileStat {
+        rtio::FileStat {
             size: stat.st_size as u64,
-            kind: kind,
-            perm: io::FilePermission::from_bits_truncate(stat.st_mode as u32),
+            kind: stat.st_mode as u64,
+            perm: stat.st_mode as u64,
             created: to_msec(stat.st_birthtim),
             modified: to_msec(stat.st_mtim),
             accessed: to_msec(stat.st_atim),
-            unstable: io::UnstableFileStat {
-                device: stat.st_dev as u64,
-                inode: stat.st_ino as u64,
-                rdev: stat.st_rdev as u64,
-                nlink: stat.st_nlink as u64,
-                uid: stat.st_uid as u64,
-                gid: stat.st_gid as u64,
-                blksize: stat.st_blksize as u64,
-                blocks: stat.st_blocks as u64,
-                flags: stat.st_flags as u64,
-                gen: stat.st_gen as u64,
-            }
+            device: stat.st_dev as u64,
+            inode: stat.st_ino as u64,
+            rdev: stat.st_rdev as u64,
+            nlink: stat.st_nlink as u64,
+            uid: stat.st_uid as u64,
+            gid: stat.st_gid as u64,
+            blksize: stat.st_blksize as u64,
+            blocks: stat.st_blocks as u64,
+            flags: stat.st_flags as u64,
+            gen: stat.st_gen as u64,
         }
     }
 }
@@ -369,29 +361,26 @@ impl FileWatcher {
         }
     }
 
-    fn base_read(&mut self, buf: &mut [u8], offset: i64) -> Result<int, IoError> {
+    fn base_read(&mut self, buf: &mut [u8], offset: i64) -> IoResult<int> {
         let _m = self.fire_homing_missile();
         let r = FsRequest::read(&self.loop_, self.fd, buf, offset);
         r.map_err(uv_error_to_io_error)
     }
-    fn base_write(&mut self, buf: &[u8], offset: i64) -> Result<(), IoError> {
+    fn base_write(&mut self, buf: &[u8], offset: i64) -> IoResult<()> {
         let _m = self.fire_homing_missile();
         let r = FsRequest::write(&self.loop_, self.fd, buf, offset);
         r.map_err(uv_error_to_io_error)
     }
-    fn seek_common(&self, pos: i64, whence: c_int) ->
-        Result<u64, IoError>{
-        unsafe {
-            match libc::lseek(self.fd, pos as libc::off_t, whence) {
-                -1 => {
-                    Err(IoError {
-                        kind: io::OtherIoError,
-                        desc: "Failed to lseek.",
-                        detail: None
-                    })
-                },
-                n => Ok(n as u64)
-            }
+    fn seek_common(&self, pos: i64, whence: c_int) -> IoResult<u64>{
+        match unsafe { libc::lseek(self.fd, pos as libc::off_t, whence) } {
+            -1 => {
+                Err(IoError {
+                    code: os::errno() as uint,
+                    extra: 0,
+                    detail: None,
+                })
+            },
+            n => Ok(n as u64)
         }
     }
 }
@@ -425,47 +414,47 @@ impl Drop for FileWatcher {
 }
 
 impl rtio::RtioFileStream for FileWatcher {
-    fn read(&mut self, buf: &mut [u8]) -> Result<int, IoError> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<int> {
         self.base_read(buf, -1)
     }
-    fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
+    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         self.base_write(buf, -1)
     }
-    fn pread(&mut self, buf: &mut [u8], offset: u64) -> Result<int, IoError> {
+    fn pread(&mut self, buf: &mut [u8], offset: u64) -> IoResult<int> {
         self.base_read(buf, offset as i64)
     }
-    fn pwrite(&mut self, buf: &[u8], offset: u64) -> Result<(), IoError> {
+    fn pwrite(&mut self, buf: &[u8], offset: u64) -> IoResult<()> {
         self.base_write(buf, offset as i64)
     }
-    fn seek(&mut self, pos: i64, whence: io::SeekStyle) -> Result<u64, IoError> {
+    fn seek(&mut self, pos: i64, whence: rtio::SeekStyle) -> IoResult<u64> {
         use libc::{SEEK_SET, SEEK_CUR, SEEK_END};
         let whence = match whence {
-            io::SeekSet => SEEK_SET,
-            io::SeekCur => SEEK_CUR,
-            io::SeekEnd => SEEK_END
+            rtio::SeekSet => SEEK_SET,
+            rtio::SeekCur => SEEK_CUR,
+            rtio::SeekEnd => SEEK_END
         };
         self.seek_common(pos, whence)
     }
-    fn tell(&self) -> Result<u64, IoError> {
+    fn tell(&self) -> IoResult<u64> {
         use libc::SEEK_CUR;
 
         self.seek_common(0, SEEK_CUR)
     }
-    fn fsync(&mut self) -> Result<(), IoError> {
+    fn fsync(&mut self) -> IoResult<()> {
         let _m = self.fire_homing_missile();
         FsRequest::fsync(&self.loop_, self.fd).map_err(uv_error_to_io_error)
     }
-    fn datasync(&mut self) -> Result<(), IoError> {
+    fn datasync(&mut self) -> IoResult<()> {
         let _m = self.fire_homing_missile();
         FsRequest::datasync(&self.loop_, self.fd).map_err(uv_error_to_io_error)
     }
-    fn truncate(&mut self, offset: i64) -> Result<(), IoError> {
+    fn truncate(&mut self, offset: i64) -> IoResult<()> {
         let _m = self.fire_homing_missile();
         let r = FsRequest::truncate(&self.loop_, self.fd, offset);
         r.map_err(uv_error_to_io_error)
     }
 
-    fn fstat(&mut self) -> Result<FileStat, IoError> {
+    fn fstat(&mut self) -> IoResult<rtio::FileStat> {
         let _m = self.fire_homing_missile();
         FsRequest::fstat(&self.loop_, self.fd).map_err(uv_error_to_io_error)
     }
@@ -475,7 +464,6 @@ impl rtio::RtioFileStream for FileWatcher {
 mod test {
     use libc::c_int;
     use libc::{O_CREAT, O_RDWR, O_RDONLY, S_IWUSR, S_IRUSR};
-    use std::io;
     use std::str;
     use super::FsRequest;
     use super::super::Loop;
@@ -562,10 +550,6 @@ mod test {
         let result = FsRequest::mkdir(l(), path, mode);
         assert!(result.is_ok());
 
-        let result = FsRequest::stat(l(), path);
-        assert!(result.is_ok());
-        assert!(result.unwrap().kind == io::TypeDirectory);
-
         let result = FsRequest::rmdir(l(), path);
         assert!(result.is_ok());