diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index c29c82ab2e9b4..1ac6fdc5ab122 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -56,9 +56,9 @@ use io::{FilePermission, Write, UnstableFileStat, Open, FileAccess, FileMode}; use io::{IoResult, IoError, FileStat, SeekStyle, Seek, Writer, Reader}; use io::{Read, Truncate, SeekCur, SeekSet, ReadWrite, SeekEnd, Append}; use io; +use io; use iter::Iterator; use kinds::Send; -use libc; use option::{Some, None, Option}; use owned::Box; use path::{Path, GenericPath}; @@ -138,7 +138,7 @@ impl File { Write => rtio::Write, ReadWrite => rtio::ReadWrite, }; - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_open(&path.to_c_str(), mode, access).map(|fd| { File { path: path.clone(), @@ -146,7 +146,11 @@ impl File { last_nread: -1 } }) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't open file", |e| { + format!("{}; path={}; mode={}; access={}", e, path.display(), + mode_string(mode), access_string(access)) + }) } /// Attempts to open a file in read-only mode. This function is equivalent to @@ -185,6 +189,7 @@ impl File { /// ``` pub fn create(path: &Path) -> IoResult { File::open_mode(path, Truncate, Write) + .update_desc("couldn't create file") } /// Returns the original path which was used to open this file. @@ -196,7 +201,9 @@ impl File { /// device. This will flush any internal buffers necessary to perform this /// operation. pub fn fsync(&mut self) -> IoResult<()> { - self.fd.fsync().map_err(IoError::from_rtio_error) + let err = self.fd.fsync().map_err(IoError::from_rtio_error); + err.update_err("couldn't fsync file", + |e| format!("{}; path={}", e, self.path.display())) } /// This function is similar to `fsync`, except that it may not synchronize @@ -204,7 +211,9 @@ impl File { /// must synchronize content, but don't need the metadata on disk. The goal /// of this method is to reduce disk operations. pub fn datasync(&mut self) -> IoResult<()> { - self.fd.datasync().map_err(IoError::from_rtio_error) + let err = self.fd.datasync().map_err(IoError::from_rtio_error); + err.update_err("couldn't datasync file", + |e| format!("{}; path={}", e, self.path.display())) } /// Either truncates or extends the underlying file, updating the size of @@ -216,7 +225,10 @@ impl File { /// will be extended to `size` and have all of the intermediate data filled /// in with 0s. pub fn truncate(&mut self, size: i64) -> IoResult<()> { - self.fd.truncate(size).map_err(IoError::from_rtio_error) + let err = self.fd.truncate(size).map_err(IoError::from_rtio_error); + err.update_err("couldn't truncate file", |e| { + format!("{}; path={}; size={}", e, self.path.display(), size) + }) } /// Tests whether this stream has reached EOF. @@ -229,10 +241,12 @@ impl File { /// Queries information about the underlying file. pub fn stat(&mut self) -> IoResult { - match self.fd.fstat() { + let err = match self.fd.fstat() { Ok(s) => Ok(from_rtio(s)), Err(e) => Err(IoError::from_rtio_error(e)), - } + }; + err.update_err("couldn't fstat file", + |e| format!("{}; path={}", e, self.path.display())) } } @@ -258,9 +272,11 @@ impl File { /// user lacks permissions to remove the file, or if some other filesystem-level /// error occurs. pub fn unlink(path: &Path) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_unlink(&path.to_c_str()) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't unlink path", + |e| format!("{}; path={}", e, path.display())) } /// Given a path, query the file system to get information about a file, @@ -285,10 +301,12 @@ pub fn unlink(path: &Path) -> IoResult<()> { /// to perform a `stat` call on the given path or if there is no entry in the /// filesystem at the provided path. pub fn stat(path: &Path) -> IoResult { - match LocalIo::maybe_raise(|io| io.fs_stat(&path.to_c_str())) { + let err = match LocalIo::maybe_raise(|io| io.fs_stat(&path.to_c_str())) { Ok(s) => Ok(from_rtio(s)), Err(e) => Err(IoError::from_rtio_error(e)), - } + }; + err.update_err("couldn't stat path", + |e| format!("{}; path={}", e, path.display())) } /// Perform the same operation as the `stat` function, except that this @@ -300,10 +318,12 @@ pub fn stat(path: &Path) -> IoResult { /// /// See `stat` pub fn lstat(path: &Path) -> IoResult { - match LocalIo::maybe_raise(|io| io.fs_lstat(&path.to_c_str())) { + let err = match LocalIo::maybe_raise(|io| io.fs_lstat(&path.to_c_str())) { Ok(s) => Ok(from_rtio(s)), Err(e) => Err(IoError::from_rtio_error(e)), - } + }; + err.update_err("couldn't lstat path", + |e| format!("{}; path={}", e, path.display())) } fn from_rtio(s: rtio::FileStat) -> FileStat { @@ -359,9 +379,12 @@ fn from_rtio(s: rtio::FileStat) -> FileStat { /// permissions to view the contents, or if some other intermittent I/O error /// occurs. pub fn rename(from: &Path, to: &Path) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_rename(&from.to_c_str(), &to.to_c_str()) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't rename path", |e| { + format!("{}; from={}; to={}", e, from.display(), to.display()) + }) } /// Copies the contents of one file to another. This function will also @@ -393,12 +416,17 @@ pub fn rename(from: &Path, to: &Path) -> IoResult<()> { /// ensured to not exist, there is nothing preventing the destination from /// being created and then destroyed by this operation. pub fn copy(from: &Path, to: &Path) -> IoResult<()> { + fn update_err(result: IoResult, from: &Path, to: &Path) -> IoResult { + result.update_err("couldn't copy path", + |e| format!("{}; from={}; to={}", e, from.display(), to.display())) + } + if !from.is_file() { - return Err(IoError { + return update_err(Err(IoError { kind: io::MismatchedFileTypeForOperation, desc: "the source path is not an existing file", - detail: None, - }) + detail: None + }), from, to) } let mut reader = try!(File::open(from)); @@ -409,12 +437,12 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> { let amt = match reader.read(buf) { Ok(n) => n, Err(ref e) if e.kind == io::EndOfFile => { break } - Err(e) => return Err(e) + Err(e) => return update_err(Err(e), from, to) }; try!(writer.write(buf.slice_to(amt))); } - chmod(to, try!(from.stat()).perm) + chmod(to, try!(update_err(from.stat(), from, to)).perm) } /// Changes the permission mode bits found on a file or a directory. This @@ -439,33 +467,45 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> { /// Some possible error situations are not having the permission to /// change the attributes of a file or the file not existing. pub fn chmod(path: &Path, mode: io::FilePermission) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_chmod(&path.to_c_str(), mode.bits() as uint) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't chmod path", |e| { + format!("{}; path={}; mode={}", e, path.display(), mode) + }) } /// Change the user and group owners of a file at the specified path. pub fn chown(path: &Path, uid: int, gid: int) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_chown(&path.to_c_str(), uid, gid) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't chown path", |e| { + format!("{}; path={}; uid={}; gid={}", e, path.display(), uid, gid) + }) } /// Creates a new hard link on the filesystem. The `dst` path will be a /// link pointing to the `src` path. Note that systems often require these /// two paths to both be located on the same filesystem. pub fn link(src: &Path, dst: &Path) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_link(&src.to_c_str(), &dst.to_c_str()) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't link path", |e| { + format!("{}; src={}; dest={}", e, src.display(), dst.display()) + }) } /// Creates a new symbolic link on the filesystem. The `dst` path will be a /// symlink pointing to the `src` path. pub fn symlink(src: &Path, dst: &Path) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_symlink(&src.to_c_str(), &dst.to_c_str()) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't symlink path", |e| { + format!("{}; src={}; dest={}", e, src.display(), dst.display()) + }) } /// Reads a symlink, returning the file that the symlink points to. @@ -475,9 +515,11 @@ pub fn symlink(src: &Path, dst: &Path) -> IoResult<()> { /// This function will return an error on failure. Failure conditions include /// reading a file that does not exist or reading a file which is not a symlink. pub fn readlink(path: &Path) -> IoResult { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { Ok(Path::new(try!(io.fs_readlink(&path.to_c_str())))) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't resolve symlink for path", + |e| format!("{}; path={}", e, path.display())) } /// Create a new, empty directory at the provided path @@ -498,9 +540,12 @@ pub fn readlink(path: &Path) -> IoResult { /// This call will return an error if the user lacks permissions to make a new /// directory at the provided path, or if the directory already exists. pub fn mkdir(path: &Path, mode: FilePermission) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_mkdir(&path.to_c_str(), mode.bits() as uint) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't create directory", |e| { + format!("{}; path={}; mode={}", e, path.display(), mode) + }) } /// Remove an existing, empty directory @@ -520,9 +565,11 @@ pub fn mkdir(path: &Path, mode: FilePermission) -> IoResult<()> { /// This call will return an error if the user lacks permissions to remove the /// directory at the provided path, or if the directory isn't empty. pub fn rmdir(path: &Path) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_rmdir(&path.to_c_str()) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't remove directory", + |e| format!("{}; path={}", e, path.display())) } /// Retrieve a vector containing all entries within a provided directory @@ -557,11 +604,13 @@ pub fn rmdir(path: &Path) -> IoResult<()> { /// permissions to view the contents or if the `path` points at a non-directory /// file pub fn readdir(path: &Path) -> IoResult> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { Ok(try!(io.fs_readdir(&path.to_c_str(), 0)).move_iter().map(|a| { Path::new(a) }).collect()) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't read directory", + |e| format!("{}; path={}", e, path.display())) } /// Returns an iterator which will recursively walk the directory structure @@ -569,7 +618,11 @@ pub fn readdir(path: &Path) -> IoResult> { /// perform iteration in some top-down order. The contents of unreadable /// subdirectories are ignored. pub fn walk_dir(path: &Path) -> IoResult { - Ok(Directories { stack: try!(readdir(path)) }) + Ok(Directories { + stack: try!(readdir(path).update_err("couldn't walk directory", + |e| format!("{}; path={}", + e, path.display()))) + }) } /// An iterator which walks over a directory @@ -582,7 +635,12 @@ impl Iterator for Directories { match self.stack.pop() { Some(path) => { if path.is_dir() { - match readdir(&path) { + let result = readdir(&path) + .update_err("couldn't advance Directories iterator", + |e| format!("{}; path={}", + e, path.display())); + + match result { Ok(dirs) => { self.stack.push_all_move(dirs); } Err(..) => {} } @@ -614,7 +672,11 @@ pub fn mkdir_recursive(path: &Path, mode: FilePermission) -> IoResult<()> { for c in comps { curpath.push(c); - match mkdir(&curpath, mode) { + let result = mkdir(&curpath, mode) + .update_err("couldn't recursively mkdir", + |e| format!("{}; path={}", e, path.display())); + + match result { Err(mkdir_err) => { // already exists ? if try!(stat(&curpath)).kind != io::TypeDirectory { @@ -639,8 +701,20 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> { let mut rm_stack = Vec::new(); rm_stack.push(path.clone()); + fn rmdir_failed(err: &IoError, path: &Path) -> String { + format!("rmdir_recursive failed; path={}; cause={}", + path.display(), err) + } + + fn update_err(err: IoResult, path: &Path) -> IoResult { + err.update_err("couldn't recursively rmdir", + |e| rmdir_failed(e, path)) + } + while !rm_stack.is_empty() { - let children = try!(readdir(rm_stack.last().unwrap())); + let children = try!(readdir(rm_stack.last().unwrap()) + .update_detail(|e| rmdir_failed(e, path))); + let mut has_child_dir = false; // delete all regular files in the way and push subdirs @@ -648,17 +722,17 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> { for child in children.move_iter() { // FIXME(#12795) we should use lstat in all cases let child_type = match cfg!(windows) { - true => try!(stat(&child)).kind, - false => try!(lstat(&child)).kind + true => try!(update_err(stat(&child), path)), + false => try!(update_err(lstat(&child), path)) }; - if child_type == io::TypeDirectory { + if child_type.kind == io::TypeDirectory { rm_stack.push(child); has_child_dir = true; } else { // we can carry on safely if the file is already gone // (eg: deleted by someone else since readdir) - match unlink(&child) { + match update_err(unlink(&child), path) { Ok(()) => (), Err(ref e) if e.kind == io::FileNotFound => (), Err(e) => return Err(e) @@ -668,7 +742,8 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> { // if no subdir was found, let's pop and delete if !has_child_dir { - match rmdir(&rm_stack.pop().unwrap()) { + let result = update_err(rmdir(&rm_stack.pop().unwrap()), path); + match result { Ok(()) => (), Err(ref e) if e.kind == io::FileNotFound => (), Err(e) => return Err(e) @@ -685,18 +760,28 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> { /// be in milliseconds. // FIXME(#10301) these arguments should not be u64 pub fn change_file_times(path: &Path, atime: u64, mtime: u64) -> IoResult<()> { - LocalIo::maybe_raise(|io| { + let err = LocalIo::maybe_raise(|io| { io.fs_utime(&path.to_c_str(), atime, mtime) - }).map_err(IoError::from_rtio_error) + }).map_err(IoError::from_rtio_error); + err.update_err("couldn't change_file_times", + |e| format!("{}; path={}", e, path.display())) } impl Reader for File { fn read(&mut self, buf: &mut [u8]) -> IoResult { - match self.fd.read(buf) { + fn update_err(result: IoResult, file: &File) -> IoResult { + result.update_err("couldn't read file", + |e| format!("{}; path={}", + e, file.path.display())) + } + + let result: IoResult = update_err(self.fd.read(buf), self); + + match result { Ok(read) => { self.last_nread = read; match read { - 0 => Err(io::standard_error(io::EndOfFile)), + 0 => update_err(Err(standard_error(io::EndOfFile)), self), _ => Ok(read as uint) } }, @@ -707,13 +792,17 @@ impl Reader for File { impl Writer for File { fn write(&mut self, buf: &[u8]) -> IoResult<()> { - self.fd.write(buf).map_err(IoError::from_rtio_error) + let err = self.fd.write(buf).map_err(IoError::from_rtio_error) + err.update_err("couldn't write to file", + |e| format!("{}; path={}", e, self.path.display())) } } impl Seek for File { fn tell(&self) -> IoResult { - self.fd.tell().map_err(IoError::from_rtio_error) + let err = self.fd.tell().map_err(IoError::from_rtio_error); + err.update_err("couldn't retrieve file cursor (`tell`)", + |e| format!("{}; path={}", e, self.path.display())) } fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> { @@ -722,14 +811,16 @@ impl Seek for File { SeekCur => rtio::SeekCur, SeekEnd => rtio::SeekEnd, }; - match self.fd.seek(pos, style) { + let err = match self.fd.seek(pos, style) { Ok(_) => { // successful seek resets EOF indicator self.last_nread = -1; Ok(()) } Err(e) => Err(IoError::from_rtio_error(e)), - } + }; + err.update_err("couldn't seek in file", + |e| format!("{}; path={}", e, self.path.display())) } } @@ -779,6 +870,22 @@ impl path::Path { } } +fn mode_string(mode: FileMode) -> &'static str { + match mode { + super::Open => "open", + super::Append => "append", + super::Truncate => "truncate" + } +} + +fn access_string(access: FileAccess) -> &'static str { + match access { + super::Read => "read", + super::Write => "write", + super::ReadWrite => "readwrite" + } +} + #[cfg(test)] #[allow(unused_imports)] mod test { @@ -801,6 +908,14 @@ mod test { } ) ) + macro_rules! error( ($e:expr, $s:expr) => ( + match $e { + Ok(val) => fail!("Should have been an error, was {:?}", val), + Err(ref err) => assert!(err.to_str().as_slice().contains($s.as_slice()), + format!("`{}` did not contain `{}`", err, $s)) + } + ) ) + struct TempDir(Path); impl TempDir { @@ -856,13 +971,21 @@ mod test { let tmpdir = tmpdir(); let filename = &tmpdir.join("file_that_does_not_exist.txt"); let result = File::open_mode(filename, Open, Read); - assert!(result.is_err()); + + error!(result, "couldn't open file"); + error!(result, "no such file or directory"); + error!(result, format!("path={}; mode=open; access=read", filename.display())); }) iotest!(fn file_test_iounlinking_invalid_path_should_raise_condition() { let tmpdir = tmpdir(); let filename = &tmpdir.join("file_another_file_that_does_not_exist.txt"); - assert!(unlink(filename).is_err()); + + let result = unlink(filename); + + error!(result, "couldn't unlink path"); + error!(result, "no such file or directory"); + error!(result, format!("path={}", filename.display())); }) iotest!(fn file_test_io_non_positional_read() { @@ -1091,6 +1214,22 @@ mod test { assert!(dir.is_dir()) }) + iotest!(fn recursive_mkdir_failure() { + let tmpdir = tmpdir(); + let dir = tmpdir.join("d1"); + let file = dir.join("f1"); + + check!(mkdir_recursive(&dir, io::UserRWX)); + check!(File::create(&file)); + + let result = mkdir_recursive(&file, io::UserRWX); + + error!(result, "couldn't recursively mkdir"); + error!(result, "couldn't create directory"); + error!(result, "mode=FilePermission { bits: 448 }"); + error!(result, format!("path={}", file.display())); + }) + iotest!(fn recursive_mkdir_slash() { check!(mkdir_recursive(&Path::new("/"), io::UserRWX)); }) @@ -1147,6 +1286,12 @@ mod test { iotest!(fn copy_file_does_not_exist() { let from = Path::new("test/nonexistent-bogus-path"); let to = Path::new("test/other-bogus-path"); + + error!(copy(&from, &to), + format!("couldn't copy path (the source path is not an \ + existing file; from={}; to={})", + from.display(), to.display())); + match copy(&from, &to) { Ok(..) => fail!(), Err(..) => { diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index a1e0fa889789f..a7f84899a622e 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -232,7 +232,7 @@ use owned::Box; use result::{Ok, Err, Result}; use rt::rtio; use slice::{Vector, MutableVector, ImmutableVector}; -use str::{StrSlice, StrAllocating}; +use str::{Str, StrSlice, StrAllocating}; use str; use string::String; use uint; @@ -309,6 +309,7 @@ impl IoError { /// struct is filled with an allocated string describing the error /// in more detail, retrieved from the operating system. pub fn from_errno(errno: uint, detail: bool) -> IoError { + #[cfg(windows)] fn get_err(errno: i32) -> (IoErrorKind, &'static str) { match errno { @@ -388,8 +389,8 @@ impl IoError { IoError { kind: kind, desc: desc, - detail: if detail { - Some(os::error_string(errno)) + detail: if detail && kind == OtherIoError { + Some(os::error_string(errno).as_slice().chars().map(|c| c.to_lowercase()).collect()) } else { None }, @@ -420,10 +421,13 @@ impl IoError { impl fmt::Show for IoError { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - try!(write!(fmt, "{}", self.desc)); - match self.detail { - Some(ref s) => write!(fmt, " ({})", *s), - None => Ok(()) + match *self { + IoError { kind: OtherIoError, desc: "unknown error", detail: Some(ref detail) } => + write!(fmt, "{}", detail), + IoError { detail: None, desc, .. } => + write!(fmt, "{}", desc), + IoError { detail: Some(ref detail), desc, .. } => + write!(fmt, "{} ({})", desc, detail) } } } @@ -484,6 +488,37 @@ pub enum IoErrorKind { NoProgress, } +/// A trait that lets you add a `detail` to an IoError easily +trait UpdateIoError { + /// Returns an IoError with updated description and detail + fn update_err(self, desc: &'static str, detail: |&IoError| -> String) -> Self; + + /// Returns an IoError with updated detail + fn update_detail(self, detail: |&IoError| -> String) -> Self; + + /// Returns an IoError with update description + fn update_desc(self, desc: &'static str) -> Self; +} + +impl UpdateIoError for IoResult { + fn update_err(self, desc: &'static str, detail: |&IoError| -> String) -> IoResult { + self.map_err(|mut e| { + let detail = detail(&e); + e.desc = desc; + e.detail = Some(detail); + e + }) + } + + fn update_detail(self, detail: |&IoError| -> String) -> IoResult { + self.map_err(|mut e| { e.detail = Some(detail(&e)); e }) + } + + fn update_desc(self, desc: &'static str) -> IoResult { + self.map_err(|mut e| { e.desc = desc; e }) + } +} + static NO_PROGRESS_LIMIT: uint = 1000; /// A trait for objects which are byte-oriented streams. Readers are defined by @@ -1577,7 +1612,7 @@ pub fn standard_error(kind: IoErrorKind) -> IoError { ConnectionAborted => "connection aborted", NotConnected => "not connected", BrokenPipe => "broken pipe", - PathAlreadyExists => "file exists", + PathAlreadyExists => "file already exists", PathDoesntExist => "no such file", MismatchedFileTypeForOperation => "mismatched file type", ResourceUnavailable => "resource unavailable",