fix(manifest): derive JsonSchema for LocalPath

As mentioned in
https://github.com/extism/extism/pull/696/files#r1993086470, the key
parameter doesnt seem very useful. You can achieve the same effect by
doing `HashMap<Key, PluginPool>` in the client code.

---------

Co-authored-by: zach <zach@dylibso.com>

.github/dependabot.yml

@@ -9,33 +9,8 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "weekly"
+    ignore:
+      - dependency-name: "wasmtime"
+      - dependency-name: "wasi-common"
+      - dependency-name: "wiggle"
 
-  - package-ecosystem: "pip"
-    directory: "python"
-    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "mix"
-    directory: "elixir"
-    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "npm"
-    directory: "node"
-    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "composer"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "bundler"
-    directory: "ruby"
-    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "gomod"
-    directory: "/"
-    schedule:
-      interval: "weekly"

.github/workflows/ci.yml

@@ -52,7 +52,7 @@ jobs:
         shell: bash
         run: cargo build --release -p ${{ env.LIBEXTISM_CRATE }}
       - name: Upload artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: libextism-${{ matrix.os }}
           path: |

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

@@ -20,10 +20,13 @@ jobs:
         uses: actions/setup-dotnet@v3.0.3
         with:
            dotnet-version: 7.x
-      - uses: dawidd6/action-download-artifact@v6
-        with:
-          workflow: release.yml
-          name: release-artifacts
+      - 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 }}
       - name: Extract Archive
         run: |      
           extract_archive() {

.github/workflows/release.yml

@@ -7,11 +7,6 @@ on:
 
 name: Release
 
-env:
-  RUNTIME_MANIFEST: runtime/Cargo.toml
-  RUNTIME_CRATE: libextism
-  RUSTFLAGS: -C target-feature=-crt-static
-  ARTIFACT_DIR: release-artifacts
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -21,6 +16,11 @@ jobs:
   release:
     name: ${{ matrix.os }} ${{ matrix.target }}
     runs-on: ${{ matrix.os }}-latest
+    env:
+      RUNTIME_MANIFEST: runtime/Cargo.toml
+      RUNTIME_CRATE: libextism
+      RUSTFLAGS: -C target-feature=-crt-static
+      ARTIFACT_DIR: release-artifacts-${{ matrix.os }}-${{ matrix.target }}
     strategy:
       matrix:
         include:
@@ -38,20 +38,6 @@ jobs:
             static-dll-artifact: ''
             pc-in: 'extism.pc.in'
             static-pc-in: 'extism-static.pc.in'
-          - os: 'ubuntu'
-            target: 'aarch64-linux-android'
-            artifact: 'libextism.so'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: ''
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
-          - os: 'ubuntu'
-            target: 'x86_64-linux-android'
-            artifact: 'libextism.so'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: ''
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
           - os: 'ubuntu'
             target: 'aarch64-unknown-linux-gnu'
             artifact: 'libextism.so'
@@ -206,7 +192,7 @@ jobs:
           ls -ll ${DEST_DIR}
 
       - name: Upload Artifact to Summary
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ env.ARTIFACT_DIR }}
           path: ${{ env.ARTIFACT_DIR }}
@@ -225,9 +211,10 @@ jobs:
     needs: [release]
     if: github.ref == 'refs/heads/main'
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: ${{ env.ARTIFACT_DIR }}
+          pattern: release-artifacts-*
+          merge-multiple: true
 
       - uses: "marvinpinto/action-automatic-releases@latest"
         with:

README.md

@@ -36,6 +36,22 @@ function linking, and more. Extism users build:
 - web applications
 - & much more...
 
+# Supported Targets
+
+We currently provide releases for the following targets:
+
+- aarch64-apple-darwin
+- aarch64-unknown-linux-gnu
+- aarch64-unknown-linux-musl
+- x86_64-apple-darwin
+- x86_64-pc-windows-gnu
+- x86_64-pc-windows-msvc
+- x86_64-unknown-linux-gnu
+- x86_64-unknown-linux-musl
+
+For Android we suggest taking a look at the [Chicory SDK](https://github.com/extism/chicory-sdk) for a pure Java
+Extism runtime.
+
 # Run WebAssembly In Your App
 
 Pick a SDK to import into your program, and refer to the documentation to get

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(ToJson)]`");
+    ensure!(!encodings.is_empty(), "encoding needs to be specified"; try = "`#[encoding(Json)]`");
     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(ToJson)]`"),
+        |e| error_message!(e.span(), "{e}"; note= "expects a path"; try = "`#[encoding(Json)]`"),
     )?)
 }
 

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

