Implement tidying of collector cache directory

Author: Kobzol

collector/src/bin/collector.rs

@@ -65,8 +65,13 @@ use database::{
     CommitType, Connection, Pool,
 };
 
+/// Directory used to cache downloaded Rust toolchains on disk.
 const TOOLCHAIN_CACHE_DIRECTORY: &str = "cache";
 
+/// Maximum allowed number of toolchains in the toolchain cache directory.
+/// If the directory will have more toolchains, it will be purged.
+const TOOLCHAIN_CACHE_MAX_TOOLCHAINS: usize = 30;
+
 fn n_normal_benchmarks_remaining(n: usize) -> String {
     let suffix = if n == 1 { "" } else { "s" };
     format!("{n} normal benchmark{suffix} remaining")
@@ -1434,6 +1439,8 @@ async fn run_job_queue_benchmarks(
     all_compile_benchmarks: Vec<Benchmark>,
     check_git_sha: bool,
 ) -> anyhow::Result<()> {
+    let _ = tidy_toolchain_cache_dir();
+
     let mut last_request_tag = None;
 
     while let Some((benchmark_job, artifact_id)) = conn
@@ -1444,20 +1451,25 @@ async fn run_job_queue_benchmarks(
         )
         .await?
     {
+        // Are we benchmarking a different benchmark request than in the previous iteration of the
+        // loop?
+        let is_new_request = last_request_tag.is_some()
+            && last_request_tag.as_deref() != Some(benchmark_job.request_tag());
+        if is_new_request {
+            let _ = tidy_toolchain_cache_dir();
+        }
+
         // Here we check if we should update our commit SHA, if rustc-perf has been updated.
         // We only check for updates when we switch *benchmark requests*, not *benchmark jobs*,
         // to avoid changing code in the middle of benchmarking the same request.
         // Note that if an update happens, the job that we have just dequeued will have its deque
         // counter increased. But since updates are relatively rare, that shouldn't be a big deal,
         // it will be dequeued again when the collector starts again.
-        if check_git_sha
-            && last_request_tag.is_some()
-            && last_request_tag.as_deref() != Some(benchmark_job.request_tag())
-            && needs_git_update(collector)
-        {
+        if check_git_sha && is_new_request && needs_git_update(collector) {
             log::warn!("Exiting collector to update itself from git.");
             return Ok(());
         }
+
         last_request_tag = Some(benchmark_job.request_tag().to_string());
 
         log::info!("Dequeued job {benchmark_job:?}, artifact_id {artifact_id:?}");
@@ -1523,6 +1535,26 @@ async fn run_job_queue_benchmarks(
     Ok(())
 }
 
+/// Check the toolchain cache directory and delete it if it grows too large.
+/// Currently, we just assume that "too large" means "has more than N toolchains".
+fn tidy_toolchain_cache_dir() -> std::io::Result<()> {
+    let dir_count = Path::new(TOOLCHAIN_CACHE_DIRECTORY)
+        .read_dir()?
+        .filter_map(|e| e.ok())
+        .filter_map(|d| d.file_type().ok())
+        .filter(|t| t.is_dir())
+        .count();
+    if dir_count > TOOLCHAIN_CACHE_MAX_TOOLCHAINS {
+        log::warn!(
+            "Purging toolchain cache directory at {}",
+            TOOLCHAIN_CACHE_DIRECTORY.display()
+        );
+        // Just remove the whole directory, to avoid having to figure out which toolchains are old
+        std::fs::remove_dir_all(TOOLCHAIN_CACHE_DIRECTORY)?;
+    }
+    Ok(())
+}
+
 /// Returns true if the commit SHA of collector does not match the latest commit SHA of the master
 /// branch of https://github.com/rust-lang/rustc-perf.
 fn needs_git_update(collector: &CollectorConfig) -> bool {
@@ -1606,8 +1638,6 @@ async fn run_benchmark_job(
             };
             // Avoid redownloading the same sysroot multiple times for different jobs, even
             // across collector restarts.
-
-            // TODO: Periodically clear the cache directory to avoid running out of disk space.
             sysroot.preserve();
             Toolchain::from_sysroot(&sysroot, commit.sha.clone())
         }