add audits and exemptions for new component-async-tests deps

In order to convince `cargo vet` that we only needed these deps to be
`safe-to-run` (not necessarily `safe-to-deploy`, since it's test code), I've
moved the `wasm-compose` dep to the `dev-dependencies` section of the
`Cargo.toml` file, which required rearranging some code.

I've exempted `wasm-compose` since it's a BA project, and also exempted all but
one of the remaining new deps since they each get well over 10,000 downloads per
day from crates.io.  I've audited and certified the remaining dep, `im-rc`,
which came in a bit shy of the 10,000-per-day mark.

Signed-off-by: Joel Dice <[email protected]>

Author: dicej

crates/misc/component-async-tests/Cargo.toml

@@ -22,7 +22,6 @@ tokio = { workspace = true, features = [
   "rt-multi-thread",
   "time",
 ] }
-wasm-compose = { workspace = true }
 wasmparser = { workspace = true }
 wasmtime = { workspace = true, features = [
   "default",
@@ -33,6 +32,7 @@ wasmtime = { workspace = true, features = [
 wasmtime-wasi = { workspace = true }
 
 [dev-dependencies]
+wasm-compose = { workspace = true }
 test-programs-artifacts = { workspace = true }
 bytes = { workspace = true }
 once_cell = { version = "1.12.0" }

crates/misc/component-async-tests/src/util.rs

@@ -1,47 +1,3 @@
-use std::collections::HashMap;
-use std::env;
-use std::ops::Deref;
-use std::path::Path;
-use std::sync::{Arc, LazyLock, Once};
-use std::time::Duration;
-
-use anyhow::{Result, anyhow, bail};
-use futures::stream::{FuturesUnordered, TryStreamExt};
-use tokio::fs;
-use tokio::sync::Mutex;
-use wasm_compose::composer::ComponentComposer;
-use wasmtime::component::{Component, Linker, ResourceTable};
-use wasmtime::{Config, Engine, Store};
-use wasmtime_wasi::p2::WasiCtxBuilder;
-
-use super::{Ctx, sleep};
-
-pub fn init_logger() {
-    static ONCE: Once = Once::new();
-    ONCE.call_once(env_logger::init);
-}
-
-pub fn config() -> Config {
-    init_logger();
-
-    let mut config = Config::new();
-    if env::var_os("MIRI_TEST_CWASM_DIR").is_some() {
-        config.target("pulley64").unwrap();
-        config.memory_reservation(1 << 20);
-        config.memory_guard_size(0);
-        config.signals_based_traps(false);
-    } else {
-        config.cranelift_debug_verifier(true);
-    }
-    config.wasm_component_model(true);
-    config.wasm_component_model_async(true);
-    config.wasm_component_model_async_builtins(true);
-    config.wasm_component_model_async_stackful(true);
-    config.wasm_component_model_error_context(true);
-    config.async_support(true);
-    config
-}
-
 pub async fn sleep(duration: std::time::Duration) {
     if cfg!(miri) {
         // TODO: We should be able to use `tokio::time::sleep` here, but as of
@@ -95,189 +51,3 @@ pub async fn sleep(duration: std::time::Duration) {
         tokio::time::sleep(duration).await;
     }
 }
-
-/// Compose two components
-///
-/// a is the "root" component, and b is composed into it
-#[allow(unused)]
-async fn compose(a: &[u8], b: &[u8]) -> Result<Vec<u8>> {
-    let dir = tempfile::tempdir()?;
-
-    let a_file = dir.path().join("a.wasm");
-    fs::write(&a_file, a).await?;
-
-    let b_file = dir.path().join("b.wasm");
-    fs::write(&b_file, b).await?;
-
-    ComponentComposer::new(
-        &a_file,
-        &wasm_compose::config::Config {
-            dir: dir.path().to_owned(),
-            definitions: vec![b_file.to_owned()],
-            ..Default::default()
-        },
-    )
-    .compose()
-}
-
-pub async fn make_component(engine: &Engine, components: &[&str]) -> Result<Component> {
-    fn cwasm_name(components: &[&str]) -> Result<String> {
-        if components.is_empty() {
-            Err(anyhow!("expected at least one path"))
-        } else {
-            let names = components
-                .iter()
-                .map(|&path| {
-                    let path = Path::new(path);
-                    if let Some(name) = path.file_name() {
-                        Ok(name)
-                    } else {
-                        Err(anyhow!(
-                            "expected path with at least two components; got: {}",
-                            path.display()
-                        ))
-                    }
-                })
-                .collect::<Result<Vec<_>>>()?;
-
-            Ok(format!(
-                "{}.cwasm",
-                names
-                    .iter()
-                    .map(|name| { name.to_str().unwrap() })
-                    .collect::<Vec<_>>()
-                    .join("+")
-            ))
-        }
-    }
-
-    async fn compile(engine: &Engine, components: &[&str]) -> Result<Vec<u8>> {
-        match components {
-            [component] => engine.precompile_component(&fs::read(component).await?),
-            [a, b] => engine
-                .precompile_component(&compose(&fs::read(a).await?, &fs::read(b).await?).await?),
-            _ => Err(anyhow!("expected one or two paths")),
-        }
-    }
-
-    async fn load(engine: &Engine, components: &[&str]) -> Result<Vec<u8>> {
-        let cwasm_path = if let Some(cwasm_dir) = &env::var_os("MIRI_TEST_CWASM_DIR") {
-            Some(Path::new(cwasm_dir).join(cwasm_name(components)?))
-        } else {
-            None
-        };
-
-        if let Some(cwasm_path) = &cwasm_path {
-            if let Ok(compiled) = fs::read(cwasm_path).await {
-                return Ok(compiled);
-            }
-        }
-
-        if cfg!(miri) {
-            bail!(
-                "Running these tests with miri requires precompiled .cwasm files.\n\
-                 Please set the `MIRI_TEST_CWASM_DIR` environment variable to the\n\
-                 absolute path of a valid directory, then run the test(s)\n\
-                 _without_ miri, and finally run them again _with_ miri."
-            )
-        }
-
-        let compiled = compile(engine, components).await?;
-        if let Some(cwasm_path) = &cwasm_path {
-            fs::write(cwasm_path, &compiled).await?;
-        }
-        Ok(compiled)
-    }
-
-    static CACHE: LazyLock<Mutex<HashMap<Vec<String>, Arc<Mutex<Option<Arc<Vec<u8>>>>>>>> =
-        LazyLock::new(|| Mutex::new(HashMap::new()));
-
-    let compiled = {
-        let entry = CACHE
-            .lock()
-            .await
-            .entry(components.iter().map(|&s| s.to_owned()).collect())
-            .or_insert_with(|| Arc::new(Mutex::new(None)))
-            .clone();
-
-        let mut entry = entry.lock().await;
-        if let Some(component) = entry.deref() {
-            component.clone()
-        } else {
-            let component = Arc::new(load(engine, components).await?);
-            *entry = Some(component.clone());
-            component
-        }
-    };
-
-    Ok(unsafe { Component::deserialize(&engine, &*compiled)? })
-}
-
-#[allow(unused)]
-pub async fn test_run(components: &[&str]) -> Result<()> {
-    test_run_with_count(components, 3).await
-}
-
-pub async fn test_run_with_count(components: &[&str], count: usize) -> Result<()> {
-    let mut config = config();
-    // As of this writing, miri/pulley/epochs is a problematic combination, so
-    // we don't test it.
-    if env::var_os("MIRI_TEST_CWASM_DIR").is_none() {
-        config.epoch_interruption(true);
-    }
-
-    let engine = Engine::new(&config)?;
-
-    let component = make_component(&engine, components).await?;
-
-    let mut linker = Linker::new(&engine);
-
-    wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;
-    super::yield_host::bindings::local::local::continue_::add_to_linker::<_, Ctx>(
-        &mut linker,
-        |ctx| ctx,
-    )?;
-    super::yield_host::bindings::local::local::ready::add_to_linker::<_, Ctx>(
-        &mut linker,
-        |ctx| ctx,
-    )?;
-    super::resource_stream::bindings::local::local::resource_stream::add_to_linker::<_, Ctx>(
-        &mut linker,
-        |ctx| ctx,
-    )?;
-    sleep::local::local::sleep::add_to_linker::<_, Ctx>(&mut linker, |ctx| ctx)?;
-
-    let mut store = Store::new(
-        &engine,
-        Ctx {
-            wasi: WasiCtxBuilder::new().inherit_stdio().build(),
-            table: ResourceTable::default(),
-            continue_: false,
-            wakers: Arc::new(std::sync::Mutex::new(None)),
-        },
-    );
-
-    if env::var_os("MIRI_TEST_CWASM_DIR").is_none() {
-        store.set_epoch_deadline(1);
-
-        std::thread::spawn(move || {
-            std::thread::sleep(Duration::from_secs(10));
-            engine.increment_epoch();
-        });
-    }
-
-    let instance = linker.instantiate_async(&mut store, &component).await?;
-    let yield_host = super::yield_host::bindings::YieldHost::new(&mut store, &instance)?;
-
-    // Start `count` concurrent calls and then join them all:
-    let mut futures = FuturesUnordered::new();
-    for _ in 0..count {
-        futures.push(yield_host.local_local_run().call_run(&mut store));
-    }
-
-    while let Some(()) = instance.run(&mut store, futures.try_next()).await?? {
-        // continue
-    }
-
-    Ok(())
-}

crates/misc/component-async-tests/tests/scenario/backpressure.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 
-use component_async_tests::util::test_run;
+use super::util::test_run;
 
 // No-op function; we only test this by composing it in `async_backpressure_caller`
 #[allow(

crates/misc/component-async-tests/tests/scenario/borrowing.rs

@@ -2,14 +2,13 @@ use std::env;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
+use super::util::{config, make_component};
 use anyhow::Result;
 use futures::stream::{FuturesUnordered, TryStreamExt};
 use wasmtime::component::{Linker, ResourceTable};
 use wasmtime::{Engine, Store};
 use wasmtime_wasi::p2::WasiCtxBuilder;
 
-use component_async_tests::util::{config, make_component};
-
 #[tokio::test]
 pub async fn async_borrowing_caller() -> Result<()> {
     test_run_bool(

crates/misc/component-async-tests/tests/scenario/error_context.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 
-use component_async_tests::util::test_run;
+use super::util::test_run;
 
 #[tokio::test]
 pub async fn async_error_context() -> Result<()> {

crates/misc/component-async-tests/tests/scenario/mod.rs

@@ -1,3 +1,5 @@
+mod util;
+
 pub mod backpressure;
 pub mod borrowing;
 pub mod error_context;

crates/misc/component-async-tests/tests/scenario/post_return.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 
-use component_async_tests::util::test_run;
+use super::util::test_run;
 
 // No-op function; we only test this by composing it in `async_post_return_caller`
 #[allow(

crates/misc/component-async-tests/tests/scenario/read_resource_stream.rs

@@ -1,7 +1,6 @@
+use super::util::test_run;
 use anyhow::Result;
 
-use component_async_tests::util::test_run;
-
 #[tokio::test]
 pub async fn async_read_resource_stream() -> Result<()> {
     test_run(&[test_programs_artifacts::ASYNC_READ_RESOURCE_STREAM_COMPONENT]).await

crates/misc/component-async-tests/tests/scenario/round_trip.rs

@@ -7,7 +7,10 @@ use std::sync::{
 use std::task::{Context, Wake, Waker};
 use std::time::Duration;
 
+use super::util::{config, make_component};
 use anyhow::{Result, anyhow};
+use component_async_tests::Ctx;
+use component_async_tests::util::sleep;
 use futures::{
     FutureExt,
     channel::oneshot,
@@ -18,10 +21,6 @@ use wasmtime::component::{Accessor, AccessorTask, HasSelf, Instance, Linker, Res
 use wasmtime::{Engine, Store};
 use wasmtime_wasi::p2::WasiCtxBuilder;
 
-use component_async_tests::Ctx;
-
-pub use component_async_tests::util::{config, make_component, sleep};
-
 #[tokio::test]
 pub async fn async_round_trip_stackful() -> Result<()> {
     test_round_trip_uncomposed(test_programs_artifacts::ASYNC_ROUND_TRIP_STACKFUL_COMPONENT).await

crates/misc/component-async-tests/tests/scenario/round_trip_direct.rs

@@ -1,15 +1,15 @@
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
+use super::util::{config, make_component};
 use anyhow::{Result, anyhow};
+use component_async_tests::Ctx;
+use component_async_tests::util::sleep;
 use futures::stream::{FuturesUnordered, TryStreamExt};
 use wasmtime::component::{Linker, ResourceTable, Val};
 use wasmtime::{Engine, Store};
 use wasmtime_wasi::p2::WasiCtxBuilder;
 
-use component_async_tests::Ctx;
-use component_async_tests::util::{config, make_component, sleep};
-
 #[tokio::test]
 pub async fn async_round_trip_direct_stackless() -> Result<()> {
     test_round_trip_direct_uncomposed(