@@ -1,6 +1,6 @@
 error: encoding needs to be specified
 
-         = try: `#[encoding(ToJson)]`
+         = try: `#[encoding(Json)]`
  --> 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(ToJson)]`
+         = try: `#[encoding(Json)]`
  --> 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(ToJson)]`
+         = try: `#[encoding(Json)]`
   --> 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(ToJson)]`
+         = try: `#[encoding(Json)]`
   --> tests/ui/invalid-encoding.rs:15:21
    |
 15 | #[encoding(something, else)]

convert/src/from_bytes.rs

@@ -141,6 +141,16 @@ 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,6 +61,17 @@ 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,6 +144,14 @@ 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,6 +1,10 @@
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
+mod local_path;
+
+pub use local_path::LocalPath;
+
 #[deprecated]
 pub type ManifestMemory = MemoryOptions;
 
@@ -279,7 +283,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<String, PathBuf>>,
+    pub allowed_paths: Option<BTreeMap<PathBuf, LocalPath>>,
 
     /// The plugin timeout in milliseconds
     #[serde(default)]
@@ -337,15 +341,15 @@ impl Manifest {
     }
 
     /// Add a path to `allowed_paths`
-    pub fn with_allowed_path(mut self, src: String, dest: impl AsRef<Path>) -> Self {
+    pub fn with_allowed_path(mut self, src: impl Into<LocalPath>, dest: impl AsRef<Path>) -> Self {
         let dest = dest.as_ref().to_path_buf();
         match &mut self.allowed_paths {
             Some(p) => {
-                p.insert(src, dest);
+                p.insert(dest, src.into());
             }
             None => {
                 let mut p = BTreeMap::new();
-                p.insert(src, dest);
+                p.insert(dest, src.into());
                 self.allowed_paths = Some(p);
             }
         }
@@ -354,8 +358,8 @@ impl Manifest {
     }
 
     /// Set `allowed_paths`
-    pub fn with_allowed_paths(mut self, paths: impl Iterator<Item = (String, PathBuf)>) -> Self {
-        self.allowed_paths = Some(paths.collect());
+    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());
         self
     }
 

manifest/src/local_path.rs

@@ -0,0 +1,119 @@
+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

@@ -9,9 +9,9 @@ repository.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmtime = {version = ">= 26.0.0, < 27.0.0"}
-wasi-common = {version = ">= 26.0.0, < 27.0.0"}
-wiggle = {version = ">= 26.0.0, < 27.0.0"}
+wasmtime = {version = ">= 27.0.0, < 31.0.0"}
+wasi-common = {version = ">= 27.0.0, < 31.0.0"}
+wiggle = {version = ">= 27.0.0, < 31.0.0"}
 anyhow = "1"
 serde = {version = "1", features = ["derive"]}
 serde_json = "1"
@@ -21,7 +21,7 @@ tracing = "0.1"
 tracing-subscriber = {version = "0.3.18", features = ["std", "env-filter", "fmt"]}
 url = "2"
 glob = "0.3"
-ureq = {version = "2.5", optional=true}
+ureq = {version = "3.0", optional=true}
 extism-manifest = { workspace = true }
 extism-convert = { workspace = true, features = ["extism-path"] }
 uuid = { version = "1", features = ["v4"] }
@@ -34,12 +34,12 @@ register-filesystem = [] # enables wasm to be loaded from disk
 http = ["ureq"]          # enables extism_http_request
 
 [build-dependencies]
-cbindgen = { version = "0.28", default-features = false }
+cbindgen = { version = "0.29", default-features = false }
 
 [dev-dependencies]
-criterion = "0.5.1"
+criterion = "0.6.0"
 quickcheck = "1"
-rand = "0.8.5"
+rand = "0.9.0"
 
 [[bench]]
 name = "bench"

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, see [the docs](https://docs.wasmtime.dev/cli-cache.html) for details about configuration. Setting this to an empty string will disable caching.
+- `EXTISM_CACHE_CONFIG=path/to/config.toml`: enable Wasmtime cache, details [here](#wasmtime-caching)
 
 > *Note*: The debug and coredump info will only be written if the plug-in has an error.
 
@@ -88,7 +88,7 @@ println!("{:?}", res);
 
 ### Plug-in State
 
-Plug-ins may be stateful or stateless. Plug-ins can maintain state b/w calls by the use of variables. Our count vowels plug-in remembers the total number of vowels it's ever counted in the "total" key in the result. You can see this by making subsequent calls to the export:
+Plug-ins may be stateful or stateless. Plug-ins can maintain state between calls by the use of variables. Our count vowels plug-in remembers the total number of vowels it's ever counted in the "total" key in the result. You can see this by making subsequent calls to the export:
 
 ```rust
 let res = plugin.call::<&str, &str>("count_vowels", "Hello, world!").unwrap();
@@ -219,5 +219,52 @@ println!("{}", res);
 # => {"count": 3, "total": 6, "vowels": "aeiouAEIOU"}
 ```
 
+### Logging
 
+Plug-ins can't directly print anything to the console. They can however use Extism's built-in logging functionality, for example the [`log!` macro in the rust-pdk](https://docs.rs/extism-pdk/1.4.0/extism_pdk/macro.log.html) or the [`logInfo` function in the haskell-pdk](https://hackage.haskell.org/package/extism-pdk-1.2.0.0/docs/Extism-PDK.html#v:logInfo).
 
+Inside your host application, the rust-sdk emits these as [tracing](https://github.com/tokio-rs/tracing) events. The simplest way to make the logged messages visible is by adding the `tracing_subscriber` dependency to your crate and then initializing a tracing subscriber at the top of your main function:
+
+```rust
+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

@@ -206,15 +206,16 @@ impl CurrentPlugin {
             anyhow::bail!("expected extism_context to be an externref value",)
         };
 
-        match xs
-            .data_mut(&mut *store)?
-            .downcast_mut::<Box<dyn std::any::Any + Send + Sync>>()
-        {
-            Some(xs) => match xs.downcast_mut::<T>() {
-                Some(xs) => Ok(xs),
-                None => anyhow::bail!("could not downcast extism_context inner value"),
-            },
-            None => anyhow::bail!("could not downcast extism_context"),
+        if let Some(d) = xs.data_mut(&mut *store)? {
+            match d.downcast_mut::<Box<dyn std::any::Any + Send + Sync>>() {
+                Some(xs) => match xs.downcast_mut::<T>() {
+                    Some(xs) => Ok(xs),
+                    None => anyhow::bail!("could not downcast extism_context inner value"),
+                },
+                None => anyhow::bail!("could not downcast extism_context"),
+            }
+        } else {
+            anyhow::bail!("extism_context not found")
         }
     }
 
@@ -351,9 +352,9 @@ impl CurrentPlugin {
 
             if let Some(a) = &manifest.allowed_paths {
                 for (k, v) in a.iter() {
-                    let readonly = k.starts_with("ro:");
+                    let readonly = matches!(v, extism_manifest::LocalPath::ReadOnly(_));
 
-                    let dir_path = if readonly { &k[3..] } else { k };
+                    let dir_path = v.as_path();
 
                     let dir = wasi_common::sync::dir::Dir::from_cap_std(
                         wasi_common::sync::Dir::open_ambient_dir(dir_path, auth)?,
@@ -365,7 +366,7 @@ impl CurrentPlugin {
                         Box::new(dir)
                     };
 
-                    ctx.push_preopened_dir(file, v)?;
+                    ctx.push_preopened_dir(file, k)?;
                 }
             }
 
@@ -476,10 +477,7 @@ impl CurrentPlugin {
             offset: offs,
             length,
         });
-        match s {
-            Ok(s) => Some(s),
-            Err(_) => None,
-        }
+        s.ok()
     }
 
     #[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,6 +29,7 @@ pub(crate) mod manifest;
 pub(crate) mod pdk;
 mod plugin;
 mod plugin_builder;
+mod pool;
 mod readonly_dir;
 mod timer;
 
@@ -43,6 +44,7 @@ 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/manifest.rs

@@ -86,14 +86,16 @@ fn to_module(engine: &Engine, wasm: &extism_manifest::Wasm) -> Result<(String, M
             #[cfg(feature = "register-http")]
             {
                 // Setup request
-                let mut req = ureq::request(method.as_deref().unwrap_or("GET"), url);
+                let mut req = ureq::http::request::Builder::new()
+                    .method(method.as_deref().unwrap_or("GET").to_uppercase().as_str())
+                    .uri(url);
 
                 for (k, v) in headers.iter() {
-                    req = req.set(k, v);
+                    req = req.header(k, v);
                 }
 
                 // Fetch WASM code
-                let mut r = req.call()?.into_reader();
+                let mut r = ureq::run(req.body(())?)?.into_body().into_reader();
                 let mut data = Vec::new();
                 r.read_to_end(&mut data)?;
 

runtime/src/pdk.rs

@@ -233,17 +233,22 @@ pub(crate) fn http_request(
             )));
         }
 
-        let mut r = ureq::request(req.method.as_deref().unwrap_or("GET"), &req.url);
+        let mut r = ureq::http::request::Builder::new()
+            .method(
+                req.method
+                    .as_deref()
+                    .unwrap_or("GET")
+                    .to_uppercase()
+                    .as_str(),
+            )
+            .uri(&req.url);
 
         for (k, v) in req.headers.iter() {
-            r = r.set(k, v);
+            r = r.header(k, v);
         }
 
         // Set HTTP timeout to respect the manifest timeout
-        if let Some(remaining) = data.time_remaining() {
-            r = r.timeout(remaining);
-        }
-
+        let timeout = data.time_remaining();
         let res = if body_offset > 0 {
             let handle = match data.memory_handle(body_offset) {
                 Some(h) => h,
@@ -252,9 +257,15 @@ pub(crate) fn http_request(
                 }
             };
             let buf: &[u8] = data.memory_bytes(handle)?;
-            r.send_bytes(buf)
+            let agent = ureq::agent();
+            let config = agent.configure_request(r.body(buf)?);
+            let req = config.timeout_global(timeout).build();
+            ureq::run(req)
         } else {
-            r.call()
+            let agent = ureq::agent();
+            let config = agent.configure_request(r.body(())?);
+            let req = config.timeout_global(timeout).build();
+            ureq::run(req)
         };
 
         if let Some(handle) = data.memory_handle(body_offset) {
@@ -264,26 +275,26 @@ pub(crate) fn http_request(
         let reader = match res {
             Ok(res) => {
                 if let Some(headers) = &mut data.http_headers {
-                    for name in res.headers_names() {
-                        if let Some(h) = res.header(&name) {
-                            headers.insert(name, h.to_string());
+                    for (name, h) in res.headers() {
+                        if let Ok(h) = h.to_str() {
+                            headers.insert(name.as_str().to_string(), h.to_string());
                         }
                     }
                 }
-                data.http_status = res.status();
-                Some(res.into_reader())
+                data.http_status = res.status().as_u16();
+                Some(res.into_body().into_reader())
             }
             Err(e) => {
                 // Catch timeout and return
                 if let Some(d) = data.time_remaining() {
-                    if e.kind() == ureq::ErrorKind::Io && d.as_nanos() == 0 {
+                    if matches!(e, ureq::Error::Timeout(_)) && d.as_nanos() == 0 {
                         anyhow::bail!("timeout");
                     }
                 }
                 let msg = e.to_string();
-                if let Some(res) = e.into_response() {
-                    data.http_status = res.status();
-                    Some(res.into_reader())
+                if let ureq::Error::StatusCode(res) = e {
+                    data.http_status = res;
+                    None
                 } else {
                     return Err(Error::msg(msg));
                 }

runtime/src/plugin.rs

@@ -1,6 +1,7 @@
 use std::{
     any::Any,
     collections::{BTreeMap, BTreeSet},
+    sync::TryLockError,
 };
 
 use anyhow::Context;
@@ -190,6 +191,7 @@ 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]>),
@@ -855,15 +857,20 @@ impl Plugin {
 
         // Set host context
         let r = if let Some(host_context) = host_context {
-            let inner = self
+            if let Some(inner) = self
                 .host_context
                 .data_mut(&mut self.store)
-                .map_err(|x| (x, -1))?;
-            if let Some(inner) = inner.downcast_mut::<Box<dyn std::any::Any + Send + Sync>>() {
-                let x: Box<T> = Box::new(host_context);
-                *inner = x;
+                .map_err(|x| (x, -1))?
+            {
+                if let Some(inner) = inner.downcast_mut::<Box<dyn std::any::Any + Send + Sync>>() {
+                    let x: Box<T> = Box::new(host_context);
+                    *inner = x;
+                }
+
+                Some(self.host_context)
+            } else {
+                None
             }
-            Some(self.host_context)
         } else {
             None
         };
@@ -906,7 +913,7 @@ impl Plugin {
         let mut res = func.call(self.store_mut(), &[], results.as_mut_slice());
 
         // Reset host context
-        if let Ok(inner) = self.host_context.data_mut(&mut self.store) {
+        if let Ok(Some(inner)) = self.host_context.data_mut(&mut self.store) {
             if let Some(inner) = inner.downcast_mut::<Box<dyn std::any::Any + Send + Sync>>() {
                 let x: Box<dyn Any + Send + Sync> = Box::new(());
                 *inner = x;
@@ -1083,7 +1090,12 @@ impl Plugin {
         input: T,
     ) -> Result<U, Error> {
         let lock = self.instance.clone();
-        let mut lock = lock.lock().unwrap();
+        let mut lock = lock.try_lock().map_err(|e| match e {
+            TryLockError::Poisoned(_) => anyhow::anyhow!(
+                "instance lock was poisoned; previous thread panicked while calling into wasm"
+            ),
+            TryLockError::WouldBlock => anyhow::anyhow!("cannot make reentrant calls into plugin"),
+        })?;
         let data = input.to_bytes()?;
         self.raw_call(&mut lock, name, data, None::<()>)
             .map_err(|e| e.0)
@@ -1108,7 +1120,12 @@ impl Plugin {
         C: Any + Send + Sync + 'static,
     {
         let lock = self.instance.clone();
-        let mut lock = lock.lock().unwrap();
+        let mut lock = lock.try_lock().map_err(|e| match e {
+            TryLockError::Poisoned(_) => anyhow::anyhow!(
+                "instance lock was poisoned; previous thread panicked while calling into wasm"
+            ),
+            TryLockError::WouldBlock => anyhow::anyhow!("cannot make reentrant calls into plugin"),
+        })?;
         let data = input.to_bytes()?;
         self.raw_call(&mut lock, name, data, Some(host_context))
             .map_err(|e| e.0)
@@ -1127,7 +1144,18 @@ impl Plugin {
         input: T,
     ) -> Result<U, (Error, i32)> {
         let lock = self.instance.clone();
-        let mut lock = lock.lock().unwrap();
+        let mut lock = lock.try_lock().map_err(|e| match e {
+            TryLockError::Poisoned(_) => (
+                anyhow::anyhow!(
+                    "instance lock was poisoned; previous thread panicked while calling into wasm"
+                ),
+                -1,
+            ),
+            TryLockError::WouldBlock => (
+                anyhow::anyhow!("cannot make reentrant calls into plugin"),
+                -1,
+            ),
+        })?;
         let data = input.to_bytes().map_err(|e| (e, -1))?;
         self.raw_call(&mut lock, name, data, None::<()>)
             .and_then(move |_| self.output().map_err(|e| (e, -1)))

runtime/src/plugin_builder.rs

@@ -33,6 +33,7 @@ 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

@@ -0,0 +1,174 @@
+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/sdk.rs

@@ -180,7 +180,7 @@ pub unsafe extern "C" fn extism_current_plugin_memory_free(
 /// - `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/tests/kernel.rs

@@ -412,7 +412,7 @@ quickcheck! {
 quickcheck! {
     fn check_alloc_with_load_and_store(amounts: Vec<u16>) -> bool {
         use rand::Rng;
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let (mut store, mut instance) = init_kernel_test();
         let instance = &mut instance;
         for a in amounts {
@@ -425,7 +425,7 @@ quickcheck! {
             }
 
             for _ in 0..16 {
-                let i = rng.gen_range(ptr..ptr+a as u64);
+                let i = rng.random_range(ptr..ptr+a as u64);
                 extism_store_u8(&mut store, instance, i, i as u8);
                 if extism_load_u8(&mut store, instance, i as u64) != i as u8 {
                     return false

runtime/src/tests/mod.rs

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

runtime/src/tests/pool.rs

@@ -0,0 +1,48 @@
+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);
+    }
+}