Standardize File errors

Author: cuviper

src/combiner.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::fs;
 use std::io::{Read, Write};
 use std::path::Path;
 use flate2::read::GzDecoder;
@@ -63,12 +62,10 @@ impl Combiner {
         create_dir_all(&package_dir)?;
 
         // Merge each installer into the work directory of the new installer
-        let components = fs::File::create(package_dir.join("components"))
-            .chain_err(|| "failed to create a new components file")?;
+        let components = create_new_file(package_dir.join("components"))?;
         for input_tarball in self.input_tarballs.split(',').map(str::trim).filter(|s| !s.is_empty()) {
             // Extract the input tarballs
-            fs::File::open(&input_tarball)
-                .and_then(GzDecoder::new)
+            GzDecoder::new(open_file(&input_tarball)?)
                 .and_then(|tar| Archive::new(tar).unpack(&self.work_dir))
                 .chain_err(|| format!("unable to extract '{}' into '{}'",
                                       &input_tarball, self.work_dir))?;
@@ -79,17 +76,17 @@ impl Combiner {
 
             // Verify the version number
             let mut version = String::new();
-            fs::File::open(pkg_dir.join("rust-installer-version"))
-                .and_then(|mut file| file.read_to_string(&mut version))
+            open_file(pkg_dir.join("rust-installer-version"))
+                .and_then(|mut file| file.read_to_string(&mut version).map_err(Error::from))
                 .chain_err(|| format!("failed to read version in '{}'", input_tarball))?;
             if version.trim().parse() != Ok(::RUST_INSTALLER_VERSION) {
                 bail!("incorrect installer version in {}", input_tarball);
             }
 
             // Move components to the new combined installer
             let mut pkg_components = String::new();
-            fs::File::open(pkg_dir.join("components"))
-                .and_then(|mut file| file.read_to_string(&mut pkg_components))
+            open_file(pkg_dir.join("components"))
+                .and_then(|mut file| file.read_to_string(&mut pkg_components).map_err(Error::from))
                 .chain_err(|| format!("failed to read components in '{}'", input_tarball))?;
             for component in pkg_components.split_whitespace() {
                 // All we need to do is move the component directory
@@ -104,8 +101,8 @@ impl Combiner {
         drop(components);
 
         // Write the installer version
-        fs::File::create(package_dir.join("rust-installer-version"))
-            .and_then(|file| writeln!(&file, "{}", ::RUST_INSTALLER_VERSION))
+        let version = package_dir.join("rust-installer-version");
+        writeln!(create_new_file(version)?, "{}", ::RUST_INSTALLER_VERSION)
             .chain_err(|| "failed to write new installer version")?;
 
         // Copy the overlay

src/generator.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::fs;
 use std::io::Write;
 use std::path::Path;
 
@@ -71,14 +70,14 @@ impl Generator {
         copy_and_manifest(self.image_dir.as_ref(), &component_dir, &self.bulk_dirs)?;
 
         // Write the component name
-        fs::File::create(package_dir.join("components"))
-            .and_then(|file| writeln!(&file, "{}", self.component_name))
+        let components = package_dir.join("components");
+        writeln!(create_new_file(components)?, "{}", self.component_name)
             .chain_err(|| "failed to write the component file")?;
 
         // Write the installer version (only used by combine-installers.sh)
-        fs::File::create(package_dir.join("rust-installer-version"))
-            .and_then(|file| writeln!(&file, "{}", ::RUST_INSTALLER_VERSION))
-            .chain_err(|| "failed to write the installer version")?;
+        let version = package_dir.join("rust-installer-version");
+        writeln!(create_new_file(version)?, "{}", ::RUST_INSTALLER_VERSION)
+            .chain_err(|| "failed to write new installer version")?;
 
         // Copy the overlay
         if !self.non_installed_overlay.is_empty() {
@@ -110,7 +109,7 @@ impl Generator {
 
 /// Copies the `src` directory recursively to `dst`, writing `manifest.in` too.
 fn copy_and_manifest(src: &Path, dst: &Path, bulk_dirs: &str) -> Result<()> {
-    let manifest = fs::File::create(dst.join("manifest.in"))?;
+    let manifest = create_new_file(dst.join("manifest.in"))?;
     let bulk_dirs: Vec<_> = bulk_dirs.split(',')
         .filter(|s| !s.is_empty())
         .map(Path::new).collect();

src/scripter.rs

@@ -8,15 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::fs;
 use std::io::Write;
 
-// Needed to set the script mode to executable.
-#[cfg(unix)]
-use std::os::unix::fs::OpenOptionsExt;
-// FIXME: what about Windows?  Are default ACLs executable?
-
 use errors::*;
+use util::*;
 
 const TEMPLATE: &'static str = include_str!("../install-template.sh");
 
@@ -59,11 +54,8 @@ impl Scripter {
             .replace("%%TEMPLATE_LEGACY_MANIFEST_DIRS%%", &sh_quote(&self.legacy_manifest_dirs))
             .replace("%%TEMPLATE_RUST_INSTALLER_VERSION%%", &sh_quote(&::RUST_INSTALLER_VERSION));
 
-        let mut options = fs::OpenOptions::new();
-        options.write(true).create_new(true);
-        #[cfg(unix)] options.mode(0o755);
-        options.open(&self.output_script)
-            .and_then(|mut output| output.write_all(script.as_ref()))
+        create_new_executable(&self.output_script)?
+            .write_all(script.as_ref())
             .chain_err(|| format!("failed to write output script '{}'", self.output_script))
     }
 }

src/tarballer.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::fs;
 use std::io::{self, Write};
 use std::path::Path;
 
@@ -56,14 +55,10 @@ impl Tarballer {
         files.sort_by(|a, b| a.bytes().rev().cmp(b.bytes().rev()));
 
         // Prepare the .tar.gz file
-        let output = fs::File::create(&tar_gz)
-            .chain_err(|| "failed to create .tar.gz file")?;
-        let gz = GzEncoder::new(output, flate2::Compression::Best);
+        let gz = GzEncoder::new(create_new_file(tar_gz)?, flate2::Compression::Best);
 
         // Prepare the .tar.xz file
-        let output = fs::File::create(&tar_xz)
-            .chain_err(|| "failed to create .tar.xz file")?;
-        let xz = XzEncoder::new(output, 9);
+        let xz = XzEncoder::new(create_new_file(tar_xz)?, 9);
 
         // Write the tar into both encoded files.  We write all directories
         // first, so files may be directly created. (see rustup.rs#1092)
@@ -75,8 +70,7 @@ impl Tarballer {
         }
         for path in files {
             let src = Path::new(&self.work_dir).join(&path);
-            fs::File::open(&src)
-                .and_then(|mut file| builder.append_file(&path, &mut file))
+            builder.append_file(&path, &mut open_file(&src)?)
                 .chain_err(|| format!("failed to tar file '{}'", src.display()))?;
         }
         let Tee(gz, xz) = builder.into_inner()

src/util.rs

@@ -13,6 +13,11 @@ use std::fs;
 use std::path::Path;
 use walkdir::WalkDir;
 
+// Needed to set the script mode to executable.
+#[cfg(unix)]
+use std::os::unix::fs::OpenOptionsExt;
+// FIXME: what about Windows?  Are default ACLs executable?
+
 use errors::*;
 
 /// Convert a `&Path` to a UTF-8 `&str`
@@ -41,6 +46,27 @@ pub fn create_dir_all<P: AsRef<Path>>(path: P) -> Result<()> {
         .chain_err(|| format!("failed to create dir '{}'", path.as_ref().display()))
 }
 
+/// Wrap `fs::OpenOptions::create_new().open()` as executable, with a nicer error message
+pub fn create_new_executable<P: AsRef<Path>>(path: P) -> Result<fs::File> {
+    let mut options = fs::OpenOptions::new();
+    options.write(true).create_new(true);
+    #[cfg(unix)] options.mode(0o755);
+    options.open(&path)
+        .chain_err(|| format!("failed to create file '{}'", path.as_ref().display()))
+}
+
+/// Wrap `fs::OpenOptions::create_new().open()`, with a nicer error message
+pub fn create_new_file<P: AsRef<Path>>(path: P) -> Result<fs::File> {
+    fs::OpenOptions::new().write(true).create_new(true).open(&path)
+        .chain_err(|| format!("failed to create file '{}'", path.as_ref().display()))
+}
+
+/// Wrap `fs::File::open()` with a nicer error message
+pub fn open_file<P: AsRef<Path>>(path: P) -> Result<fs::File> {
+    fs::File::open(&path)
+        .chain_err(|| format!("failed to open file '{}'", path.as_ref().display()))
+}
+
 /// Wrap `remove_dir_all` with a nicer error message
 pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> Result<()> {
     ::remove_dir_all::remove_dir_all(path.as_ref())