fixup: use tmp dir

Author: not-matthias

go-runner/Cargo.lock

@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 anyhow = "1.0.98"
-clap = { version = "4.5.41", features = ["derive"] }
+clap = { version = "4.5", features = ["derive"] }
 env_logger = "0.11.8"
 glob = "0.3.2"
 gosyn = "0.2.9"
@@ -18,8 +18,8 @@ serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.141"
 statrs = { version = "0.18.0", default-features = false }
 thiserror = "2.0.12"
+tempfile = "3.14.0"
 
 [dev-dependencies]
 insta = { version = "1.43.1", features = ["json", "redactions"] }
-rstest = "0.25.0"
-tempfile = "3.14.0"
+rstest = "0.26"

go-runner/Cargo.toml

@@ -3,6 +3,7 @@ use std::path::{Path, PathBuf};
 
 use handlebars::Handlebars;
 use serde::{Deserialize, Serialize};
+use tempfile::TempDir;
 
 use crate::builder::{BenchmarkData, GoPackage};
 use crate::utils;
@@ -52,26 +53,9 @@ struct TemplateData {
     module_name: String,
 }
 
-pub fn run(package: &GoPackage) -> anyhow::Result<(PathBuf, PathBuf)> {
-    // TODO:
-    // [x] 1. Symlink the files to /tmp -> either just the test files or
-    // [x] 2. Rename the _test.go files to _codspeed.go
-    // [x] 3. Generate the codspeed/runner.go file using the template
-
+pub fn run(package: &GoPackage) -> anyhow::Result<(TempDir, PathBuf)> {
     // 1. Copy the whole module to a build directory
-    //
-    // FIXME: Use tmp folder
-    let target_dir = PathBuf::from(format!(
-        "/tmp/go-build/build-{}",
-        package.name() // Path::new(&package.dir)
-                       //     .file_name()
-                       //     .unwrap()
-                       //     .to_string_lossy()
-    ));
-    // FIXME: Create once and reuse for all the packages
-    if target_dir.exists() {
-        fs::remove_dir_all(&target_dir).context("Failed to remove existing target directory")?;
-    }
+    let target_dir = TempDir::new()?;
     std::fs::create_dir_all(&target_dir).context("Failed to create target directory")?;
     utils::copy_dir_all(&package.module.dir, &target_dir)?;
 
@@ -90,13 +74,12 @@ pub fn run(package: &GoPackage) -> anyhow::Result<(PathBuf, PathBuf)> {
     info!("Relative package path: {}", relative_package_path.display());
 
     // 2. Find benchmark files and patch only their imports
-    let benchmark_files = find_benchmark_files(&target_dir, relative_package_path, files)?;
+    let benchmark_files = find_benchmark_files(target_dir.path(), relative_package_path, files)?;
     patcher::patch_imports(&target_dir, benchmark_files)?;
 
     // 3. Rename the _test.go files to _codspeed.go
-
     for file in files {
-        let old_path = target_dir.join(relative_package_path).join(file);
+        let old_path = target_dir.path().join(relative_package_path).join(file);
         let new_path = old_path.with_file_name(
             old_path
                 .file_name()
@@ -118,24 +101,25 @@ pub fn run(package: &GoPackage) -> anyhow::Result<(PathBuf, PathBuf)> {
     let template_content = include_str!("template.go");
     handlebars.register_template_string("main", template_content)?;
 
-    // TODO:
-    // - Find the benchmarks + their names
-    // - Find their imports and qualified names and everything
-    //
-
     // import <alias> <mod_path>
     // { "<name>", <qualified_path> },
     let data = TemplateData {
         benchmarks: package.benchmarks()?,
-        module_name: "asdf".into(), // TODO: Do we need this?
+        module_name: "codspeed_runner".into(),
     };
     let rendered = handlebars.render("main", &data)?;
 
     let runner_path = target_dir
+        .path()
         .join(relative_package_path)
         .join("codspeed/runner.go");
-    fs::create_dir_all(target_dir.join(relative_package_path).join("codspeed"))
-        .context("Failed to create codspeed directory")?;
+    fs::create_dir_all(
+        target_dir
+            .path()
+            .join(relative_package_path)
+            .join("codspeed"),
+    )
+    .context("Failed to create codspeed directory")?;
     fs::write(&runner_path, rendered).context("Failed to write runner.go file")?;
 
     Ok((target_dir, runner_path))

go-runner/src/builder/templater.rs

@@ -26,26 +26,23 @@ pub fn build_benchmarks(project_dir: &Path, binary_dir: &Path) -> anyhow::Result
         .sum();
     info!("Total benchmarks discovered: {total_benchmarks}");
 
+    debug!("Creating binary directory: {}", binary_dir.display());
+    std::fs::create_dir_all(binary_dir)?;
+
     // 2. Generate codspeed runners
     let mut binaries = Vec::new();
     for (package_name, package) in &benchmark_packages {
         info!("Processing package: {package_name}");
-        let (_, runner_path) = builder::templater::run(package)?;
+        let (_target_dir, runner_path) = builder::templater::run(package)?;
 
         // 3. Run the benchmarks
         info!("Building benchmarks for: {}", runner_path.display());
-        binaries.push(builder::runner::build(&runner_path)?);
-    }
-
-    // 4. Copy them to the binary folder
-    debug!("Creating binary directory: {}", binary_dir.display());
-    std::fs::create_dir_all(binary_dir)?;
+        let binary_path = builder::runner::build(&runner_path)?;
 
-    let mut copied_binaries = Vec::new();
-    for binary_path in &binaries {
+        // 4. Copy the binaries to the binary directory
         // Create a unique filename to avoid accidentally overwriting existing benchmarks.
         let filename = binary_path.file_name().unwrap().to_string_lossy();
-        let unique_filename = format!("{}_{:08x}", filename, rand::random::<u32>());
+        let unique_filename: String = format!("{}_{:08x}", filename, rand::random::<u32>());
         let target_path = binary_dir.join(unique_filename);
 
         debug!(
@@ -54,10 +51,10 @@ pub fn build_benchmarks(project_dir: &Path, binary_dir: &Path) -> anyhow::Result
             target_path.display()
         );
         std::fs::copy(binary_path, &target_path)?;
-        copied_binaries.push(target_path);
+        binaries.push(target_path);
     }
 
-    Ok(copied_binaries)
+    Ok(binaries)
 }
 
 pub fn run_benchmarks(bench: &str, binary_dir: &Path) -> anyhow::Result<()> {