Parallelize Cases (#109)

* Parallelize over cases

* Rename the state and driver

* Parallelize execution

* Update the default config of the tool

* Make codebase async

* Fix machete

* Fix tests & clear node directories before startup

* Cleanup the cleanup logic

* Rename geth node

crates/solc-binaries/Cargo.toml

@@ -14,6 +14,7 @@ revive-dt-common = { workspace = true }
 anyhow = { workspace = true }
 hex = { workspace = true }
 tracing = { workspace = true }
+tokio = { workspace = true }
 reqwest = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }

crates/solc-binaries/src/cache.rs

@@ -6,15 +6,17 @@ use std::{
     io::{BufWriter, Write},
     os::unix::fs::PermissionsExt,
     path::{Path, PathBuf},
-    sync::{LazyLock, Mutex},
+    sync::LazyLock,
 };
 
+use tokio::sync::Mutex;
+
 use crate::download::GHDownloader;
 
 pub const SOLC_CACHE_DIRECTORY: &str = "solc";
 pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);
 
-pub(crate) fn get_or_download(
+pub(crate) async fn get_or_download(
     working_directory: &Path,
     downloader: &GHDownloader,
 ) -> anyhow::Result<PathBuf> {
@@ -23,20 +25,20 @@ pub(crate) fn get_or_download(
         .join(downloader.version.to_string());
     let target_file = target_directory.join(downloader.target);
 
-    let mut cache = SOLC_CACHER.lock().unwrap();
+    let mut cache = SOLC_CACHER.lock().await;
     if cache.contains(&target_file) {
         tracing::debug!("using cached solc: {}", target_file.display());
         return Ok(target_file);
     }
 
     create_dir_all(target_directory)?;
-    download_to_file(&target_file, downloader)?;
+    download_to_file(&target_file, downloader).await?;
     cache.insert(target_file.clone());
 
     Ok(target_file)
 }
 
-fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()> {
+async fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()> {
     tracing::info!("caching file: {}", path.display());
 
     let Ok(file) = File::create_new(path) else {
@@ -52,7 +54,7 @@ fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()
     }
 
     let mut file = BufWriter::new(file);
-    file.write_all(&downloader.download()?)?;
+    file.write_all(&downloader.download().await?)?;
     file.flush()?;
     drop(file);
 

crates/solc-binaries/src/download.rs

@@ -25,12 +25,12 @@ impl List {
     ///
     /// Caches the list retrieved from the `url` into [LIST_CACHE],
     /// subsequent calls with the same `url` will return the cached list.
-    pub fn download(url: &'static str) -> anyhow::Result<Self> {
+    pub async fn download(url: &'static str) -> anyhow::Result<Self> {
         if let Some(list) = LIST_CACHE.lock().unwrap().get(url) {
             return Ok(list.clone());
         }
 
-        let body: List = reqwest::blocking::get(url)?.json()?;
+        let body: List = reqwest::get(url).await?.json().await?;
 
         LIST_CACHE.lock().unwrap().insert(url, body.clone());
 
@@ -54,7 +54,7 @@ impl GHDownloader {
     pub const WINDOWS_NAME: &str = "solc-windows.exe";
     pub const WASM_NAME: &str = "soljson.js";
 
-    fn new(
+    async fn new(
         version: impl Into<VersionOrRequirement>,
         target: &'static str,
         list: &'static str,
@@ -67,7 +67,8 @@ impl GHDownloader {
                 list,
             }),
             VersionOrRequirement::Requirement(requirement) => {
-                let Some(version) = List::download(list)?
+                let Some(version) = List::download(list)
+                    .await?
                     .builds
                     .into_iter()
                     .map(|build| build.version)
@@ -85,20 +86,20 @@ impl GHDownloader {
         }
     }
 
-    pub fn linux(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
-        Self::new(version, Self::LINUX_NAME, List::LINUX_URL)
+    pub async fn linux(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
+        Self::new(version, Self::LINUX_NAME, List::LINUX_URL).await
     }
 
-    pub fn macosx(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
-        Self::new(version, Self::MACOSX_NAME, List::MACOSX_URL)
+    pub async fn macosx(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
+        Self::new(version, Self::MACOSX_NAME, List::MACOSX_URL).await
     }
 
-    pub fn windows(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
-        Self::new(version, Self::WINDOWS_NAME, List::WINDOWS_URL)
+    pub async fn windows(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
+        Self::new(version, Self::WINDOWS_NAME, List::WINDOWS_URL).await
     }
 
-    pub fn wasm(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
-        Self::new(version, Self::WASM_NAME, List::WASM_URL)
+    pub async fn wasm(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
+        Self::new(version, Self::WASM_NAME, List::WASM_URL).await
     }
 
     /// Returns the download link.
@@ -110,16 +111,17 @@ impl GHDownloader {
     ///
     /// Errors out if the download fails or the digest of the downloaded file
     /// mismatches the expected digest from the release [List].
-    pub fn download(&self) -> anyhow::Result<Vec<u8>> {
+    pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
         tracing::info!("downloading solc: {self:?}");
-        let expected_digest = List::download(self.list)?
+        let expected_digest = List::download(self.list)
+            .await?
             .builds
             .iter()
             .find(|build| build.version == self.version)
             .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))
             .map(|b| b.sha256.strip_prefix("0x").unwrap_or(&b.sha256).to_string())?;
 
-        let file = reqwest::blocking::get(self.url())?.bytes()?.to_vec();
+        let file = reqwest::get(self.url()).await?.bytes().await?.to_vec();
 
         if hex::encode(Sha256::digest(&file)) != expected_digest {
             anyhow::bail!("sha256 mismatch for solc version {}", self.version);
@@ -133,27 +135,56 @@ impl GHDownloader {
 mod tests {
     use crate::{download::GHDownloader, list::List};
 
-    #[test]
-    fn try_get_windows() {
-        let version = List::download(List::WINDOWS_URL).unwrap().latest_release;
-        GHDownloader::windows(version).unwrap().download().unwrap();
+    #[tokio::test]
+    async fn try_get_windows() {
+        let version = List::download(List::WINDOWS_URL)
+            .await
+            .unwrap()
+            .latest_release;
+        GHDownloader::windows(version)
+            .await
+            .unwrap()
+            .download()
+            .await
+            .unwrap();
     }
 
-    #[test]
-    fn try_get_macosx() {
-        let version = List::download(List::MACOSX_URL).unwrap().latest_release;
-        GHDownloader::macosx(version).unwrap().download().unwrap();
+    #[tokio::test]
+    async fn try_get_macosx() {
+        let version = List::download(List::MACOSX_URL)
+            .await
+            .unwrap()
+            .latest_release;
+        GHDownloader::macosx(version)
+            .await
+            .unwrap()
+            .download()
+            .await
+            .unwrap();
     }
 
-    #[test]
-    fn try_get_linux() {
-        let version = List::download(List::LINUX_URL).unwrap().latest_release;
-        GHDownloader::linux(version).unwrap().download().unwrap();
+    #[tokio::test]
+    async fn try_get_linux() {
+        let version = List::download(List::LINUX_URL)
+            .await
+            .unwrap()
+            .latest_release;
+        GHDownloader::linux(version)
+            .await
+            .unwrap()
+            .download()
+            .await
+            .unwrap();
     }
 
-    #[test]
-    fn try_get_wasm() {
-        let version = List::download(List::WASM_URL).unwrap().latest_release;
-        GHDownloader::wasm(version).unwrap().download().unwrap();
+    #[tokio::test]
+    async fn try_get_wasm() {
+        let version = List::download(List::WASM_URL).await.unwrap().latest_release;
+        GHDownloader::wasm(version)
+            .await
+            .unwrap()
+            .download()
+            .await
+            .unwrap();
     }
 }

crates/solc-binaries/src/lib.rs

@@ -19,22 +19,22 @@ pub mod list;
 ///
 /// Subsequent calls for the same version will use a cached artifact
 /// and not download it again.
-pub fn download_solc(
+pub async fn download_solc(
     cache_directory: &Path,
     version: impl Into<VersionOrRequirement>,
     wasm: bool,
 ) -> anyhow::Result<PathBuf> {
     let downloader = if wasm {
-        GHDownloader::wasm(version)
+        GHDownloader::wasm(version).await
     } else if cfg!(target_os = "linux") {
-        GHDownloader::linux(version)
+        GHDownloader::linux(version).await
     } else if cfg!(target_os = "macos") {
-        GHDownloader::macosx(version)
+        GHDownloader::macosx(version).await
     } else if cfg!(target_os = "windows") {
-        GHDownloader::windows(version)
+        GHDownloader::windows(version).await
     } else {
         unimplemented!()
     }?;
 
-    get_or_download(cache_directory, &downloader)
+    get_or_download(cache_directory, &downloader).await
 }