ci: re-organize release workflow

Fixes #816

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

@@ -1,4 +1,6 @@
 on:
+  release:
+    types: [published, edited]
   workflow_dispatch:
 
 name: Release .NET Native NuGet Packages

.github/workflows/release.yml

@@ -38,6 +38,20 @@ 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'
@@ -98,13 +112,11 @@ jobs:
           pyproject="$(cat extism-maturin/pyproject.toml)"
           <<<"$pyproject" >extism-maturin/pyproject.toml sed -e 's/^version = "0.0.0.replaced-by-ci"/version = "'"$version"'"/g'
 
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: stable
-          profile: minimal
-          override: true
           target: ${{ matrix.target }}
+          override: true
+          toolchain: stable
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -113,11 +125,15 @@ jobs:
           cache-on-failure: "true"
 
       - name: Build Target (${{ matrix.os }} ${{ matrix.target }})
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.os != 'windows' }}
-          command: build
-          args: --release --target ${{ matrix.target }} -p ${{ env.RUNTIME_CRATE }}
+        if: ${{ matrix.os != 'windows' }}
+        run: |
+          cargo install cross
+          cross build --release --target ${{ matrix.target }} -p ${{ env.RUNTIME_CRATE }}
+
+      - name: Build Target (${{ matrix.os }} ${{ matrix.target }})
+        if: ${{ matrix.os == 'windows' }}
+        run: |
+          cargo build --release --target ${{ matrix.target }} -p ${{ env.RUNTIME_CRATE }}
 
       - uses: actions/setup-python@v4
         with:

runtime/Cargo.toml

@@ -34,7 +34,7 @@ register-filesystem = [] # enables wasm to be loaded from disk
 http = ["ureq"]          # enables extism_http_request
 
 [build-dependencies]
-cbindgen = { version = "0.27", default-features = false }
+cbindgen = { version = "0.28", default-features = false }
 
 [dev-dependencies]
 criterion = "0.5.1"

runtime/src/plugin.rs

@@ -325,6 +325,36 @@ fn relink(
         get_log_level() -> I32;
     );
 
+    for (name, module) in modules.iter() {
+        if name == EXTISM_ENV_MODULE {
+            continue;
+        }
+
+        for import in module.imports() {
+            if import.module() == EXTISM_ENV_MODULE
+                && modules[EXTISM_ENV_MODULE]
+                    .get_export(import.name())
+                    .is_none()
+                && linker
+                    .get(&mut store, EXTISM_ENV_MODULE, import.name())
+                    .is_none()
+            {
+                let (kind, ty) = match import.ty() {
+                    ExternType::Func(t) => ("function", t.to_string()),
+                    ExternType::Global(t) => ("global", t.content().to_string()),
+                    ExternType::Table(t) => ("table", t.element().to_string()),
+                    ExternType::Memory(_) => ("memory", String::new()),
+                };
+                anyhow::bail!(
+                    "Invalid {kind} import from extism:host/env: {} {ty}\n\n\
+                    Note: This may indicate that the PDK that was used to build this plugin has additional features that aren't \
+                    available in this version of the SDK, try updating the SDK to the latest version.",
+                    import.name(),
+                )
+            }
+        }
+    }
+
     let mut linked = BTreeSet::new();
     linker.module(&mut store, EXTISM_ENV_MODULE, &modules[EXTISM_ENV_MODULE])?;
     linked.insert(EXTISM_ENV_MODULE.to_string());
@@ -1125,6 +1155,25 @@ impl Plugin {
             anyhow::bail!("Plugin::clear_error failed, extism:host/env::error_set not found")
         }
     }
+
+    /// Returns the amount of fuel consumed by the plugin.
+    ///
+    /// This function calculates the difference between the initial fuel and the remaining fuel.
+    /// If either the initial fuel or the remaining fuel is not set, it returns `None`.
+    ///
+    /// # Returns
+    ///
+    /// * `Some(u64)` - The amount of fuel consumed.
+    /// * `None` - If the initial fuel or remaining fuel is not set.
+    pub fn fuel_consumed(&self) -> Option<u64> {
+        self.fuel.map(|x| {
+            x.saturating_sub(
+                self.store
+                    .get_fuel()
+                    .expect("fuel support should be enabled to use fuel"),
+            )
+        })
+    }
 }
 
 // Enumerates the PDK languages that need some additional initialization

runtime/src/sdk.rs

