chore: update to 2024 edition

.github/dependabot.yml

@@ -9,8 +9,12 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "weekly"
-    ignore:
-      - dependency-name: "wasmtime"
-      - dependency-name: "wasi-common"
-      - dependency-name: "wiggle"
+    groups:
+      # This is the name of your group, it will be used in PR titles and branch names
+      wasmtime-deps:
+        # A pattern can be...
+        patterns:
+          - "wasmtime"
+          - "wasi-common"
+          - "wiggle"
 

.github/workflows/release-dotnet-native.yaml

@@ -20,13 +20,10 @@ jobs:
         uses: actions/setup-dotnet@v3.0.3
         with:
            dotnet-version: 7.x
-      - name: download release
-        run: |
-          tag='${{ github.ref }}'
-          tag="${tag/refs\/tags\//}"
-          gh release download "$tag" -p 'libextism-*.tar.gz'
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: release.yml
+          name: release-artifacts
       - name: Extract Archive
         run: |      
           extract_archive() {

Cargo.toml

@@ -4,7 +4,7 @@ members = ["extism-maturin", "manifest", "runtime", "libextism", "convert", "con
 exclude = ["kernel"]
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 authors = ["The Extism Authors", "oss@extism.org"]
 license = "BSD-3-Clause"
 homepage = "https://extism.org"

convert-macros/src/lib.rs

@@ -34,11 +34,11 @@ fn extract_encoding(attrs: &[Attribute]) -> Result<Path> {
         .iter()
         .filter(|attr| attr.path().is_ident("encoding"))
         .collect();
-    ensure!(!encodings.is_empty(), "encoding needs to be specified"; try = "`#[encoding(Json)]`");
+    ensure!(!encodings.is_empty(), "encoding needs to be specified"; try = "`#[encoding(ToJson)]`");
     ensure!(encodings.len() < 2, encodings[1], "only one encoding can be specified"; try = "remove `{}`", encodings[1].to_token_stream());
 
     Ok(encodings[0].parse_args().map_err(
-        |e| error_message!(e.span(), "{e}"; note= "expects a path"; try = "`#[encoding(Json)]`"),
+        |e| error_message!(e.span(), "{e}"; note= "expects a path"; try = "`#[encoding(ToJson)]`"),
     )?)
 }
 

convert-macros/tests/ui/invalid-encoding.stderr

@@ -1,6 +1,6 @@
 error: encoding needs to be specified
 
-         = try: `#[encoding(Json)]`
+         = try: `#[encoding(ToJson)]`
  --> tests/ui/invalid-encoding.rs:3:10
   |
 3 | #[derive(ToBytes)]
@@ -11,7 +11,7 @@ error: encoding needs to be specified
 error: expected attribute arguments in parentheses: #[encoding(...)]
 
          = note: expects a path
-         = try: `#[encoding(Json)]`
+         = try: `#[encoding(ToJson)]`
  --> tests/ui/invalid-encoding.rs:7:3
   |
 7 | #[encoding]
@@ -20,7 +20,7 @@ error: expected attribute arguments in parentheses: #[encoding(...)]
 error: expected parentheses: #[encoding(...)]
 
          = note: expects a path
-         = try: `#[encoding(Json)]`
+         = try: `#[encoding(ToJson)]`
   --> tests/ui/invalid-encoding.rs:11:12
    |
 11 | #[encoding = "string"]
@@ -29,7 +29,7 @@ error: expected parentheses: #[encoding(...)]
 error: unexpected token
 
          = note: expects a path
-         = try: `#[encoding(Json)]`
+         = try: `#[encoding(ToJson)]`
   --> tests/ui/invalid-encoding.rs:15:21
    |
 15 | #[encoding(something, else)]

convert/src/encoding.rs

@@ -15,7 +15,7 @@ use base64::Engine;
 /// and [`FromBytesOwned`] using [`serde_json::from_slice`]
 #[macro_export]
 macro_rules! encoding {
-    ($pub:vis $name:ident, $to_vec:expr, $from_slice:expr) => {
+    ($pub:vis $name:ident, $to_vec:expr_2021, $from_slice:expr_2021) => {
         #[doc = concat!(stringify!($name), " encoding")]
         #[derive(Debug)]
         $pub struct $name<T>(pub T);

convert/src/from_bytes.rs

@@ -141,16 +141,6 @@ impl FromBytesOwned for u32 {
     }
 }
 
-impl FromBytesOwned for bool {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        if let Some(x) = data.first() {
-            Ok(*x != 0)
-        } else {
-            Err(Error::msg("Expected one byte to read boolean value"))
-        }
-    }
-}
-
 impl FromBytesOwned for () {
     fn from_bytes_owned(_: &[u8]) -> Result<Self, Error> {
         Ok(())

convert/src/tests.rs

@@ -61,17 +61,6 @@ fn rountrip_option() {
     assert_eq!(y.unwrap().0, z.unwrap().0);
 }
 
-#[test]
-fn check_bool() {
-    // `None` case
-    let a = true.to_bytes().unwrap();
-    let b = false.to_bytes().unwrap();
-    assert_ne!(a, b);
-
-    assert_eq!(a, [1]);
-    assert_eq!(b, [0]);
-}
-
 #[cfg(all(feature = "raw", target_endian = "little"))]
 mod raw_tests {
     use crate::*;

convert/src/to_bytes.rs

@@ -144,14 +144,6 @@ impl ToBytes<'_> for u32 {
     }
 }
 
-impl ToBytes<'_> for bool {
-    type Bytes = [u8; 1];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok([*self as u8])
-    }
-}
-
 impl<'a, T: ToBytes<'a>> ToBytes<'a> for &'a T {
     type Bytes = T::Bytes;
 

manifest/src/lib.rs

@@ -1,10 +1,6 @@
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
-mod local_path;
-
-pub use local_path::LocalPath;
-
 #[deprecated]
 pub type ManifestMemory = MemoryOptions;
 
@@ -244,10 +240,10 @@ struct DataPtrLength {
 }
 
 #[cfg(feature = "json_schema")]
-fn wasmdata_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+fn wasmdata_schema(g: &mut schemars::r#gen::SchemaGenerator) -> schemars::schema::Schema {
     use schemars::{schema::SchemaObject, JsonSchema};
-    let mut schema: SchemaObject = <String>::json_schema(gen).into();
-    let objschema: SchemaObject = <DataPtrLength>::json_schema(gen).into();
+    let mut schema: SchemaObject = <String>::json_schema(g).into();
+    let objschema: SchemaObject = <DataPtrLength>::json_schema(g).into();
     let types = schemars::schema::SingleOrVec::<schemars::schema::InstanceType>::Vec(vec![
         schemars::schema::InstanceType::String,
         schemars::schema::InstanceType::Object,
@@ -283,7 +279,7 @@ pub struct Manifest {
     /// the path on disk to the path it should be available inside the plugin.
     /// For example, `".": "/tmp"` would mount the current directory as `/tmp` inside the module
     #[serde(default)]
-    pub allowed_paths: Option<BTreeMap<PathBuf, LocalPath>>,
+    pub allowed_paths: Option<BTreeMap<String, PathBuf>>,
 
     /// The plugin timeout in milliseconds
     #[serde(default)]
@@ -341,15 +337,15 @@ impl Manifest {
     }
 
     /// Add a path to `allowed_paths`
-    pub fn with_allowed_path(mut self, src: impl Into<LocalPath>, dest: impl AsRef<Path>) -> Self {
+    pub fn with_allowed_path(mut self, src: String, dest: impl AsRef<Path>) -> Self {
         let dest = dest.as_ref().to_path_buf();
         match &mut self.allowed_paths {
             Some(p) => {
-                p.insert(dest, src.into());
+                p.insert(src, dest);
             }
             None => {
                 let mut p = BTreeMap::new();
-                p.insert(dest, src.into());
+                p.insert(src, dest);
                 self.allowed_paths = Some(p);
             }
         }
@@ -358,8 +354,8 @@ impl Manifest {
     }
 
     /// Set `allowed_paths`
-    pub fn with_allowed_paths(mut self, paths: impl Iterator<Item = (LocalPath, PathBuf)>) -> Self {
-        self.allowed_paths = Some(paths.map(|(local, wasm)| (wasm, local)).collect());
+    pub fn with_allowed_paths(mut self, paths: impl Iterator<Item = (String, PathBuf)>) -> Self {
+        self.allowed_paths = Some(paths.collect());
         self
     }
 

manifest/src/local_path.rs

@@ -1,119 +0,0 @@
-use std::path::{Path, PathBuf};
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
-pub enum LocalPath {
-    ReadOnly(PathBuf),
-    ReadWrite(PathBuf),
-}
-
-impl LocalPath {
-    pub fn as_path(&self) -> &Path {
-        match self {
-            LocalPath::ReadOnly(p) => p.as_path(),
-            LocalPath::ReadWrite(p) => p.as_path(),
-        }
-    }
-}
-
-impl From<&str> for LocalPath {
-    fn from(value: &str) -> Self {
-        if let Some(s) = value.strip_prefix("ro:") {
-            LocalPath::ReadOnly(PathBuf::from(s))
-        } else {
-            LocalPath::ReadWrite(PathBuf::from(value))
-        }
-    }
-}
-
-impl From<String> for LocalPath {
-    fn from(value: String) -> Self {
-        LocalPath::from(value.as_str())
-    }
-}
-
-impl From<PathBuf> for LocalPath {
-    fn from(value: PathBuf) -> Self {
-        LocalPath::ReadWrite(value)
-    }
-}
-
-impl From<&Path> for LocalPath {
-    fn from(value: &Path) -> Self {
-        LocalPath::ReadWrite(value.to_path_buf())
-    }
-}
-
-impl serde::Serialize for LocalPath {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self {
-            LocalPath::ReadOnly(path) => {
-                let s = match path.to_str() {
-                    Some(s) => s,
-                    None => {
-                        return Err(serde::ser::Error::custom(
-                            "Path contains invalid UTF-8 characters",
-                        ))
-                    }
-                };
-
-                format!("ro:{s}").serialize(serializer)
-            }
-            LocalPath::ReadWrite(path) => path.serialize(serializer),
-        }
-    }
-}
-
-struct LocalPathVisitor;
-
-impl serde::de::Visitor<'_> for LocalPathVisitor {
-    type Value = LocalPath;
-
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("path string")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        Ok(From::from(v))
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        Ok(From::from(v))
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        std::str::from_utf8(v)
-            .map(From::from)
-            .map_err(|_| serde::de::Error::invalid_value(serde::de::Unexpected::Bytes(v), &self))
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        String::from_utf8(v).map(From::from).map_err(|e| {
-            serde::de::Error::invalid_value(serde::de::Unexpected::Bytes(&e.into_bytes()), &self)
-        })
-    }
-}
-
-impl<'de> serde::Deserialize<'de> for LocalPath {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        deserializer.deserialize_string(LocalPathVisitor)
-    }
-}

runtime/Cargo.toml

@@ -34,10 +34,10 @@ register-filesystem = [] # enables wasm to be loaded from disk
 http = ["ureq"]          # enables extism_http_request
 
 [build-dependencies]
-cbindgen = { version = "0.29", default-features = false }
+cbindgen = { version = "0.28", default-features = false }
 
 [dev-dependencies]
-criterion = "0.6.0"
+criterion = "0.5.1"
 quickcheck = "1"
 rand = "0.9.0"
 

runtime/README.md

@@ -24,7 +24,7 @@ There are a few environment variables that can be used for debugging purposes:
 - `EXTISM_COREDUMP=extism.core`: write [coredump](https://github.com/WebAssembly/tool-conventions/blob/main/Coredump.md) to a file when a WebAssembly function traps
 - `EXTISM_DEBUG=1`: generate debug information
 - `EXTISM_PROFILE=perf|jitdump|vtune`: enable Wasmtime profiling
-- `EXTISM_CACHE_CONFIG=path/to/config.toml`: enable Wasmtime cache, details [here](#wasmtime-caching)
+- `EXTISM_CACHE_CONFIG=path/to/config.toml`: enable Wasmtime cache, see [the docs](https://docs.wasmtime.dev/cli-cache.html) for details about configuration. Setting this to an empty string will disable caching.
 
 > *Note*: The debug and coredump info will only be written if the plug-in has an error.
 
@@ -229,42 +229,3 @@ Inside your host application, the rust-sdk emits these as [tracing](https://gith
 tracing_subscriber::fmt::init();
 ```
 
-### Wasmtime Caching
-
-To enable or disable caching for plugin compilation, you need to provide a configuration file that will be used by the [wasmtime crate](https://github.com/bytecodealliance/wasmtime).
-
-For more information and values that can be used for configuring caching, take a look at [the docs](https://docs.wasmtime.dev/cli-cache.html).
-
-> *Note*: As of now extism uses wasmtime [`version = ">= 27.0.0, < 31.0.0"`](https://github.com/extism/extism/blob/v1.11.1/runtime/Cargo.toml#L12), but the `enabled` key requirement [was removed](https://github.com/bytecodealliance/wasmtime/pull/10859) from `wasmtime` and its documentation, this could explain the `failed to parse config file` error you might encounter without it.
-
-An example configuration for caching would be:
-
-```toml
-[cache]
-enabled = true # This value is required
-directory = "/some/path"
-```
-
-You can :
-- [Create a global `wasmtime` configuration file](#using-a-configuration-file) in `$HOME/.config/wasmtime/config.toml`.
-- [Set the `EXTISM_CACHE_CONFIG` environment variable](#using-an-environment-variable)
-- [Set the configuration file path using `PluginBuilder`](#using-pluginbuilder)
-
-#### Using a configuration file
-
-The [wasmtime](https://github.com/bytecodealliance/wasmtime) crate, by default, will look for a configuration file in your systems' default configuration directory (for example on UNIX systems: `$HOME/.config/wasmtime/config.toml`),
-for more [information on this behaviour](`https://docs.rs/wasmtime/31.0.0/wasmtime/struct.Config.html#method.cache_config_load_default`).
-
-#### Using an environment variable
-
-You can set the `EXTISM_CACHE_CONFIG=path/to/config.toml` environment variable to set the path of the configuration file used by [wasmtime](https://github.com/bytecodealliance/wasmtime).
-Setting the variable to an empty string will disable caching (it won't load any configuration file).
-
-> *Note*: If the environment variable is not set, `wasmtime` will still try to read from a configuration file that may exist in your system's default configuration folder (e.g. `$HOME/.config/wasmtime/config.toml`).
-
-The environment variable does not override the path you might have set using `PluginBuilder`. will only be checked for if you did not specify a cache configuration path in `PluginBuilder`.
-
-#### Using PluginBuilder
-
-If you use a [PluginBuilder](https://docs.rs/extism/latest/extism/struct.PluginBuilder.html), you can set the `wasmtime` configuration path using the [with_cache_config](https://docs.rs/extism/latest/extism/struct.PluginBuilder.html#method.with_cache_config) method.
-This will override the `EXTISM_CACHE_CONFIG` environment variable if it's set, so you could have a "global" and per plugin configuration if needed.

runtime/extism.h

@@ -156,7 +156,7 @@ void extism_current_plugin_memory_free(ExtismCurrentPlugin *plugin, ExtismMemory
  * - `n_outputs`: number of return types
  * - `func`: the function to call
  * - `user_data`: a pointer that will be passed to the function when it's called
- *   this value should live as long as the function exists
+ *    this value should live as long as the function exists
  * - `free_user_data`: a callback to release the `user_data` value when the resulting
  *   `ExtismFunction` is freed.
  *

runtime/src/current_plugin.rs

@@ -352,9 +352,9 @@ impl CurrentPlugin {
 
             if let Some(a) = &manifest.allowed_paths {
                 for (k, v) in a.iter() {
-                    let readonly = matches!(v, extism_manifest::LocalPath::ReadOnly(_));
+                    let readonly = k.starts_with("ro:");
 
-                    let dir_path = v.as_path();
+                    let dir_path = if readonly { &k[3..] } else { k };
 
                     let dir = wasi_common::sync::dir::Dir::from_cap_std(
                         wasi_common::sync::Dir::open_ambient_dir(dir_path, auth)?,
@@ -366,7 +366,7 @@ impl CurrentPlugin {
                         Box::new(dir)
                     };
 
-                    ctx.push_preopened_dir(file, k)?;
+                    ctx.push_preopened_dir(file, v)?;
                 }
             }
 
@@ -477,7 +477,10 @@ impl CurrentPlugin {
             offset: offs,
             length,
         });
-        s.ok()
+        match s {
+            Ok(s) => Some(s),
+            Err(_) => None,
+        }
     }
 
     #[doc(hidden)]

runtime/src/function.rs

@@ -284,8 +284,8 @@ impl Function {
 /// A few things worth noting:
 /// - The function always returns a `Result` that wraps the specified return type
 /// - If a first parameter and type are passed (`_user_data` above) followed by a semicolon it will be
-///   the name of the `UserData` parameter and can be used from inside the function
-//    definition.
+///    the name of the `UserData` parameter and can be used from inside the function
+//     definition.
 #[macro_export]
 macro_rules! host_fn {
     ($pub:vis $name: ident  ($($arg:ident : $argty:ty),*) $(-> $ret:ty)? $b:block) => {

runtime/src/lib.rs

@@ -29,7 +29,6 @@ pub(crate) mod manifest;
 pub(crate) mod pdk;
 mod plugin;
 mod plugin_builder;
-mod pool;
 mod readonly_dir;
 mod timer;
 
@@ -44,7 +43,6 @@ pub use plugin::{
     CancelHandle, CompiledPlugin, Plugin, WasmInput, EXTISM_ENV_MODULE, EXTISM_USER_MODULE,
 };
 pub use plugin_builder::{DebugOptions, PluginBuilder};
-pub use pool::{Pool, PoolBuilder, PoolPlugin};
 
 pub(crate) use internal::{Internal, Wasi};
 pub(crate) use timer::{Timer, TimerAction};

runtime/src/plugin.rs

@@ -191,7 +191,6 @@ pub(crate) fn profiling_strategy() -> ProfilingStrategy {
 /// Defines an input type for Wasm data.
 ///
 /// Types that implement `Into<WasmInput>` can be passed directly into `Plugin::new`
-#[derive(Clone)]
 pub enum WasmInput<'a> {
     /// Raw Wasm module
     Data(std::borrow::Cow<'a, [u8]>),

runtime/src/plugin_builder.rs

@@ -33,7 +33,6 @@ impl Default for DebugOptions {
 }
 
 /// PluginBuilder is used to configure and create `Plugin` instances
-#[derive(Clone)]
 pub struct PluginBuilder<'a> {
     pub(crate) source: WasmInput<'a>,
     pub(crate) config: Option<wasmtime::Config>,

runtime/src/pool.rs

@@ -1,174 +0,0 @@
-use crate::{Error, FromBytesOwned, Plugin, ToBytes};
-
-// `PoolBuilder` is used to configure and create `Pool`s
-#[derive(Debug, Clone)]
-pub struct PoolBuilder {
-    /// Max number of concurrent instances for a plugin - by default this is set to
-    /// the output of `std::thread::available_parallelism`
-    pub max_instances: usize,
-}
-
-impl PoolBuilder {
-    /// Create a `PoolBuilder` with default values
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Set the max number of parallel instances
-    pub fn with_max_instances(mut self, n: usize) -> Self {
-        self.max_instances = n;
-        self
-    }
-
-    /// Create a new `Pool` with the given configuration
-    pub fn build<F: 'static + Fn() -> Result<Plugin, Error>>(self, source: F) -> Pool {
-        Pool::new_from_builder(source, self)
-    }
-}
-
-impl Default for PoolBuilder {
-    fn default() -> Self {
-        PoolBuilder {
-            max_instances: std::thread::available_parallelism()
-                .expect("available parallelism")
-                .into(),
-        }
-    }
-}
-
-/// `PoolPlugin` is used by the pool to track the number of live instances of a particular plugin
-#[derive(Clone, Debug)]
-pub struct PoolPlugin(std::rc::Rc<std::cell::RefCell<Plugin>>);
-
-impl PoolPlugin {
-    fn new(plugin: Plugin) -> Self {
-        Self(std::rc::Rc::new(std::cell::RefCell::new(plugin)))
-    }
-
-    /// Access the underlying plugin
-    pub fn plugin(&self) -> std::cell::RefMut<Plugin> {
-        self.0.borrow_mut()
-    }
-
-    /// Helper to call a plugin function on the underlying plugin
-    pub fn call<'a, Input: ToBytes<'a>, Output: FromBytesOwned>(
-        &self,
-        name: impl AsRef<str>,
-        input: Input,
-    ) -> Result<Output, Error> {
-        self.plugin().call(name.as_ref(), input)
-    }
-
-    /// Helper to get the underlying plugin's ID
-    pub fn id(&self) -> uuid::Uuid {
-        self.plugin().id
-    }
-}
-
-type PluginSource = dyn Fn() -> Result<Plugin, Error>;
-
-struct PoolInner {
-    plugin_source: Box<PluginSource>,
-    instances: Vec<PoolPlugin>,
-}
-
-unsafe impl Send for PoolInner {}
-unsafe impl Sync for PoolInner {}
-
-/// `Pool` manages threadsafe access to a limited number of instances of multiple plugins
-#[derive(Clone)]
-pub struct Pool {
-    config: PoolBuilder,
-    inner: std::sync::Arc<std::sync::Mutex<PoolInner>>,
-}
-
-unsafe impl Send for Pool {}
-unsafe impl Sync for Pool {}
-
-impl Pool {
-    /// Create a new pool with the default configuration
-    pub fn new<F: 'static + Fn() -> Result<Plugin, Error>>(source: F) -> Self {
-        Pool {
-            config: Default::default(),
-            inner: std::sync::Arc::new(std::sync::Mutex::new(PoolInner {
-                plugin_source: Box::new(source),
-                instances: Default::default(),
-            })),
-        }
-    }
-
-    /// Create a new pool configured using a `PoolBuilder`
-    pub fn new_from_builder<F: 'static + Fn() -> Result<Plugin, Error>>(
-        source: F,
-        builder: PoolBuilder,
-    ) -> Self {
-        Pool {
-            config: builder,
-            inner: std::sync::Arc::new(std::sync::Mutex::new(PoolInner {
-                plugin_source: Box::new(source),
-                instances: Default::default(),
-            })),
-        }
-    }
-
-    fn find_available(&self) -> Result<Option<PoolPlugin>, Error> {
-        let pool = self.inner.lock().unwrap();
-        for instance in pool.instances.iter() {
-            if std::rc::Rc::strong_count(&instance.0) == 1 {
-                return Ok(Some(instance.clone()));
-            }
-        }
-        Ok(None)
-    }
-
-    /// Get the number of live instances for a plugin
-    pub fn count(&self) -> usize {
-        self.inner.lock().unwrap().instances.len()
-    }
-
-    /// Get access to a plugin, this will create a new instance if needed (and allowed by the specified
-    /// max_instances). `Ok(None)` is returned if the timeout is reached before an available plugin could be
-    /// acquired
-    pub fn get(&self, timeout: std::time::Duration) -> Result<Option<PoolPlugin>, Error> {
-        let start = std::time::Instant::now();
-        let max = self.config.max_instances;
-        if let Some(avail) = self.find_available()? {
-            return Ok(Some(avail));
-        }
-
-        {
-            let mut pool = self.inner.lock().unwrap();
-            if pool.instances.len() < max {
-                let plugin = (*pool.plugin_source)()?;
-                let instance = PoolPlugin::new(plugin);
-                pool.instances.push(instance);
-                return Ok(Some(pool.instances.last().unwrap().clone()));
-            }
-        }
-
-        loop {
-            if let Ok(Some(x)) = self.find_available() {
-                return Ok(Some(x));
-            }
-            if std::time::Instant::now() - start > timeout {
-                return Ok(None);
-            }
-
-            std::thread::sleep(std::time::Duration::from_millis(100));
-        }
-    }
-
-    /// Access a plugin in a callback function. This calls `Pool::get` then the provided
-    /// callback. `Ok(None)` is returned if the timeout is reached before an available
-    /// plugin could be acquired
-    pub fn with_plugin<T>(
-        &self,
-        timeout: std::time::Duration,
-        f: impl FnOnce(&mut Plugin) -> Result<T, Error>,
-    ) -> Result<Option<T>, Error> {
-        if let Some(plugin) = self.get(timeout)? {
-            return f(&mut plugin.plugin()).map(Some);
-        }
-        Ok(None)
-    }
-}

runtime/src/tests/mod.rs

@@ -1,4 +1,3 @@
 mod issues;
 mod kernel;
-mod pool;
 mod runtime;

runtime/src/tests/pool.rs

@@ -1,48 +0,0 @@
-use crate::*;
-
-fn run_thread(p: Pool, i: u64) -> std::thread::JoinHandle<()> {
-    std::thread::spawn(move || {
-        std::thread::sleep(std::time::Duration::from_millis(i));
-        let s: String = p
-            .get(std::time::Duration::from_secs(1))
-            .unwrap()
-            .unwrap()
-            .call("count_vowels", "abc")
-            .unwrap();
-        println!("{}", s);
-    })
-}
-
-#[test]
-fn test_threads() {
-    for i in 1..=3 {
-        let data = include_bytes!("../../../wasm/code.wasm");
-        let plugin_builder =
-            extism::PluginBuilder::new(extism::Manifest::new([extism::Wasm::data(data)]))
-                .with_wasi(true);
-        let pool: Pool = PoolBuilder::new()
-            .with_max_instances(i)
-            .build(move || plugin_builder.clone().build());
-
-        let threads = vec![
-            run_thread(pool.clone(), 1000),
-            run_thread(pool.clone(), 1000),
-            run_thread(pool.clone(), 1000),
-            run_thread(pool.clone(), 1000),
-            run_thread(pool.clone(), 1000),
-            run_thread(pool.clone(), 1000),
-            run_thread(pool.clone(), 500),
-            run_thread(pool.clone(), 500),
-            run_thread(pool.clone(), 500),
-            run_thread(pool.clone(), 500),
-            run_thread(pool.clone(), 500),
-            run_thread(pool.clone(), 0),
-        ];
-
-        for t in threads {
-            t.join().unwrap();
-        }
-
-        assert!(pool.count() <= i);
-    }
-}