Add behavior on failure to BootstrapCommand

Author: Kobzol

src/bootstrap/exec.rs

@@ -9,26 +9,34 @@ pub enum OutputOnFailure {
     Verbose,
 }
 
+/// What should be done when the command fails.
+#[derive(Debug, Copy, Clone)]
+pub enum BehaviorOnFailure {
+    /// Immediately stop bootstrap
+    Exit,
+    /// Delay failure until the end of bootstrap invocation
+    DelayFail,
+}
+
 /// Wrapper around `std::process::Command`.
 #[derive(Debug)]
 pub struct BootstrapCommand<'a> {
     pub command: &'a mut Command,
-    /// Report failure later instead of immediately.
-    pub delay_failure: bool,
-    pub output_on_failure: Option<OutputOnFailure>,
+    pub failure_behavior: Option<BehaviorOnFailure>,
+    pub failure_output: Option<OutputOnFailure>,
 }
 
 impl<'a> BootstrapCommand<'a> {
-    pub fn delay_failure(self) -> Self {
-        Self { delay_failure: true, ..self }
+    pub fn failure_behavior(self, failure_behavior: BehaviorOnFailure) -> Self {
+        Self { failure_behavior: Some(failure_behavior), ..self }
     }
-    pub fn output_on_failure(self, output_on_failure: OutputOnFailure) -> Self {
-        Self { output_on_failure: Some(output_on_failure), ..self }
+    pub fn failure_output(self, failure_output: OutputOnFailure) -> Self {
+        Self { failure_output: Some(failure_output), ..self }
     }
 }
 
 impl<'a> From<&'a mut Command> for BootstrapCommand<'a> {
     fn from(command: &'a mut Command) -> Self {
-        Self { command, delay_failure: false, output_on_failure: None }
+        Self { command, failure_behavior: None, failure_output: None }
     }
 }

src/bootstrap/lib.rs

@@ -90,7 +90,7 @@ mod job {
 pub use crate::builder::PathSet;
 use crate::cache::{Interned, INTERNER};
 pub use crate::config::Config;
-use crate::exec::{BootstrapCommand, OutputOnFailure};
+use crate::exec::{BehaviorOnFailure, BootstrapCommand, OutputOnFailure};
 pub use crate::flags::Subcommand;
 use termcolor::{ColorChoice, StandardStream, WriteColor};
 
@@ -976,22 +976,26 @@ impl Build {
     /// Runs a command, printing out nice contextual information if it fails.
     fn run_quiet(&self, cmd: &mut Command) {
         let cmd: BootstrapCommand<'_> = cmd.into();
-        // TODO: fail bootstrap immediately if this command fails
-        self.run_cmd(cmd.output_on_failure(OutputOnFailure::Verbose));
+        self.run_cmd(
+            cmd.failure_output(OutputOnFailure::Verbose).failure_behavior(BehaviorOnFailure::Exit),
+        );
     }
 
     /// Runs a command, printing out nice contextual information if it fails.
     /// Exits if the command failed to execute at all, otherwise returns its
     /// `status.success()`.
     fn run_quiet_delaying_failure(&self, cmd: &mut Command) -> bool {
         let cmd: BootstrapCommand<'_> = cmd.into();
-        self.run_cmd(cmd.output_on_failure(OutputOnFailure::Verbose).delay_failure())
+        self.run_cmd(
+            cmd.failure_output(OutputOnFailure::Verbose)
+                .failure_behavior(BehaviorOnFailure::DelayFail),
+        )
     }
 
     /// Runs a command, printing out contextual info if it fails, and delaying errors until the build finishes.
     pub(crate) fn run_delaying_failure(&self, cmd: &mut Command) -> bool {
         let cmd: BootstrapCommand<'_> = cmd.into();
-        self.run_cmd(cmd.delay_failure())
+        self.run_cmd(cmd.failure_behavior(BehaviorOnFailure::DelayFail))
     }
 
     /// A centralized function for running commands that do not return output.
@@ -1004,7 +1008,7 @@ impl Build {
             Err(e) => fail(&format!("failed to execute command: {:?}\nerror: {}", command, e)),
         };
         let result = if !output.status.success() {
-            let output_on_failure = match command.output_on_failure {
+            let output_on_failure = match command.failure_output {
                 Some(output) => Some(output),
                 None if self.is_verbose() => Some(OutputOnFailure::Succint),
                 None => None,
@@ -1040,10 +1044,16 @@ impl Build {
         match result {
             Ok(_) => true,
             Err(_) => {
-                if command.delay_failure {
-                    let mut failures = self.delayed_failures.borrow_mut();
-                    failures.push(format!("{command:?}"));
-                    return false;
+                if let Some(failure_behavior) = command.failure_behavior {
+                    match failure_behavior {
+                        BehaviorOnFailure::DelayFail => {
+                            let mut failures = self.delayed_failures.borrow_mut();
+                            failures.push(format!("{command:?}"));
+                        }
+                        BehaviorOnFailure::Exit => {
+                            exit!(1);
+                        }
+                    }
                 }
                 if self.fail_fast {
                     exit!(1);