Merge pull request rust-lang#1661 from Kobzol/cargo-lock-check

Check that `Cargo.lock` doesn't change

Author: Kobzol

collector/src/compile/execute/mod.rs

@@ -5,6 +5,7 @@ use crate::compile::benchmark::profile::Profile;
 use crate::compile::benchmark::scenario::Scenario;
 use crate::compile::benchmark::BenchmarkName;
 use crate::toolchain::Toolchain;
+use crate::utils::fs::EnsureImmutableFile;
 use crate::{async_command_output, command_output, utils};
 use anyhow::Context;
 use bencher::Bencher;
@@ -203,6 +204,12 @@ impl<'a> CargoProcess<'a> {
         );
 
         loop {
+            // Make sure that Cargo.lock isn't changed by the build
+            let _guard = EnsureImmutableFile::new(
+                &self.cwd.join("Cargo.lock"),
+                self.processor_name.0.clone(),
+            )?;
+
             // Get the subcommand. If it's not `rustc` it must should be a
             // subcommand that itself invokes `rustc` (so that the `FAKE_RUSTC`
             // machinery works).
@@ -316,6 +323,7 @@ impl<'a> CargoProcess<'a> {
 
             let cmd = tokio::process::Command::from(cmd);
             let output = async_command_output(cmd).await?;
+
             if let Some((ref mut processor, scenario, scenario_str, patch)) = self.processor_etc {
                 let data = ProcessOutputData {
                     name: self.processor_name.clone(),

collector/src/runtime/benchmark.rs

@@ -1,5 +1,6 @@
 use crate::runtime_group_step_name;
 use crate::toolchain::Toolchain;
+use crate::utils::fs::EnsureImmutableFile;
 use anyhow::Context;
 use benchlib::benchmark::passes_filter;
 use cargo_metadata::Message;
@@ -195,6 +196,14 @@ pub fn prepare_runtime_benchmark_suite(
 
         let target_dir = temp_dir.as_ref().map(|d| d.path());
 
+        // Make sure that Cargo.lock isn't changed by the build if we're running in isolated mode
+        let _guard = match isolation_mode {
+            CargoIsolationMode::Cached => None,
+            CargoIsolationMode::Isolated => Some(EnsureImmutableFile::new(
+                &benchmark_crate.path.join("Cargo.lock"),
+                benchmark_crate.name.clone(),
+            )?),
+        };
         let result = start_cargo_build(toolchain, &benchmark_crate.path, target_dir, &opts)
             .with_context(|| {
                 anyhow::anyhow!("Cannot start compilation of {}", benchmark_crate.name)

collector/src/utils/fs.rs

@@ -1,7 +1,9 @@
 use anyhow::Context;
+use std::collections::hash_map::DefaultHasher;
 use std::ffi::OsStr;
 use std::fs;
-use std::path::{Component, Path};
+use std::hash::{Hash, Hasher};
+use std::path::{Component, Path, PathBuf};
 use std::process::Command;
 
 #[cfg(windows)]
@@ -142,6 +144,46 @@ pub fn robocopy(
     Ok(())
 }
 
+/// Loads contents of a file and hashes it when it is created.
+/// It then asserts that when it is dropped, the file still has the same contents.
+#[must_use = "EnsureImmutableFile acts like a guard, consider keeping it alive until something can happen with the file"]
+pub struct EnsureImmutableFile {
+    path: PathBuf,
+    hash: u64,
+    name: String,
+}
+
+impl EnsureImmutableFile {
+    pub fn new(path: &Path, name: String) -> anyhow::Result<Self> {
+        let hash = Self::hash(path)?;
+        Ok(Self {
+            path: path.to_path_buf(),
+            hash,
+            name,
+        })
+    }
+
+    fn hash(path: &Path) -> anyhow::Result<u64> {
+        let contents = fs::read(path)?;
+        let mut hasher = DefaultHasher::new();
+        contents.hash(&mut hasher);
+        Ok(hasher.finish())
+    }
+}
+
+impl Drop for EnsureImmutableFile {
+    fn drop(&mut self) {
+        let hash = Self::hash(&self.path).expect("Cannot hash file");
+        assert_eq!(
+            self.hash,
+            hash,
+            "{} ({}) has changed during a build",
+            self.path.display(),
+            self.name
+        );
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::get_file_count_and_size;