Use prebuilt binaries

Author: smoelius

.github/workflows/ci.yml

@@ -58,8 +58,7 @@ jobs:
 
       - uses: actions/checkout@v5
 
-      - uses: actions/cache/restore@v4
-        id: cache-restore
+      - uses: actions/cache@v4
         with:
           key: ${{ runner.os }}-cargo-${{ hashFiles('Cargo.lock') }}
           path: |
@@ -70,31 +69,15 @@ jobs:
             ~/.cargo/git/db/
             ~/.dylint_drivers/
             ~/.rustup/toolchains/
-            agave/
             target/dylint/
 
       - name: Rustup
         run: rustup update
 
-      - name: Install Agave prerequisites
+      - name: Install Anchor prerequisites
         run: |
           sudo apt update
-          sudo apt install libclang-dev libudev-dev llvm protobuf-compiler
-
-      - name: Install Agave
-        run: |
-          if ! ./agave/bin/solana-test-validator --version; then
-            git clone https://github.com/anza-xyz/agave
-            cd agave
-            # smoelius: The next commit merges `SBPF v0.12.2`: https://github.com/anza-xyz/agave/pull/7498
-            git checkout cd291424d3d71c1a3be0c2c919916dcaa272d162
-            sed -i '/^\[patch\.crates-io\]$/a solana-sbpf = { git = "https://github.com/trail-of-forks/sbpf-coverage" }' Cargo.toml
-            # smoelius: `solana` is not used directly, but it is called by `anchor`.
-            sed -i '/^binArgs=()$/i BINS=(cargo-build-sbf solana-test-validator solana); DCOU_BINS=()' scripts/cargo-install-all.sh
-            ./scripts/cargo-install-all.sh .
-            cd ..
-          fi
-          echo "$PWD/agave/bin" >> "$GITHUB_PATH"
+          sudo apt install libudev-dev
 
       # smoelius: https://www.anchor-lang.com/docs/installation
       - name: Install Anchor
@@ -120,32 +103,22 @@ jobs:
 
       - name: Sanity test fixtures
         run: |
+          AGAVE_TAG="$(cat agave_tag.txt)"
           for X in fixtures/*; do
-            pushd "$X" && yarn && anchor test && popd
+            pushd "$X"
+            yarn
+            wget https://github.com/trail-of-forks/sbpf-coverage/releases/download/$AGAVE_TAG/patched-agave-tools-$AGAVE_TAG-Linux.tar.gz
+            tar xzf patched-agave-tools-$AGAVE_TAG-Linux.tar.gz
+            rm -f patched-agave-tools-$AGAVE_TAG-Linux.tar.gz
+            PATH="$PWD/patched-agave-tools-$AGAVE_TAG-Linux/bin:$PATH"
+            anchor test
+            popd
           done
 
       - name: Test
         run: |
           cargo test --config "$GROUP_RUNNER"
 
-      # https://github.com/actions/cache/tree/main/save#always-save-cache
-      - uses: actions/cache/save@v4
-        # smoelius: Update the cache regardless of whether a cache hit occurred, in case further
-        # progress was made.
-        if: always() # && steps.cache-restore.outputs.cache-hit != 'true'
-        with:
-          key: ${{ runner.os }}-cargo-${{ hashFiles('Cargo.lock') }}
-          path: |
-            ~/.avm
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            ~/.dylint_drivers/
-            ~/.rustup/toolchains/
-            agave/
-            target/dylint/
-
   all-checks:
     needs: [test]
 

.gitignore

@@ -1,3 +1,4 @@
 /target
 /coverage
 /fixtures/*/sbf_trace_dir
+patched-agave-tools-*

agave_tag.txt

@@ -0,0 +1 @@
+v3.0.6

src/bin/anchor-coverage.rs

@@ -1,8 +1,10 @@
-use anchor_coverage::util::StripCurrentDir;
+use anchor_coverage::util::{var_guard::VarGuard, StripCurrentDir};
 use anyhow::{bail, ensure, Result};
 use std::{
-    env::{args, current_dir},
-    fs::{canonicalize, create_dir_all, remove_dir_all},
+    env::{args, current_dir, join_paths, split_paths, var_os},
+    ffi::OsString,
+    fmt::Write,
+    fs::{canonicalize, create_dir_all, read, remove_dir_all},
     path::{Path, PathBuf},
     process::Command,
 };
@@ -34,6 +36,18 @@ Usage: {0} [ANCHOR_TEST_ARGS]...
 
     let current_dir = current_dir()?;
 
