Properly report and terminate if cargo acl test fails

Tests for this use-case will be added later, since we need some
additional features to be able to effectively test this.

Author: davidlattimore

src/build_script_checker.rs

@@ -20,15 +20,6 @@ impl BuildScriptReport {
     ) -> Result<BuildScriptReport> {
         let mut report = BuildScriptReport::default();
         let crate_sel = &outputs.crate_sel;
-        if outputs.exit_code != 0 {
-            report.problems.push(Problem::BuildScriptFailed(
-                crate::problem::BinExecutionFailed {
-                    output: outputs.clone(),
-                    crate_sel: crate_sel.clone(),
-                },
-            ));
-            return Ok(report);
-        }
         let perm_sel = PermSel::for_build_script(crate_sel.pkg_name());
         let allow_build_instructions = config
             .permissions
@@ -117,7 +108,7 @@ mod tests {
             stderr: vec![],
             crate_sel: CrateSel::build_script(pkg_id("my_pkg")),
             sandbox_config: SandboxConfig::default(),
-            build_script: PathBuf::new(),
+            binary_path: PathBuf::new(),
             sandbox_config_display: None,
         };
         super::BuildScriptReport::build(&outputs, &config)

src/checker.rs

@@ -242,7 +242,15 @@ impl Checker {
                 Ok(ProblemList::default())
             }
             rpc::Request::BinExecutionComplete(output) => {
-                if output.crate_sel.kind == CrateKind::BuildScript {
+                if output.exit_code != 0 {
+                    Ok(
+                        Problem::ExecutionFailed(crate::problem::BinExecutionFailed {
+                            output: output.clone(),
+                            crate_sel: output.crate_sel.clone(),
+                        })
+                        .into(),
+                    )
+                } else if output.crate_sel.kind == CrateKind::BuildScript {
                     let report =
                         build_script_checker::BuildScriptReport::build(output, &self.config)?;
                     crate::sandbox::write_env_vars(

src/config_editor.rs

@@ -94,7 +94,7 @@ pub(crate) fn fixes_for_problem(problem: &Problem, config: &Config) -> Vec<Box<d
                 perm_sel: PermSel::for_primary(pkg_id.pkg_name()),
             }));
         }
-        Problem::BuildScriptFailed(failure) => {
+        Problem::ExecutionFailed(failure) => {
             if failure.output.sandbox_config.kind != Some(SandboxKind::Disabled) {
                 let perm_sel = PermSel::for_build_script(failure.crate_sel.pkg_name());
                 if !failure.output.sandbox_config.allow_network.unwrap_or(false) {
@@ -1337,7 +1337,7 @@ mod tests {
     #[test]
     fn build_script_failed() {
         let crate_sel = CrateSel::build_script(pkg_id("crab1"));
-        let failure = Problem::BuildScriptFailed(crate::problem::BinExecutionFailed {
+        let failure = Problem::ExecutionFailed(crate::problem::BinExecutionFailed {
             output: BinExecutionOutput {
                 exit_code: 1,
                 stdout: Vec::new(),
@@ -1350,7 +1350,7 @@ mod tests {
                     bind_writable: vec![],
                     make_writable: vec![],
                 },
-                build_script: PathBuf::new(),
+                binary_path: PathBuf::new(),
                 sandbox_config_display: None,
             },
             crate_sel,

src/problem.rs

@@ -35,7 +35,7 @@ pub(crate) enum Problem {
     IsProcMacro(PackageId),
     DisallowedApiUsage(ApiUsages),
     OffTreeApiUsage(OffTreeApiUsage),
-    BuildScriptFailed(BinExecutionFailed),
+    ExecutionFailed(BinExecutionFailed),
     DisallowedBuildInstruction(DisallowedBuildInstruction),
     UnusedPackageConfig(PermSel),
     UnusedAllowApi(UnusedAllowApi),
@@ -181,7 +181,7 @@ impl Problem {
     fn should_send_retry_to_subprocess(&self) -> bool {
         matches!(
             self,
-            &Problem::BuildScriptFailed(..) | &Problem::DisallowedUnsafe(..)
+            &Problem::ExecutionFailed(..) | &Problem::DisallowedUnsafe(..)
         )
     }
 
@@ -222,7 +222,7 @@ impl Problem {
             Problem::IsProcMacro(pkg_id) => Some(pkg_id),
             Problem::DisallowedApiUsage(d) => Some(&d.pkg_id),
             Problem::OffTreeApiUsage(d) => Some(&d.usages.pkg_id),
-            Problem::BuildScriptFailed(d) => Some(d.crate_sel.pkg_id()),
+            Problem::ExecutionFailed(d) => Some(d.crate_sel.pkg_id()),
             Problem::DisallowedBuildInstruction(d) => Some(&d.pkg_id),
             Problem::UnusedPackageConfig(_) => None,
             Problem::UnusedAllowApi(_) => None,
@@ -282,7 +282,7 @@ impl Display for Problem {
                     display_usages(f, &info.usages.usages)?;
                 }
             }
-            Problem::BuildScriptFailed(info) => info.fmt(f)?,
+            Problem::ExecutionFailed(info) => info.fmt(f)?,
             Problem::DisallowedBuildInstruction(info) => {
                 write!(
                     f,

src/proxy/rpc.rs

@@ -53,7 +53,7 @@ impl RpcClient {
         read_from_stream(&mut ipc)
     }
 
-    pub(crate) fn build_script_complete(&self, info: BinExecutionOutput) -> Result<Outcome> {
+    pub(crate) fn bin_execution_complete(&self, info: BinExecutionOutput) -> Result<Outcome> {
         let mut ipc = self.connect()?;
         write_to_stream(&Request::BinExecutionComplete(info), &mut ipc)?;
         read_from_stream(&mut ipc)
@@ -96,7 +96,7 @@ pub(crate) struct BinExecutionOutput {
     pub(crate) stderr: Vec<u8>,
     pub(crate) crate_sel: CrateSel,
     pub(crate) sandbox_config: SandboxConfig,
-    pub(crate) build_script: PathBuf,
+    pub(crate) binary_path: PathBuf,
     /// A display string for how the sandbox was configured (e.g. the command line). Only present if
     /// the exit code is non-zero.
     pub(crate) sandbox_config_display: Option<String>,

src/proxy/subprocess.rs

@@ -152,15 +152,15 @@ fn proxy_binary(
         };
 
         let output = sandbox.run(&command)?;
-        let rpc_response = rpc_client.build_script_complete({
+        let rpc_response = rpc_client.bin_execution_complete({
             let exit_code = output.status.code().unwrap_or(-1);
             BinExecutionOutput {
                 exit_code,
                 stdout: output.stdout.clone(),
                 stderr: output.stderr.clone(),
                 crate_sel: crate_sel.clone(),
                 sandbox_config,
-                build_script: orig_bin.clone(),
+                binary_path: orig_bin.clone(),
                 sandbox_config_display: (exit_code != 0)
                     .then(|| sandbox.display_to_run(&command).to_string()),
             }