docs: remove version from readme

Updates the requirements on [toml](https://github.com/toml-rs/toml) to
permit the latest version.
<details>
<summary>Commits</summary>
<ul>
<li><a
href="c28f9ac30f"><code>c28f9ac</code></a>
chore: Release</li>
<li><a
href="f3a2299148"><code>f3a2299</code></a>
docs: Update changelog</li>
<li><a
href="69f09d3093"><code>69f09d3</code></a>
fix(lex): Don't loop over ')' for forever (<a
href="https://redirect.github.com/toml-rs/toml/issues/1003">#1003</a>)</li>
<li><a
href="cc68ae4f42"><code>cc68ae4</code></a>
fix(lex): Don't loop over ')' for forever</li>
<li><a
href="8c8ef44ea1"><code>8c8ef44</code></a>
chore: Release</li>
<li><a
href="b60ac5bfe9"><code>b60ac5b</code></a>
fix(toml): Correct minimal version for indexmap (<a
href="https://redirect.github.com/toml-rs/toml/issues/998">#998</a>)</li>
<li><a
href="966bd40511"><code>966bd40</code></a>
fix(toml): Correct minimal version for indexmap</li>
<li><a
href="2ed2af6519"><code>2ed2af6</code></a>
docs(readme): Mention additional crates</li>
<li><a
href="c7d93e5524"><code>c7d93e5</code></a>
chore: Release</li>
<li><a
href="1ac3aa136c"><code>1ac3aa1</code></a>
chore: Release</li>
<li>Additional commits viewable in <a
href="https://github.com/toml-rs/toml/compare/toml-v0.8.0...toml-v0.9.2">compare
view</a></li>
</ul>
</details>
<br />


Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

convert/Cargo.toml

@@ -13,7 +13,7 @@ description = "Traits to make Rust types usable with Extism"
 anyhow = "1.0.75"
 base64 = "~0.22"
 bytemuck = {version = "1.14.0", optional = true }
-prost = { version = "0.13.1", optional = true }
+prost = { version = "0.14.1", optional = true }
 protobuf = { version = "3.2.0", optional = true }
 rmp-serde = { version = "1.1.2", optional = true }
 serde = "1.0.186"

runtime/Cargo.toml

@@ -9,29 +9,46 @@ repository.workspace = true
 version.workspace = true
 
 [dependencies]
-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"}
+wasmtime = { version = ">= 27.0.0, < 31.0.0", default-features = false, features = [
+  'cache',
+  'gc',
+  'gc-drc',
+  'cranelift',
+  'coredump',
+  'wat',
+  'parallel-compilation',
+  'pooling-allocator',
+  'demangle',
+] }
+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 = { version = "1", features = ["derive"] }
 serde_json = "1"
-toml = "0.8"
+toml = "0.9"
 sha2 = "0.10"
 tracing = "0.1"
-tracing-subscriber = {version = "0.3.18", features = ["std", "env-filter", "fmt"]}
+tracing-subscriber = { version = "0.3.18", features = [
+  "std",
+  "env-filter",
+  "fmt",
+] }
 url = "2"
 glob = "0.3"
-ureq = {version = "3.0", optional=true}
+ureq = { version = "3.0", optional = true }
 extism-manifest = { workspace = true }
 extism-convert = { workspace = true, features = ["extism-path"] }
 uuid = { version = "1", features = ["v4"] }
 libc = "0.2"
 
 [features]
-default = ["http", "register-http", "register-filesystem"]
-register-http = ["ureq"] # enables wasm to be downloaded using http
-register-filesystem = [] # enables wasm to be loaded from disk
-http = ["ureq"]          # enables extism_http_request
+default = ["http", "register-http", "register-filesystem", "wasmtime-default-features"]
+register-http = ["ureq"]                                   # enables wasm to be downloaded using http
+register-filesystem = []                                   # enables wasm to be loaded from disk
+http = ["ureq"]                                            # enables extism_http_request
+wasmtime-default-features = [
+  'wasmtime/default',
+]
 
 [build-dependencies]
 cbindgen = { version = "0.29", default-features = false }

runtime/README.md

@@ -12,7 +12,7 @@ To use the `extism` crate, you can add it to your Cargo file:
 
 ```toml
 [dependencies]
-extism = "1.4.1"
+extism = "*"
 ```
 
 ## Environment variables
@@ -112,7 +112,8 @@ let mut plugin = Plugin::new(&manifest, [], true);
 let res = plugin.call::<&str, &str>("count_vowels", "Yellow, world!").unwrap();
 println!("{}", res);
 # => {"count": 3, "total": 3, "vowels": "aeiouAEIOU"}
-let mut plugin = Plugin::new(&manifest, [], true).with_config_key("vowels", "aeiouyAEIOUY");
+let manifest = Manifest::new([url]).with_config_key("vowels", "aeiouyAEIOUY");
+let mut plugin = Plugin::new(&manifest, [], true).unwrap();
 let res = plugin.call::<&str, &str>("count_vowels", "Yellow, world!").unwrap();
 println!("{}", res);
 # => {"count": 4, "total": 4, "vowels": "aeiouyAEIOUY"}

runtime/src/pdk.rs

@@ -258,12 +258,16 @@ pub(crate) fn http_request(
             };
             let buf: &[u8] = data.memory_bytes(handle)?;
             let agent = ureq::agent();
-            let config = agent.configure_request(r.body(buf)?);
+            let config = agent
+                .configure_request(r.body(buf)?)
+                .http_status_as_error(false);
             let req = config.timeout_global(timeout).build();
             ureq::run(req)
         } else {
             let agent = ureq::agent();
-            let config = agent.configure_request(r.body(())?);
+            let config = agent
+                .configure_request(r.body(())?)
+                .http_status_as_error(false);
             let req = config.timeout_global(timeout).build();
             ureq::run(req)
         };