+    // smoelius: Set `PATH` now, once and for all. This way subsequent calls to `which` will return
+    // paths to the tools actually used.
+    let _guard: VarGuard;
+    if let Some(path_buf) = anchor_coverage::util::patched_agave_tools(&current_dir)? {
+        eprintln!(
+            "Found patched Agave tools: {}",
+            path_buf.strip_current_dir().display()
+        );
+        let prepended_paths = prepend_paths(path_buf.join("bin"))?;
+        _guard = VarGuard::set("PATH", Some(prepended_paths));
+    }
+
     let sbf_trace_dir = current_dir.join("sbf_trace_dir");
 
     if sbf_trace_dir.try_exists()? {
@@ -48,21 +62,30 @@ Usage: {0} [ANCHOR_TEST_ARGS]...
     let pcs_paths = anchor_coverage::util::files_with_extension(&sbf_trace_dir, "pcs")?;
 
     if pcs_paths.is_empty() {
-        let try_running_message = grep_command()
-            .map(|command| {
-                format!(
-                    " Try running the following command:
-    {command}"
-                )
-            })
-            .unwrap_or_default();
-
-        bail!(
-            "Found no program counter files in: {}
-Are you sure your `solana-test-validator` is patched?{}",
-            sbf_trace_dir.strip_current_dir().display(),
-            try_running_message
+        let mut message = format!(
+            "Found no program counter files in: {}",
+            sbf_trace_dir.strip_current_dir().display()
         );
+        let path = which("solana-test-validator")?;
+        if !solana_test_validator_is_patched(&path)? {
+            #[rustfmt::skip]
+            write!(
+                &mut message,
+                "\n
+`{}` does not appear to be patched.
+
+Either download, unzip, and untar prebuilt patched binaries from:
+
+    https://github.com/trail-of-forks/sbpf-coverage/releases
+
+Or build patched binaries from source using the instructions at:
+
+    https://github.com/trail-of-forks/sbpf-coverage",
+                path.display()
+            )
+            .unwrap();
+        }
+        bail!(message);
     }
 
     anchor_coverage::run(sbf_trace_dir, options.debug)?;
@@ -90,6 +113,16 @@ fn parse_args() -> Options {
     Options { args, debug, help }
 }
 
+fn prepend_paths(path: PathBuf) -> Result<OsString> {
+    let Some(paths) = var_os("PATH") else {
+        bail!("`PATH` is unset");
+    };
+    let paths_split = split_paths(&paths);
+    let paths_chained = std::iter::once(path).chain(paths_split);
+    let paths_joined = join_paths(paths_chained)?;
+    Ok(paths_joined)
+}
+
 fn anchor_test_with_debug(args: &[String], sbf_trace_dir: &Path) -> Result<()> {
     #[cfg(feature = "__anchor_cli")]
     anchor_coverage::__build_with_debug(
@@ -126,12 +159,12 @@ fn anchor_test_skip_build(args: &[String], sbf_trace_dir: &Path) -> Result<()> {
     Ok(())
 }
 
-fn grep_command() -> Result<String> {
-    let path = which("solana-test-validator")?;
-    Ok(format!(
-        "grep SBF_TRACE_DIR {} || echo 'solana-test-validator is not patched'",
-        path.display()
-    ))
+fn solana_test_validator_is_patched(path: &Path) -> Result<bool> {
+    let contents = read(path)?;
+    let needle = "SBF_TRACE_DIR";
+    Ok(contents
+        .windows(needle.len())
+        .any(|w| w == needle.as_bytes()))
 }
 
 fn which(filename: &str) -> Result<PathBuf> {

src/tests.rs

@@ -1,15 +1,27 @@
-use crate::util::files_with_extension;
-use anyhow::{ensure, Result};
+use crate::util::{files_with_extension, patched_agave_tools};
+use anyhow::{anyhow, ensure, Result};
 use assert_cmd::cargo::CommandCargoExt;
 use std::{
     collections::HashSet,
     env::current_dir,
-    fs::read_to_string,
+    fs::{read_to_string, remove_file},
     path::{Path, PathBuf},
     process::Command,
-    sync::Mutex,
+    sync::{LazyLock, Mutex, MutexGuard},
 };
 
+const SBPF_COVERAGE_DOWNLOAD_URL: &str =
+    "https://github.com/trail-of-forks/sbpf-coverage/releases/download";
+
+#[cfg(target_os = "linux")]
+const OS: &str = "Linux";
+
+#[cfg(target_os = "macos")]
+const OS: &str = "macOS";
+
+#[cfg(not(any(target_os = "linux", target_os = "macos")))]
+compile_error!("Only Linux and macOS are supported.");
+
 const BASIC_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/basic");
 const MULTIPLE_TEST_CONFIGS_DIR: &str = concat!(
     env!("CARGO_MANIFEST_DIR"),
@@ -19,14 +31,18 @@ const EXTERNAL_CALL_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/e
 const MULTIPLE_PROGRAMS_DIR: &str =
     concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/multiple_programs");
 
+static AGAVE_TAG: LazyLock<String> = LazyLock::new(|| {
+    read_to_string("agave_tag.txt")
+        .map(|s| s.trim_end().to_owned())
+        .unwrap()
+});
+
 // smoelius: Only one Anchor test can be run at a time.
 static MUTEX: Mutex<()> = Mutex::new(());
 
 #[test]
 fn basic() {
-    let _lock = MUTEX.lock().unwrap();
-
-    yarn(BASIC_DIR).unwrap();
+    let _lock = prepare_for_testing(BASIC_DIR).unwrap();
 
     let mut command = anchor_coverage_command(BASIC_DIR);
     let status = command.status().unwrap();
@@ -53,9 +69,7 @@ fn basic() {
 
 #[test]
 fn multiple_test_configs() {
-    let _lock = MUTEX.lock().unwrap();
-
-    yarn(MULTIPLE_TEST_CONFIGS_DIR).unwrap();
+    let _lock = prepare_for_testing(MULTIPLE_TEST_CONFIGS_DIR).unwrap();
 
     for test_config in ["full", "just_increment_x", "just_increment_y"] {
         let mut command = anchor_coverage_command(MULTIPLE_TEST_CONFIGS_DIR);
@@ -133,9 +147,7 @@ fn multiple_test_configs() {
 
 #[test]
 fn include_cargo_does_not_change_line_hits() {
-    let _lock = MUTEX.lock().unwrap();
-
-    yarn(EXTERNAL_CALL_DIR).unwrap();
+    let _lock = prepare_for_testing(EXTERNAL_CALL_DIR).unwrap();
 
     let report_without_cargo = run_anchor_coverage_and_read_lcov(EXTERNAL_CALL_DIR, false).unwrap();
 
@@ -159,9 +171,7 @@ fn include_cargo_does_not_change_line_hits() {
 
 #[test]
 fn multiple_programs() {
-    let _lock = MUTEX.lock().unwrap();
-
-    yarn(MULTIPLE_PROGRAMS_DIR).unwrap();
+    let _lock = prepare_for_testing(MULTIPLE_PROGRAMS_DIR).unwrap();
 
     let mut command = anchor_coverage_command(MULTIPLE_PROGRAMS_DIR);
     let status = command.status().unwrap();
@@ -201,6 +211,42 @@ fn multiple_programs() {
     }
 }
 
+fn prepare_for_testing(dir: &str) -> Result<MutexGuard<'_, ()>> {
+    download_patched_agave_tools(dir)?;
+
+    yarn(dir)?;
+
+    MUTEX.lock().map_err(|error| anyhow!("{error}"))
+}
+
+fn download_patched_agave_tools(dir: impl AsRef<Path>) -> Result<()> {
+    #[allow(clippy::redundant_pattern_matching)]
+    if let Some(_) = patched_agave_tools(&dir)? {
+        return Ok(());
+    }
+
+    let filename = format!("patched-agave-tools-{}-{}.tar.gz", *AGAVE_TAG, OS);
+
+    let mut command = Command::new("wget");
+    command.arg(format!(
+        "{SBPF_COVERAGE_DOWNLOAD_URL}/{}/{}",
+        *AGAVE_TAG, filename
+    ));
+    command.current_dir(&dir);
+    let status = command.status()?;
+    ensure!(status.success(), "command failed: {command:?}");
+
+    let mut command = Command::new("tar");
+    command.args(["xzf", &filename]);
+    command.current_dir(&dir);
+    let status = command.status()?;
+    ensure!(status.success(), "command failed: {command:?}");
+
+    remove_file(dir.as_ref().join(filename))?;
+
+    Ok(())
+}
+
 fn yarn(dir: &str) -> Result<()> {
     let mut command = Command::new("yarn");
     command.current_dir(dir);

src/util/mod.rs

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use anyhow::{bail, Result};
 use std::{
     env::current_dir,
     ffi::OsStr,
@@ -20,6 +20,40 @@ pub fn files_with_extension(dir: impl AsRef<Path>, extension: &str) -> Result<Ve
     Ok(pcs_paths)
 }
 
+pub fn patched_agave_tools(path: impl AsRef<Path>) -> Result<Option<PathBuf>> {
+    let mut path_bufs = Vec::new();
+    for result in read_dir(path)? {
+        let entry = result?;
+        let path = entry.path();
+        let Some(file_name) = path.file_name() else {
+            continue;
+        };
+        if file_name
+            .to_str()
+            .is_none_or(|s| !s.starts_with("patched-agave-tools-"))
+        {
+            continue;
+        }
+        if !path.is_dir() {
+            eprintln!(
+                "Warning: Found `{}` but it is not a directory. If it contains patched Agave \
+                 tools that you want to use, please unzip and untar it.",
+                path.display()
+            );
+            continue;
+        }
+        path_bufs.push(path);
+    }
+    let mut iter = path_bufs.into_iter();
+    let Some(path_buf) = iter.next() else {
+        return Ok(None);
+    };
+    if iter.next().is_some() {
+        bail!("Found multiple patched Agave tools directories");
+    }
+    Ok(Some(path_buf))
+}
+
 pub trait StripCurrentDir {
     fn strip_current_dir(&self) -> &Self;
 }