Remove the dependency on failure

Author: phil-opp

Cargo.lock

@@ -19,8 +19,3 @@ locate-cargo-manifest = "0.1.0"
 [dependencies.cargo_metadata]
 version = "0.7.4"
 default-features = false
-
-[dependencies.failure]
-version = "0.1.5"
-default-features = false
-features = ["std"]

Cargo.toml

@@ -1,5 +1,4 @@
 use crate::ErrorString;
-use failure::{Error, ResultExt};
 use std::path::PathBuf;
 use toml::Value;
 
@@ -16,17 +15,17 @@ pub(crate) fn read_config(manifest_path: PathBuf) -> Result<Config, ErrorString>
     Ok(config)
 }
 
-pub(crate) fn read_config_inner(manifest_path: PathBuf) -> Result<Config, Error> {
+pub(crate) fn read_config_inner(manifest_path: PathBuf) -> Result<Config, ErrorString> {
     use std::{fs::File, io::Read};
     let cargo_toml: Value = {
         let mut content = String::new();
         File::open(&manifest_path)
-            .with_context(|e| format!("Failed to open Cargo.toml: {}", e))?
+            .map_err(|e| format!("Failed to open Cargo.toml: {}", e))?
             .read_to_string(&mut content)
-            .with_context(|e| format!("Failed to read Cargo.toml: {}", e))?;
+            .map_err(|e| format!("Failed to read Cargo.toml: {}", e))?;
         content
             .parse::<Value>()
-            .with_context(|e| format!("Failed to parse Cargo.toml: {}", e))?
+            .map_err(|e| format!("Failed to parse Cargo.toml: {}", e))?
     };
 
     let metadata = cargo_toml
@@ -41,31 +40,12 @@ pub(crate) fn read_config_inner(manifest_path: PathBuf) -> Result<Config, Error>
             }
             .into());
         }
-        Some(metadata) => metadata.as_table().ok_or(format_err!(
+        Some(metadata) => metadata.as_table().ok_or(format!(
             "Bootimage configuration invalid: {:?}",
             metadata
         ))?,
     };
 
-    /*
-     * The user shouldn't specify any features if they're using a precompiled bootloader, as we
-     * don't actually compile it.
-     */
-    if cargo_toml
-        .get("dependencies")
-        .and_then(|table| table.get("bootloader_precompiled"))
-        .and_then(|table| {
-            table
-                .get("features")
-                .or_else(|| table.get("default-features"))
-        })
-        .is_some()
-    {
-        return Err(format_err!(
-            "Can't change features of precompiled bootloader!"
-        ));
-    }
-
     let mut config = ConfigBuilder {
         manifest_path: Some(manifest_path),
         ..Default::default()
@@ -79,12 +59,12 @@ pub(crate) fn read_config_inner(manifest_path: PathBuf) -> Result<Config, Error>
                 for value in array {
                     match value {
                         Value::String(s) => command.push(s),
-                        _ => Err(format_err!("run-command must be a list of strings"))?,
+                        _ => Err(format!("run-command must be a list of strings"))?,
                     }
                 }
                 config.run_command = Some(command);
             }
-            (key, value) => Err(format_err!(
+            (key, value) => Err(format!(
                 "unexpected `package.metadata.bootimage` \
                  key `{}` with value `{}`",
                 key,

src/config.rs

@@ -1,6 +1,3 @@
-#[macro_use]
-extern crate failure;
-
 use args::Args;
 use std::{fmt, process};
 
@@ -44,7 +41,7 @@ fn run() -> Result<(), ErrorString> {
     }
 }
 
-struct ErrorString(Box<dyn fmt::Display>);
+struct ErrorString(Box<dyn fmt::Display + Send>);
 
 impl ErrorString {
     fn display(&self) -> &dyn fmt::Display {
@@ -60,7 +57,7 @@ impl fmt::Debug for ErrorString {
 
 impl<T> From<T> for ErrorString
 where
-    T: fmt::Display + 'static,
+    T: fmt::Display + Send + 'static,
 {
     fn from(err: T) -> Self {
         ErrorString(Box::new(err))

src/main.rs

@@ -1,15 +1,9 @@
-use crate::args::Args;
-use crate::config;
-use crate::subcommand::build;
-use failure::{Error, ResultExt};
+use crate::{args::Args, config, subcommand::build, ErrorString};
+use std::{io::Write, path::PathBuf, time::Duration, fs, io, process};
 use rayon::prelude::*;
-use std::io::Write;
-use std::path::PathBuf;
-use std::time::Duration;
-use std::{fs, io, process};
 use wait_timeout::ChildExt;
 
-pub(crate) fn test(mut args: Args) -> Result<(), crate::ErrorString> {
+pub(crate) fn test(mut args: Args) -> Result<(), ErrorString> {
     let builder = bootimage::Builder::new(args.manifest_path().clone())?;
     let config = config::read_config(builder.kernel_manifest_path().to_owned())?;
     args.apply_default_target(&config, builder.kernel_root());
@@ -56,33 +50,33 @@ pub(crate) fn test(mut args: Args) -> Result<(), crate::ErrorString> {
             command.stderr(process::Stdio::null());
             let mut child = command
                 .spawn()
-                .with_context(|e| format_err!("Failed to launch QEMU: {:?}\n{}", command, e))?;
+                .map_err(|e| format!("Failed to launch QEMU: {:?}\n{}", command, e))?;
             let timeout = Duration::from_secs(60);
             match child
                 .wait_timeout(timeout)
-                .with_context(|e| format!("Failed to wait with timeout: {}", e))?
+                .map_err(|e| format!("Failed to wait with timeout: {}", e))?
             {
                 None => {
                     child
                         .kill()
-                        .with_context(|e| format!("Failed to kill QEMU: {}", e))?;
+                        .map_err(|e| format!("Failed to kill QEMU: {}", e))?;
                     child
                         .wait()
-                        .with_context(|e| format!("Failed to wait for QEMU process: {}", e))?;
+                        .map_err(|e| format!("Failed to wait for QEMU process: {}", e))?;
                     test_result = TestResult::TimedOut;
                     writeln!(io::stderr(), "Timed Out")?;
                 }
                 Some(exit_status) => {
-                    let output = fs::read_to_string(&output_file).with_context(|e| {
-                        format_err!("Failed to read test output file {}: {}", output_file, e)
+                    let output = fs::read_to_string(&output_file).map_err(|e| {
+                        format!("Failed to read test output file {}: {}", output_file, e)
                     })?;
                     test_result = handle_exit_status(exit_status, &output, &target.name)?;
                 }
             }
 
             Ok((target.name.clone(), test_result))
         })
-        .collect::<Result<Vec<(String, TestResult)>, Error>>()?;
+        .collect::<Result<Vec<(String, TestResult)>, ErrorString>>()?;
 
     println!("");
     if tests.iter().all(|t| t.1 == TestResult::Ok) {
@@ -101,7 +95,7 @@ fn handle_exit_status(
     exit_status: process::ExitStatus,
     output: &str,
     target_name: &str,
-) -> Result<TestResult, Error> {
+) -> Result<TestResult, ErrorString> {
     match exit_status.code() {
         None => {
             writeln!(io::stderr(), "FAIL: No Exit Code.")?;