@@ -352,8 +352,11 @@ pub unsafe extern "C" fn extism_compiled_plugin_new(
         .map(|v| Box::into_raw(Box::new(v)))
         .unwrap_or_else(|e| {
             if !errmsg.is_null() {
-                let e = std::ffi::CString::new(format!("Unable to compile Extism plugin: {}", e))
-                    .unwrap();
+                let e = std::ffi::CString::new(format!(
+                    "Unable to compile Extism plugin: {}",
+                    e.root_cause(),
+                ))
+                .unwrap();
                 *errmsg = e.into_raw();
             }
             std::ptr::null_mut()
@@ -426,8 +429,11 @@ pub unsafe extern "C" fn extism_plugin_new(
         .map(|v| Box::into_raw(Box::new(v)))
         .unwrap_or_else(|e| {
             if !errmsg.is_null() {
-                let e = std::ffi::CString::new(format!("Unable to compile Extism plugin: {}", e))
-                    .unwrap();
+                let e = std::ffi::CString::new(format!(
+                    "Unable to compile Extism plugin: {}",
+                    e.root_cause(),
+                ))
+                .unwrap();
                 *errmsg = e.into_raw();
             }
             std::ptr::null_mut()
@@ -444,8 +450,11 @@ pub unsafe extern "C" fn extism_plugin_new_from_compiled(
     match plugin {
         Err(e) => {
             if !errmsg.is_null() {
-                let e = std::ffi::CString::new(format!("Unable to create Extism plugin: {}", e))
-                    .unwrap();
+                let e = std::ffi::CString::new(format!(
+                    "Unable to create Extism plugin: {}",
+                    e.root_cause(),
+                ))
+                .unwrap();
                 *errmsg = e.into_raw();
             }
             std::ptr::null_mut()
@@ -512,8 +521,11 @@ pub unsafe extern "C" fn extism_plugin_new_with_fuel_limit(
         Ok(x) => x,
         Err(e) => {
             if !errmsg.is_null() {
-                let e = std::ffi::CString::new(format!("Unable to compile Extism plugin: {}", e))
-                    .unwrap();
+                let e = std::ffi::CString::new(format!(
+                    "Unable to compile Extism plugin: {}",
+                    e.root_cause(),
+                ))
+                .unwrap();
                 *errmsg = e.into_raw();
             }
             return std::ptr::null_mut();
@@ -525,8 +537,11 @@ pub unsafe extern "C" fn extism_plugin_new_with_fuel_limit(
     match plugin {
         Err(e) => {
             if !errmsg.is_null() {
-                let e = std::ffi::CString::new(format!("Unable to create Extism plugin: {}", e))
-                    .unwrap();
+                let e = std::ffi::CString::new(format!(
+                    "Unable to create Extism plugin: {}",
+                    e.root_cause(),
+                ))
+                .unwrap();
                 *errmsg = e.into_raw();
             }
             std::ptr::null_mut()

runtime/src/tests/runtime.rs

@@ -258,6 +258,23 @@ fn test_fuel() {
     }
 }
 
+#[test]
+fn test_fuel_consumption() {
+    let manifest = Manifest::new([extism_manifest::Wasm::data(WASM_LOOP)]);
+    let mut plugin = PluginBuilder::new(manifest)
+        .with_wasi(true)
+        .with_fuel_limit(10000)
+        .build()
+        .unwrap();
+
+    let output: Result<&[u8], Error> = plugin.call("loop_forever", "abc123");
+    assert!(output.is_err());
+
+    let fuel_consumed = plugin.fuel_consumed().unwrap();
+    println!("Fuel consumed: {}", fuel_consumed);
+    assert!(fuel_consumed > 0);
+}
+
 #[test]
 #[cfg(feature = "http")]
 fn test_http_timeout() {

runtime/src/timer.rs

@@ -92,25 +92,39 @@ impl Timer {
             loop {
                 if plugins.is_empty() {
                     if let Ok(x) = rx.recv() {
-                        handle!(x)
+                        handle!(x);
                     }
                 }
 
-                plugins = plugins
-                    .into_iter()
-                    .filter(|(_k, (engine, end))| {
-                        if let Some(end) = end {
-                            let now = std::time::Instant::now();
-                            if end <= &now {
-                                engine.increment_epoch();
-                                return false;
+                let mut timeout: Option<std::time::Duration> = None;
+
+                plugins.retain(|_k, (engine, end)| {
+                    if let Some(end) = end {
+                        let now = std::time::Instant::now();
+                        if *end <= now {
+                            engine.increment_epoch();
+                            return false;
+                        } else {
+                            let time_left =
+                                (*end - now).saturating_sub(std::time::Duration::from_millis(1));
+                            if let Some(t) = &timeout {
+                                if time_left < *t {
+                                    timeout = Some(time_left);
+                                }
+                            } else {
+                                timeout = Some(time_left);
                             }
                         }
-                        true
-                    })
-                    .collect();
+                    }
 
-                for x in rx.try_iter() {
+                    true
+                });
+
+                if let Some(timeout) = timeout {
+                    if let Ok(x) = rx.recv_timeout(timeout) {
+                        handle!(x)
+                    }
+                } else if let Ok(x) = rx.recv() {
                     handle!(x)
                 }
             }