Use error-chain for more informative errors

cuviper · cuviper · commit d3d56be1697b · 2017-05-05T16:07:20.000-07:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -9,6 +9,7 @@ name = "rust-installer"
 path = "src/main.rs"
 
 [dependencies]
+error-chain = "0.10.0"
 flate2 = "0.2.19"
 tar = "0.4.11"
 walkdir = "1.0.7"
diff --git a/src/combiner.rs b/src/combiner.rs
@@ -9,14 +9,14 @@
 // except according to those terms.
 
 use std::fs;
-use std::io::{self, Read, Write};
+use std::io::{Read, Write};
 use std::path::Path;
 use flate2::read::GzDecoder;
 use tar::Archive;
 
+use errors::*;
 use super::Scripter;
 use super::Tarballer;
-use remove_dir_all::*;
 use util::*;
 
 actor!{
@@ -53,55 +53,60 @@ actor!{
 
 impl Combiner {
     /// Combine the installer tarballs
-    pub fn run(self) -> io::Result<()> {
-        fs::create_dir_all(&self.work_dir)?;
+    pub fn run(self) -> Result<()> {
+        create_dir_all(&self.work_dir)?;
 
         let package_dir = Path::new(&self.work_dir).join(&self.package_name);
         if package_dir.exists() {
             remove_dir_all(&package_dir)?;
         }
-        fs::create_dir_all(&package_dir)?;
+        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"))?;
+        let components = fs::File::create(package_dir.join("components"))
+            .chain_err(|| "failed to create a new components file")?;
         for input_tarball in self.input_tarballs.split(',').map(str::trim).filter(|s| !s.is_empty()) {
             // Extract the input tarballs
-            let input = fs::File::open(&input_tarball)?;
-            let deflated = GzDecoder::new(input)?;
-            Archive::new(deflated).unpack(&self.work_dir)?;
+            fs::File::open(&input_tarball)
+                .and_then(GzDecoder::new)
+                .and_then(|tar| Archive::new(tar).unpack(&self.work_dir))
+                .chain_err(|| format!("unable to extract '{}' into '{}'",
+                                      &input_tarball, self.work_dir))?;
 
             let pkg_name = input_tarball.trim_right_matches(".tar.gz");
             let pkg_name = Path::new(pkg_name).file_name().unwrap();
             let pkg_dir = Path::new(&self.work_dir).join(&pkg_name);
 
             // Verify the version number
             let mut version = String::new();
-            fs::File::open(pkg_dir.join("rust-installer-version"))?
-                .read_to_string(&mut version)?;
+            fs::File::open(pkg_dir.join("rust-installer-version"))
+                .and_then(|mut file| file.read_to_string(&mut version))
+                .chain_err(|| format!("failed to read version in '{}'", input_tarball))?;
             if version.trim().parse() != Ok(::RUST_INSTALLER_VERSION) {
-                let msg = format!("incorrect installer version in {}", input_tarball);
-                return Err(io::Error::new(io::ErrorKind::Other, msg));
+                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"))?
-                .read_to_string(&mut pkg_components)?;
+            fs::File::open(pkg_dir.join("components"))
+                .and_then(|mut file| file.read_to_string(&mut pkg_components))
+                .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
                 let component_dir = package_dir.join(&component);
-                fs::rename(&pkg_dir.join(&component), &component_dir)?;
+                rename(&pkg_dir.join(&component), component_dir)?;
 
                 // Merge the component name
-                writeln!(&components, "{}", component)?;
+                writeln!(&components, "{}", component)
+                    .chain_err(|| "failed to write new components")?;
             }
         }
         drop(components);
 
         // Write the installer version
-        let version = fs::File::create(package_dir.join("rust-installer-version"))?;
-        writeln!(&version, "{}", ::RUST_INSTALLER_VERSION)?;
-        drop(version);
+        fs::File::create(package_dir.join("rust-installer-version"))
+            .and_then(|file| writeln!(&file, "{}", ::RUST_INSTALLER_VERSION))
+            .chain_err(|| "failed to write new installer version")?;
 
         // Copy the overlay
         if !self.non_installed_overlay.is_empty() {
@@ -115,16 +120,16 @@ impl Combiner {
             .rel_manifest_dir(self.rel_manifest_dir)
             .success_message(self.success_message)
             .legacy_manifest_dirs(self.legacy_manifest_dirs)
-            .output_script(output_script.to_str().unwrap());
+            .output_script(path_to_str(&output_script)?);
         scripter.run()?;
 
         // Make the tarballs
-        fs::create_dir_all(&self.output_dir)?;
+        create_dir_all(&self.output_dir)?;
         let output = Path::new(&self.output_dir).join(&self.package_name);
         let mut tarballer = Tarballer::default();
         tarballer.work_dir(self.work_dir)
             .input(self.package_name)
-            .output(output.to_str().unwrap());
+            .output(path_to_str(&output)?);
         tarballer.run()?;
 
         Ok(())
diff --git a/src/generator.rs b/src/generator.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 use std::fs;
-use std::io::{self, Write};
+use std::io::Write;
 use std::path::Path;
 
+use errors::*;
 use super::Scripter;
 use super::Tarballer;
-use remove_dir_all::*;
 use util::*;
 
 actor!{
@@ -57,8 +57,8 @@ actor!{
 
 impl Generator {
     /// Generate the actual installer tarball
-    pub fn run(self) -> io::Result<()> {
-        fs::create_dir_all(&self.work_dir)?;
+    pub fn run(self) -> Result<()> {
+        create_dir_all(&self.work_dir)?;
 
         let package_dir = Path::new(&self.work_dir).join(&self.package_name);
         if package_dir.exists() {
@@ -67,18 +67,18 @@ impl Generator {
 
         // Copy the image and write the manifest
         let component_dir = package_dir.join(&self.component_name);
-        fs::create_dir_all(&component_dir)?;
+        create_dir_all(&component_dir)?;
         copy_and_manifest(self.image_dir.as_ref(), &component_dir, &self.bulk_dirs)?;
 
         // Write the component name
-        let components = fs::File::create(package_dir.join("components"))?;
-        writeln!(&components, "{}", self.component_name)?;
-        drop(components);
+        fs::File::create(package_dir.join("components"))
+            .and_then(|file| writeln!(&file, "{}", self.component_name))
+            .chain_err(|| "failed to write the component file")?;
 
         // Write the installer version (only used by combine-installers.sh)
-        let version = fs::File::create(package_dir.join("rust-installer-version"))?;
-        writeln!(&version, "{}", ::RUST_INSTALLER_VERSION)?;
-        drop(version);
+        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")?;
 
         // Copy the overlay
         if !self.non_installed_overlay.is_empty() {
@@ -92,24 +92,24 @@ impl Generator {
             .rel_manifest_dir(self.rel_manifest_dir)
             .success_message(self.success_message)
             .legacy_manifest_dirs(self.legacy_manifest_dirs)
-            .output_script(output_script.to_str().unwrap());
+            .output_script(path_to_str(&output_script)?);
         scripter.run()?;
 
         // Make the tarballs
-        fs::create_dir_all(&self.output_dir)?;
+        create_dir_all(&self.output_dir)?;
         let output = Path::new(&self.output_dir).join(&self.package_name);
         let mut tarballer = Tarballer::default();
         tarballer.work_dir(self.work_dir)
             .input(self.package_name)
-            .output(output.to_str().unwrap());
+            .output(path_to_str(&output)?);
         tarballer.run()?;
 
         Ok(())
     }
 }
 
 /// Copies the `src` directory recursively to `dst`, writing `manifest.in` too.
-fn copy_and_manifest(src: &Path, dst: &Path, bulk_dirs: &str) -> io::Result<()> {
+fn copy_and_manifest(src: &Path, dst: &Path, bulk_dirs: &str) -> Result<()> {
     let manifest = fs::File::create(dst.join("manifest.in"))?;
     let bulk_dirs: Vec<_> = bulk_dirs.split(',')
         .filter(|s| !s.is_empty())
diff --git a/src/lib.rs b/src/lib.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[macro_use]
+extern crate error_chain;
 extern crate flate2;
 extern crate tar;
 extern crate walkdir;
@@ -21,6 +23,16 @@ extern crate kernel32;
 #[macro_use]
 extern crate lazy_static;
 
+mod errors {
+    error_chain!{
+        foreign_links {
+            Io(::std::io::Error);
+            StripPrefix(::std::path::StripPrefixError);
+            WalkDir(::walkdir::Error);
+        }
+    }
+}
+
 #[macro_use]
 mod util;
 
@@ -32,6 +44,7 @@ mod generator;
 mod scripter;
 mod tarballer;
 
+pub use errors::{Result, Error, ErrorKind};
 pub use combiner::Combiner;
 pub use generator::Generator;
 pub use scripter::Scripter;
diff --git a/src/main.rs b/src/main.rs
@@ -1,11 +1,23 @@
 #[macro_use]
 extern crate clap;
+#[macro_use]
+extern crate error_chain;
 extern crate installer;
 
+use errors::*;
 use clap::{App, ArgMatches};
-use installer::*;
 
-fn main() {
+mod errors {
+    error_chain!{
+        links {
+            Installer(::installer::Error, ::installer::ErrorKind);
+        }
+    }
+}
+
+quick_main!(run);
+
+fn run() -> Result<()> {
     let yaml = load_yaml!("main.yml");
     let matches = App::from_yaml(yaml).get_matches();
 
@@ -29,8 +41,8 @@ macro_rules! parse(
     }
 );
 
-fn combine(matches: &ArgMatches) {
-    let combiner = parse!(matches => Combiner {
+fn combine(matches: &ArgMatches) -> Result<()> {
+    let combiner = parse!(matches => installer::Combiner {
         "product-name" => product_name,
         "package-name" => package_name,
         "rel-manifest-dir" => rel_manifest_dir,
@@ -42,14 +54,11 @@ fn combine(matches: &ArgMatches) {
         "output-dir" => output_dir,
     });
 
-    if let Err(e) = combiner.run() {
-        println!("failed to combine installers: {}", e);
-        std::process::exit(1);
-    }
+    combiner.run().chain_err(|| "failed to combine installers")
 }
 
-fn generate(matches: &ArgMatches) {
-    let generator = parse!(matches => Generator {
+fn generate(matches: &ArgMatches) -> Result<()> {
+    let generator = parse!(matches => installer::Generator {
         "product-name" => product_name,
         "component-name" => component_name,
         "package-name" => package_name,
@@ -63,36 +72,27 @@ fn generate(matches: &ArgMatches) {
         "output-dir" => output_dir,
     });
 
-    if let Err(e) = generator.run() {
-        println!("failed to generate installer: {}", e);
-        std::process::exit(1);
-    }
+    generator.run().chain_err(|| "failed to generate installer")
 }
 
-fn script(matches: &ArgMatches) {
-    let scripter = parse!(matches => Scripter {
+fn script(matches: &ArgMatches) -> Result<()> {
+    let scripter = parse!(matches => installer::Scripter {
         "product-name" => product_name,
         "rel-manifest-dir" => rel_manifest_dir,
         "success-message" => success_message,
         "legacy-manifest-dirs" => legacy_manifest_dirs,
         "output-script" => output_script,
     });
 
-    if let Err(e) = scripter.run() {
-        println!("failed to generate installation script: {}", e);
-        std::process::exit(1);
-    }
+    scripter.run().chain_err(|| "failed to generate installation script")
 }
 
-fn tarball(matches: &ArgMatches) {
-    let tarballer = parse!(matches => Tarballer {
+fn tarball(matches: &ArgMatches) -> Result<()> {
+    let tarballer = parse!(matches => installer::Tarballer {
         "input" => input,
         "output" => output,
         "work-dir" => work_dir,
     });
 
-    if let Err(e) = tarballer.run() {
-        println!("failed to generate tarballs: {}", e);
-        std::process::exit(1);
-    }
+    tarballer.run().chain_err(|| "failed to generate tarballs")
 }
diff --git a/src/scripter.rs b/src/scripter.rs
@@ -9,13 +9,15 @@
 // except according to those terms.
 
 use std::fs;
-use std::io::{self, Write};
+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::*;
+
 const TEMPLATE: &'static str = include_str!("../install-template.sh");
 
 
@@ -41,7 +43,7 @@ actor!{
 
 impl Scripter {
     /// Generate the actual installer script
-    pub fn run(self) -> io::Result<()> {
+    pub fn run(self) -> Result<()> {
         // Replace dashes in the success message with spaces (our arg handling botches spaces)
         // (TODO: still needed?  kept for compatibility for now...)
         let product_name = self.product_name.replace('-', " ");
@@ -60,8 +62,9 @@ impl Scripter {
         let mut options = fs::OpenOptions::new();
         options.write(true).create_new(true);
         #[cfg(unix)] options.mode(0o755);
-        let output = options.open(self.output_script)?;
-        writeln!(&output, "{}", script)
+        options.open(&self.output_script)
+            .and_then(|mut output| output.write_all(script.as_ref()))
+            .chain_err(|| format!("failed to write output script '{}'", self.output_script))
     }
 }
 
diff --git a/src/tarballer.rs b/src/tarballer.rs
diff --git a/src/util.rs b/src/util.rs