runtime/src/pool.rs

@@ -1,4 +1,7 @@
 use crate::{Error, FromBytesOwned, Plugin, ToBytes};
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::sync::RwLock;
 
 // `PoolBuilder` is used to configure and create `Pool`s
 #[derive(Debug, Clone)]
@@ -79,7 +82,8 @@ unsafe impl Sync for PoolInner {}
 #[derive(Clone)]
 pub struct Pool {
     config: PoolBuilder,
-    inner: std::sync::Arc<std::sync::Mutex<PoolInner>>,
+    inner: Arc<std::sync::Mutex<PoolInner>>,
+    existing_functions: Arc<RwLock<HashMap<String, bool>>>,
 }
 
 unsafe impl Send for Pool {}
@@ -88,13 +92,7 @@ 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(),
-            })),
-        }
+        Self::new_from_builder(Box::new(source), PoolBuilder::default())
     }
 
     /// Create a new pool configured using a `PoolBuilder`
@@ -104,10 +102,11 @@ impl Pool {
     ) -> Self {
         Pool {
             config: builder,
-            inner: std::sync::Arc::new(std::sync::Mutex::new(PoolInner {
+            inner: Arc::new(std::sync::Mutex::new(PoolInner {
                 plugin_source: Box::new(source),
                 instances: Default::default(),
             })),
+            existing_functions: RwLock::new(HashMap::default()).into(),
         }
     }
 
@@ -171,4 +170,26 @@ impl Pool {
         }
         Ok(None)
     }
+
+    /// Returns `true` if the given function exists, otherwise `false`. Results are cached
+    /// after the first call.
+    pub fn function_exists(&self, name: &str, timeout: std::time::Duration) -> Result<bool, Error> {
+        // read current value if any
+        let read = self.existing_functions.read().unwrap();
+        let exists_opt = read.get(name).cloned();
+        drop(read);
+        if let Some(exists) = exists_opt {
+            Ok(exists)
+        } else {
+            // load plugin and call function_exists
+            let plugin = self.get(timeout)?;
+            let exists = plugin.unwrap().0.borrow().function_exists(name);
+
+            // write result to hashmap
+            let mut write = self.existing_functions.write().unwrap();
+            write.insert(name.to_string(), exists);
+
+            Ok(exists)
+        }
+    }
 }

runtime/src/tests/kernel.rs

@@ -225,26 +225,6 @@ fn test_kernel_allocations() {
     extism_free(&mut store, instance, q);
 }
 
-#[test]
-fn test_kernel_page_allocations() {
-    let (mut store, mut instance) = init_kernel_test();
-    let instance = &mut instance;
-
-    let a = extism_alloc(&mut store, instance, 65500 * 4);
-    let a_size = extism_length(&mut store, instance, a);
-    let b = extism_alloc(&mut store, instance, 65539);
-
-    extism_free(&mut store, instance, a);
-    let c = extism_alloc(&mut store, instance, 65500 * 2);
-    let c_size = extism_length(&mut store, instance, c);
-
-    let d = extism_alloc(&mut store, instance, 65536);
-
-    assert_eq!(a + (a_size - c_size), c);
-    assert!(c < b);
-    assert!(d < b);
-}
-
 #[test]
 fn test_kernel_error() {
     let (mut store, mut instance) = init_kernel_test();
@@ -456,32 +436,3 @@ quickcheck! {
         true
     }
 }
-
-quickcheck! {
-    fn check_block_reuse(allocs: Vec<u16>) -> bool {
-        let (mut store, mut instance) = init_kernel_test();
-        let instance = &mut instance;
-        let init = extism_alloc(&mut store, instance, allocs.iter().map(|x| *x as u64).sum::<u64>() + (allocs.len() as u64 * (65535 + 128)));
-        let bounds = init + extism_length(&mut store, instance, init);
-        extism_free(&mut store, instance, init);
-        for a in allocs {
-            let ptr = extism_alloc(&mut store, instance, a as u64 + 65535);
-            if ptr == 0 {
-                continue
-            }
-            if extism_length(&mut store, instance, ptr) != a as u64 + 65535  {
-                println!("FAILED ALLOC");
-                return false
-            }
-
-            extism_free(&mut store, instance, ptr);
-
-            if ptr > bounds {
-                println!("ptr={ptr}, bounds={bounds}");
-                return false
-            }
-        }
-
-        true
-    }
-}

runtime/src/tests/pool.rs

@@ -1,10 +1,11 @@
 use crate::*;
+use std::time::Duration;
 
 fn run_thread(p: Pool, i: u64) -> std::thread::JoinHandle<()> {
     std::thread::spawn(move || {
-        std::thread::sleep(std::time::Duration::from_millis(i));
+        std::thread::sleep(Duration::from_millis(i));
         let s: String = p
-            .get(std::time::Duration::from_secs(1))
+            .get(Duration::from_secs(1))
             .unwrap()
             .unwrap()
             .call("count_vowels", "abc")
@@ -13,17 +14,20 @@ fn run_thread(p: Pool, i: u64) -> std::thread::JoinHandle<()> {
     })
 }
 
+fn init(max_instances: usize) -> Pool {
+    let data = include_bytes!("../../../wasm/code.wasm");
+    let plugin_builder =
+        extism::PluginBuilder::new(extism::Manifest::new([extism::Wasm::data(data)]))
+            .with_wasi(true);
+    PoolBuilder::new()
+        .with_max_instances(max_instances)
+        .build(move || plugin_builder.clone().build())
+}
+
 #[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 pool = init(i);
         let threads = vec![
             run_thread(pool.clone(), 1000),
             run_thread(pool.clone(), 1000),
@@ -46,3 +50,14 @@ fn test_threads() {
         assert!(pool.count() <= i);
     }
 }
+
+#[test]
+fn test_exists() -> Result<(), Error> {
+    let pool = init(1);
+    let timeout = Duration::from_secs(1);
+    assert!(pool.function_exists("count_vowels", timeout)?);
+    assert!(pool.function_exists("count_vowels", timeout)?);
+    assert!(!pool.function_exists("not_existing", timeout)?);
+    assert!(!pool.function_exists("not_existing", timeout)?);
+    Ok(())
+}