Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Migrate wasi-nn to `wasmtime::error` (#12288)

Nick Fitzgerald15339a8f6699
diff --git a/Cargo.lock b/Cargo.lock
index a1efc1ef49..96d00d7150 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5163,7 +5163,6 @@ dependencies = [
name = "wasmtime-wasi-nn"
version = "42.0.0"
dependencies = [
- "anyhow",
"cap-std",
"libtest-mimic",
"openvino",
diff --git a/crates/wasi-nn/Cargo.toml b/crates/wasi-nn/Cargo.toml
index 36859a29df..7bc7e0f75b 100644
--- a/crates/wasi-nn/Cargo.toml
+++ b/crates/wasi-nn/Cargo.toml
@@ -17,7 +17,6 @@ workspace = true
[dependencies]
# These dependencies are necessary for the WITX-generation macros to work:
-anyhow = { workspace = true, features = ['std'] }
wiggle = { workspace = true, features = ["wasmtime"] }
# This dependency is necessary for the WIT-generation macros to work:
diff --git a/crates/wasi-nn/src/backend/mod.rs b/crates/wasi-nn/src/backend/mod.rs
index 608725408b..8ea57c195e 100644
--- a/crates/wasi-nn/src/backend/mod.rs
+++ b/crates/wasi-nn/src/backend/mod.rs
@@ -115,7 +115,7 @@ impl Id {
#[derive(Debug, Error)]
pub enum BackendError {
#[error("Failed while accessing backend")]
- BackendAccess(#[from] anyhow::Error),
+ BackendAccess(#[from] wasmtime::Error),
#[error("Failed while accessing guest module")]
GuestAccess(#[from] GuestError),
#[error("The backend expects {0} buffers, passed {1}")]
@@ -128,7 +128,7 @@ pub enum BackendError {
/// Read a file into a byte vector.
#[allow(dead_code, reason = "not used on all platforms")]
-fn read(path: &Path) -> anyhow::Result<Vec<u8>> {
+fn read(path: &Path) -> wasmtime::Result<Vec<u8>> {
let mut file = File::open(path)?;
let mut buffer = vec![];
file.read_to_end(&mut buffer)?;
diff --git a/crates/wasi-nn/src/backend/onnx.rs b/crates/wasi-nn/src/backend/onnx.rs
index 6ee5835c70..7aaa6bf4ec 100644
--- a/crates/wasi-nn/src/backend/onnx.rs
+++ b/crates/wasi-nn/src/backend/onnx.rs
@@ -112,14 +112,14 @@ impl OnnxExecutionContext {
if i < list.len() {
i
} else {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
+ return Err(BackendError::BackendAccess(wasmtime::format_err!(
"incorrect tensor index: {i} >= {}",
list.len()
)));
}
}
Id::Name(n) => list.iter().position(|s| s.shape.name == n).ok_or_else(|| {
- BackendError::BackendAccess(anyhow::anyhow!("unknown tensor name: {n}"))
+ BackendError::BackendAccess(wasmtime::format_err!("unknown tensor name: {n}"))
})?,
};
Ok(index)
@@ -168,12 +168,12 @@ impl BackendExecutionContext for OnnxExecutionContext {
if idx < self.inputs.len() {
idx
} else {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
- "Input index out of range: {idx}"
- )));
+ return Err(BackendError::BackendAccess(
+ wasmtime::format_err!("Input index out of range: {idx}"),
+ ));
}
} else {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
+ return Err(BackendError::BackendAccess(wasmtime::format_err!(
"Unknown input tensor name: {}",
input.name
)));
@@ -249,7 +249,7 @@ impl BackendExecutionContext for OnnxExecutionContext {
if let Some(tensor) = &output.tensor {
Ok(tensor.clone())
} else {
- Err(BackendError::BackendAccess(anyhow::anyhow!(
+ Err(BackendError::BackendAccess(wasmtime::format_err!(
"missing output tensor: {}; has `compute` been called?",
output.shape.name
)))
@@ -259,7 +259,7 @@ impl BackendExecutionContext for OnnxExecutionContext {
impl From<ort::Error> for BackendError {
fn from(e: ort::Error) -> Self {
- BackendError::BackendAccess(anyhow::anyhow!("{e}"))
+ BackendError::BackendAccess(wasmtime::format_err!("{e}"))
}
}
@@ -300,9 +300,9 @@ impl Shape {
})
}
- fn matches(&self, tensor: &Tensor) -> anyhow::Result<()> {
+ fn matches(&self, tensor: &Tensor) -> wasmtime::Result<()> {
if self.dimensions.len() != tensor.dimensions.len() {
- return Err(anyhow::anyhow!(
+ return Err(wasmtime::format_err!(
"input tensor cardinality does not match model: {:?} != {:?}",
self.dimensions,
tensor.dimensions
@@ -311,7 +311,7 @@ impl Shape {
for (&shape_dim, &tensor_dim) in self.dimensions.iter().zip(tensor.dimensions.iter()) {
let tensor_dim = tensor_dim as i64;
if !is_dynamic_dimension(shape_dim) && shape_dim != tensor_dim {
- return Err(anyhow::anyhow!(
+ return Err(wasmtime::format_err!(
"input tensor dimensions do not match model: {:?} != {:?}",
self.dimensions,
tensor.dimensions
@@ -320,7 +320,7 @@ impl Shape {
}
}
if self.ty != tensor.ty {
- return Err(anyhow::anyhow!(
+ return Err(wasmtime::format_err!(
"input tensor type does not match model: {:?} != {:?}",
self.ty,
tensor.ty
@@ -337,7 +337,7 @@ fn convert_value_type(vt: &ValueType) -> Result<(Vec<i64>, TensorType), BackendE
let ty = (*ty).try_into()?;
Ok((dimensions, ty))
}
- _ => Err(BackendError::BackendAccess(anyhow::anyhow!(
+ _ => Err(BackendError::BackendAccess(wasmtime::format_err!(
"unsupported input type: {vt:?}"
))),
}
@@ -345,7 +345,7 @@ fn convert_value_type(vt: &ValueType) -> Result<(Vec<i64>, TensorType), BackendE
fn convert_i64(i: &i64) -> Result<u32, BackendError> {
u32::try_from(*i).map_err(|d| -> BackendError {
- anyhow::anyhow!("unable to convert dimension to u32: {d}").into()
+ wasmtime::format_err!("unable to convert dimension to u32: {d}").into()
})
}
@@ -358,7 +358,7 @@ impl TryFrom<TensorElementType> for TensorType {
TensorElementType::Uint8 => Ok(TensorType::U8),
TensorElementType::Int32 => Ok(TensorType::I32),
TensorElementType::Int64 => Ok(TensorType::I64),
- _ => Err(BackendError::BackendAccess(anyhow::anyhow!(
+ _ => Err(BackendError::BackendAccess(wasmtime::format_err!(
"unsupported tensor type: {ty:?}"
))),
}
@@ -376,7 +376,7 @@ fn to_input_value(slot: &TensorSlot) -> Result<[SessionInputValue<'_>; 1], Backe
.map(|d| *d as i64) // TODO: fewer conversions
.collect();
let ort_tensor = OrtTensor::<f32>::from_array((dimensions, data)).map_err(|e| {
- BackendError::BackendAccess(anyhow::anyhow!(
+ BackendError::BackendAccess(wasmtime::format_err!(
"failed to create ONNX session input: {e}"
))
})?;
@@ -387,7 +387,7 @@ fn to_input_value(slot: &TensorSlot) -> Result<[SessionInputValue<'_>; 1], Backe
}
},
None => {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
+ return Err(BackendError::BackendAccess(wasmtime::format_err!(
"missing input tensor: {}",
slot.shape.name
)));
diff --git a/crates/wasi-nn/src/backend/openvino.rs b/crates/wasi-nn/src/backend/openvino.rs
index 3e013ee713..ef6fc2b38a 100644
--- a/crates/wasi-nn/src/backend/openvino.rs
+++ b/crates/wasi-nn/src/backend/openvino.rs
@@ -198,13 +198,13 @@ impl BackendExecutionContext for OpenvinoExecutionContext {
impl From<InferenceError> for BackendError {
fn from(e: InferenceError) -> Self {
- BackendError::BackendAccess(anyhow::Error::new(e))
+ BackendError::BackendAccess(wasmtime::Error::new(e))
}
}
impl From<SetupError> for BackendError {
fn from(e: SetupError) -> Self {
- BackendError::BackendAccess(anyhow::Error::new(e))
+ BackendError::BackendAccess(wasmtime::Error::new(e))
}
}
diff --git a/crates/wasi-nn/src/backend/pytorch.rs b/crates/wasi-nn/src/backend/pytorch.rs
index 0d48577533..1cdf2e1b8c 100644
--- a/crates/wasi-nn/src/backend/pytorch.rs
+++ b/crates/wasi-nn/src/backend/pytorch.rs
@@ -117,7 +117,7 @@ impl BackendExecutionContext for PytorchExecutionContext {
Id::Index(i) => {
// Check if id_type is already set and if it matches the current id type
if let Some(Id::Name(_)) = self.id_type {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
+ return Err(BackendError::BackendAccess(wasmtime::format_err!(
"Cannot mix u32 and str indexes"
)));
}
@@ -135,7 +135,7 @@ impl BackendExecutionContext for PytorchExecutionContext {
Id::Name(_) => {
// Check if id_type is already set and if it matches the current id type
if let Some(Id::Index(_)) = self.id_type {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
+ return Err(BackendError::BackendAccess(wasmtime::format_err!(
"Cannot mix u32 and str indexes"
)));
}
@@ -144,7 +144,7 @@ impl BackendExecutionContext for PytorchExecutionContext {
self.id_type = Some(Id::Name(String::new())); // Provide a str value for Name
}
if self.inputs.get(0).is_some() {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
+ return Err(BackendError::BackendAccess(wasmtime::format_err!(
"The pytorch backend does not support multiple named inputs"
)));
} else {
@@ -214,7 +214,7 @@ impl BackendExecutionContext for PytorchExecutionContext {
// WITX-style compute with previously set inputs
None => {
if self.inputs.is_empty() {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
+ return Err(BackendError::BackendAccess(wasmtime::format_err!(
"No inputs provided for inference"
)));
}
@@ -310,6 +310,6 @@ impl TryFrom<Kind> for TensorType {
impl From<TchError> for BackendError {
fn from(e: TchError) -> Self {
- BackendError::BackendAccess(anyhow::Error::new(e))
+ BackendError::BackendAccess(wasmtime::Error::new(e))
}
}
diff --git a/crates/wasi-nn/src/backend/winml.rs b/crates/wasi-nn/src/backend/winml.rs
index 43a840f397..c1e2af0a99 100644
--- a/crates/wasi-nn/src/backend/winml.rs
+++ b/crates/wasi-nn/src/backend/winml.rs
@@ -118,7 +118,7 @@ impl WinMLExecutionContext {
if i < list.Size()? {
i
} else {
- return Err(BackendError::BackendAccess(anyhow::anyhow!(
+ return Err(BackendError::BackendAccess(wasmtime::format_err!(
"incorrect tensor index: {i} >= {}",
list.Size()?
)));
@@ -128,7 +128,9 @@ impl WinMLExecutionContext {
.into_iter()
.position(|d| d.Name().unwrap() == name)
.ok_or_else(|| {
- BackendError::BackendAccess(anyhow::anyhow!("unknown tensor name: {name}"))
+ BackendError::BackendAccess(wasmtime::format_err!(
+ "unknown tensor name: {name}"
+ ))
})? as u32,
};
Ok(index)
@@ -165,7 +167,7 @@ impl BackendExecutionContext for WinMLExecutionContext {
.into_iter()
.position(|d| d.Name().unwrap() == input.name)
.ok_or_else(|| {
- BackendError::BackendAccess(anyhow::anyhow!(
+ BackendError::BackendAccess(wasmtime::format_err!(
"Unknown input tensor name: {}",
input.name
))
@@ -235,7 +237,7 @@ impl BackendExecutionContext for WinMLExecutionContext {
);
tensor
} else {
- return Err(BackendError::BackendAccess(anyhow::Error::msg(
+ return Err(BackendError::BackendAccess(wasmtime::Error::msg(
"Output is not ready.",
)));
}
@@ -243,7 +245,7 @@ impl BackendExecutionContext for WinMLExecutionContext {
}
/// Read a file into a byte vector.
-fn read(path: &Path) -> anyhow::Result<Vec<u8>> {
+fn read(path: &Path) -> wasmtime::Result<Vec<u8>> {
let mut file = File::open(path)?;
let mut buffer = vec![];
file.read_to_end(&mut buffer)?;
@@ -252,7 +254,7 @@ fn read(path: &Path) -> anyhow::Result<Vec<u8>> {
impl From<windows::core::Error> for BackendError {
fn from(e: windows::core::Error) -> Self {
- BackendError::BackendAccess(anyhow::Error::new(e))
+ BackendError::BackendAccess(wasmtime::Error::new(e))
}
}
@@ -265,7 +267,7 @@ fn dimensions_as_u32(dimensions: &IVectorView<i64>) -> Result<Vec<u32>, BackendE
fn convert_i64(i: i64) -> Result<u32, BackendError> {
u32::try_from(i).map_err(|d| -> BackendError {
- anyhow::anyhow!("unable to convert dimension to u32: {d}").into()
+ wasmtime::format_err!("unable to convert dimension to u32: {d}").into()
})
}
diff --git a/crates/wasi-nn/src/lib.rs b/crates/wasi-nn/src/lib.rs
index 497650cd2b..b826f6abab 100644
--- a/crates/wasi-nn/src/lib.rs
+++ b/crates/wasi-nn/src/lib.rs
@@ -5,17 +5,17 @@ pub mod witx;
use crate::backend::{BackendError, Id, NamedTensor as BackendNamedTensor};
use crate::wit::generated_::wasi::nn::tensor::TensorType;
-use anyhow::anyhow;
use core::fmt;
pub use registry::{GraphRegistry, InMemoryRegistry};
use std::path::Path;
use std::sync::Arc;
+use wasmtime::format_err;
/// Construct an in-memory registry from the available backends and a list of
/// `(<backend name>, <graph directory>)`. This assumes graphs can be loaded
/// from a local directory, which is a safe assumption currently for the current
/// model types.
-pub fn preload(preload_graphs: &[(String, String)]) -> anyhow::Result<(Vec<Backend>, Registry)> {
+pub fn preload(preload_graphs: &[(String, String)]) -> wasmtime::Result<(Vec<Backend>, Registry)> {
let mut backends = backend::list();
let mut registry = InMemoryRegistry::new();
for (kind, path) in preload_graphs {
@@ -23,9 +23,9 @@ pub fn preload(preload_graphs: &[(String, String)]) -> anyhow::Result<(Vec<Backe
let backend = backends
.iter_mut()
.find(|b| b.encoding() == kind_)
- .ok_or(anyhow!("unsupported backend: {kind}"))?
+ .ok_or(format_err!("unsupported backend: {kind}"))?
.as_dir_loadable()
- .ok_or(anyhow!("{kind} does not support directory loading"))?;
+ .ok_or(format_err!("{kind} does not support directory loading"))?;
registry.load(backend, Path::new(path))?;
}
Ok((backends, Registry::from(registry)))
diff --git a/crates/wasi-nn/src/registry/in_memory.rs b/crates/wasi-nn/src/registry/in_memory.rs
index 86f81203d6..0523c8d519 100644
--- a/crates/wasi-nn/src/registry/in_memory.rs
+++ b/crates/wasi-nn/src/registry/in_memory.rs
@@ -3,8 +3,8 @@
use super::{Graph, GraphRegistry};
use crate::backend::BackendFromDir;
use crate::wit::ExecutionTarget;
-use anyhow::{anyhow, bail};
use std::{collections::HashMap, path::Path};
+use wasmtime::{bail, format_err};
pub struct InMemoryRegistry(HashMap<String, Graph>);
impl InMemoryRegistry {
@@ -18,7 +18,7 @@ impl InMemoryRegistry {
/// from a directory. The name used in the registry is the directory's last
/// suffix: if the backend can find the files it expects in `/my/model/foo`,
/// the registry will contain a new graph named `foo`.
- pub fn load(&mut self, backend: &mut dyn BackendFromDir, path: &Path) -> anyhow::Result<()> {
+ pub fn load(&mut self, backend: &mut dyn BackendFromDir, path: &Path) -> wasmtime::Result<()> {
if !path.is_dir() {
bail!(
"preload directory is not a valid directory: {}",
@@ -28,7 +28,7 @@ impl InMemoryRegistry {
let name = path
.file_name()
.map(|s| s.to_string_lossy())
- .ok_or(anyhow!("no file name in path"))?;
+ .ok_or(format_err!("no file name in path"))?;
let graph = backend.load_from_dir(path, ExecutionTarget::Cpu)?;
self.0.insert(name.into_owned(), graph);
diff --git a/crates/wasi-nn/src/wit.rs b/crates/wasi-nn/src/wit.rs
index 65c32fb1d8..32e668e277 100644
--- a/crates/wasi-nn/src/wit.rs
+++ b/crates/wasi-nn/src/wit.rs
@@ -16,11 +16,11 @@
//! [`types`]: crate::wit::types
use crate::{Backend, Registry};
-use anyhow::anyhow;
use std::collections::HashMap;
use std::hash::Hash;
use std::{fmt, str::FromStr};
use wasmtime::component::{HasData, Resource, ResourceTable};
+use wasmtime::format_err;
/// Capture the state necessary for calling into the backend ML libraries.
pub struct WasiNnCtx {
@@ -59,7 +59,7 @@ impl<'a> WasiNnView<'a> {
#[derive(Debug)]
pub struct Error {
code: ErrorCode,
- data: anyhow::Error,
+ data: wasmtime::Error,
}
/// Construct an [`Error`] resource and immediately return it.
@@ -152,7 +152,7 @@ pub use generated_::Ml as ML;
pub fn add_to_linker<T: 'static>(
l: &mut wasmtime::component::Linker<T>,
f: fn(&mut T) -> WasiNnView<'_>,
-) -> anyhow::Result<()> {
+) -> wasmtime::Result<()> {
generated::graph::add_to_linker::<_, HasWasiNnView>(l, f)?;
generated::tensor::add_to_linker::<_, HasWasiNnView>(l, f)?;
generated::inference::add_to_linker::<_, HasWasiNnView>(l, f)?;
@@ -189,7 +189,7 @@ impl generated::graph::Host for WasiNnView<'_> {
bail!(
self,
ErrorCode::InvalidEncoding,
- anyhow!("unable to find a backend for this encoding")
+ format_err!("unable to find a backend for this encoding")
);
}
}
@@ -209,7 +209,7 @@ impl generated::graph::Host for WasiNnView<'_> {
bail!(
self,
ErrorCode::NotFound,
- anyhow!("failed to find graph with name: {name}")
+ format_err!("failed to find graph with name: {name}")
);
}
}
@@ -334,7 +334,7 @@ impl generated::errors::HostError for WasiNnView<'_> {
}
ErrorCode::TooLarge => Ok(generated::errors::ErrorCode::TooLarge),
ErrorCode::NotFound => Ok(generated::errors::ErrorCode::NotFound),
- ErrorCode::Trap => Err(anyhow!(error.data.to_string())),
+ ErrorCode::Trap => Err(format_err!(error.data.to_string())),
}
}
diff --git a/crates/wasi-nn/src/witx.rs b/crates/wasi-nn/src/witx.rs
index 7aae53be0c..3a03b41dbf 100644
--- a/crates/wasi-nn/src/witx.rs
+++ b/crates/wasi-nn/src/witx.rs
@@ -111,7 +111,7 @@ mod generated {
fn nn_errno_from_wasi_nn_error(
&mut self,
e: WasiNnError,
- ) -> anyhow::Result<types::NnErrno> {
+ ) -> wasmtime::Result<types::NnErrno> {
tracing::debug!("host error: {:?}", e);
match e {
WasiNnError::BackendError(_) => Ok(types::NnErrno::RuntimeError),
diff --git a/crates/wasi-nn/tests/check/mod.rs b/crates/wasi-nn/tests/check/mod.rs
index 32e175cdff..c6218e28c6 100644
--- a/crates/wasi-nn/tests/check/mod.rs
+++ b/crates/wasi-nn/tests/check/mod.rs
@@ -31,7 +31,7 @@ pub fn artifacts_dir() -> PathBuf {
}
/// Retrieve the bytes at the `from` URL and place them in the `to` file.
-fn download(from: &str, to: &Path) -> anyhow::Result<()> {
+fn download(from: &str, to: &Path) -> wasmtime::Result<()> {
let mut curl = Command::new("curl");
curl.arg("--location").arg(from).arg("--output").arg(to);
println!("> downloading: {:?}", &curl);
diff --git a/crates/wasi-nn/tests/check/onnx.rs b/crates/wasi-nn/tests/check/onnx.rs
index 61ce907f27..ffe9411895 100644
--- a/crates/wasi-nn/tests/check/onnx.rs
+++ b/crates/wasi-nn/tests/check/onnx.rs
@@ -1,6 +1,6 @@
use super::{DOWNLOAD_LOCK, artifacts_dir, download};
-use anyhow::{Context, Result};
use std::{env, fs};
+use wasmtime::{Result, error::Context as _};
/// Return `Ok` if we find the cached MobileNet test artifacts; this will
/// download the artifacts if necessary.
diff --git a/crates/wasi-nn/tests/check/openvino.rs b/crates/wasi-nn/tests/check/openvino.rs
index d75034ed9a..bc41cd5b75 100644
--- a/crates/wasi-nn/tests/check/openvino.rs
+++ b/crates/wasi-nn/tests/check/openvino.rs
@@ -1,6 +1,6 @@
use super::{DOWNLOAD_LOCK, artifacts_dir, download};
-use anyhow::{Context, Result, bail};
use std::fs;
+use wasmtime::{Result, bail, error::Context as _};
/// Return `Ok` if we find a working OpenVINO installation.
pub fn is_installed() -> Result<()> {
diff --git a/crates/wasi-nn/tests/check/pytorch.rs b/crates/wasi-nn/tests/check/pytorch.rs
index 5f9b2daa11..72d9818919 100644
--- a/crates/wasi-nn/tests/check/pytorch.rs
+++ b/crates/wasi-nn/tests/check/pytorch.rs
@@ -1,6 +1,6 @@
use super::{DOWNLOAD_LOCK, artifacts_dir, download};
-use anyhow::{Context, Result};
use std::{env, fs};
+use wasmtime::{Result, error::Context as _};
/// Return `Ok` if we find the cached MobileNet test artifacts; this will
/// download the artifacts if necessary.
diff --git a/crates/wasi-nn/tests/check/winml.rs b/crates/wasi-nn/tests/check/winml.rs
index a02a331169..0d7ca82cb9 100644
--- a/crates/wasi-nn/tests/check/winml.rs
+++ b/crates/wasi-nn/tests/check/winml.rs
@@ -1,4 +1,4 @@
-use anyhow::{Result, anyhow};
+use wasmtime::{Result, format_err};
use windows::AI::MachineLearning::{LearningModelDevice, LearningModelDeviceKind};
/// Return `Ok` if we can use WinML.
@@ -10,6 +10,9 @@ pub fn is_available() -> Result<()> {
)
}) {
Ok(_) => Ok(()),
- Err(e) => Err(anyhow!("WinML learning device is not available: {:?}", e)),
+ Err(e) => Err(format_err!(
+ "WinML learning device is not available: {:?}",
+ e
+ )),
}
}
diff --git a/crates/wasi-nn/tests/exec/wit.rs b/crates/wasi-nn/tests/exec/wit.rs
index 268dc92fa6..61ce65bfb6 100644
--- a/crates/wasi-nn/tests/exec/wit.rs
+++ b/crates/wasi-nn/tests/exec/wit.rs
@@ -1,9 +1,8 @@
use super::PREOPENED_DIR_NAME;
use crate::check::artifacts_dir;
-use anyhow::{Result, anyhow};
use std::path::Path;
use wasmtime::component::{Component, Linker, ResourceTable};
-use wasmtime::{Config, Engine, Store};
+use wasmtime::{Config, Engine, Result, Store, format_err};
use wasmtime_wasi::p2::bindings::sync::Command;
use wasmtime_wasi::{DirPerms, FilePerms, WasiCtx, WasiCtxView};
use wasmtime_wasi_nn::wit::WasiNnView;
@@ -24,7 +23,7 @@ pub fn run(path: &str, backend: Backend, preload_model: bool) -> Result<()> {
let mut store = Store::new(&engine, Ctx::new(&artifacts_dir(), preload_model, backend)?);
let command = Command::instantiate(&mut store, &module, &linker)?;
let result = command.wasi_cli_run().call_run(&mut store)?;
- result.map_err(|_| anyhow!("failed to run command"))
+ result.map_err(|_| format_err!("failed to run command"))
}
/// The host state for running wasi-nn component tests.
diff --git a/crates/wasi-nn/tests/exec/witx.rs b/crates/wasi-nn/tests/exec/witx.rs
index b5611c941d..5d4fa3b00f 100644
--- a/crates/wasi-nn/tests/exec/witx.rs
+++ b/crates/wasi-nn/tests/exec/witx.rs
@@ -1,7 +1,7 @@
use super::PREOPENED_DIR_NAME;
use crate::check::artifacts_dir;
-use anyhow::Result;
use std::path::Path;
+use wasmtime::Result;
use wasmtime::{Config, Engine, Linker, Module, Store};
use wasmtime_wasi::p1::WasiP1Ctx;
use wasmtime_wasi::{DirPerms, FilePerms, WasiCtxBuilder};
diff --git a/crates/wasi-nn/tests/test-programs.rs b/crates/wasi-nn/tests/test-programs.rs
index 3d8d49478e..98b0339b97 100644
--- a/crates/wasi-nn/tests/test-programs.rs
+++ b/crates/wasi-nn/tests/test-programs.rs
@@ -16,10 +16,10 @@
mod check;
mod exec;
-use anyhow::Result;
use libtest_mimic::{Arguments, Trial};
use std::{borrow::Cow, env};
use test_programs_artifacts::*;
+use wasmtime::Result;
use wasmtime_wasi_nn::{Backend, backend};
fn main() -> Result<()> {
@@ -137,7 +137,7 @@ fn nn_witx_image_classification_onnx() -> Result<()> {
}
#[cfg(not(feature = "onnx"))]
fn nn_witx_image_classification_onnx() -> Result<()> {
- anyhow::bail!("this test requires the `onnx` feature")
+ wasmtime::bail!("this test requires the `onnx` feature")
}
#[cfg(all(feature = "winml", target_os = "windows"))]
@@ -149,7 +149,7 @@ fn nn_witx_image_classification_winml_named() -> Result<()> {
}
#[cfg(not(all(feature = "winml", target_os = "windows")))]
fn nn_witx_image_classification_winml_named() -> Result<()> {
- anyhow::bail!("this test requires the `winml` feature and only runs on windows")
+ wasmtime::bail!("this test requires the `winml` feature and only runs on windows")
}
#[cfg(feature = "pytorch")]
@@ -160,7 +160,7 @@ fn nn_witx_image_classification_pytorch() -> Result<()> {
}
#[cfg(not(feature = "pytorch"))]
fn nn_witx_image_classification_pytorch() -> Result<()> {
- anyhow::bail!("this test requires the `pytorch` feature")
+ wasmtime::bail!("this test requires the `pytorch` feature")
}
fn nn_wit_image_classification_openvino() -> Result<()> {
@@ -193,7 +193,7 @@ fn nn_wit_image_classification_onnx() -> Result<()> {
}
#[cfg(not(feature = "onnx"))]
fn nn_wit_image_classification_onnx() -> Result<()> {
- anyhow::bail!("this test requires the `onnx` feature")
+ wasmtime::bail!("this test requires the `onnx` feature")
}
#[cfg(feature = "pytorch")]
@@ -208,7 +208,7 @@ fn nn_wit_image_classification_pytorch() -> Result<()> {
}
#[cfg(not(feature = "pytorch"))]
fn nn_wit_image_classification_pytorch() -> Result<()> {
- anyhow::bail!("this test requires the `pytorch` feature")
+ wasmtime::bail!("this test requires the `pytorch` feature")
}
#[cfg(all(feature = "winml", target_os = "windows"))]
@@ -220,7 +220,7 @@ fn nn_wit_image_classification_winml_named() -> Result<()> {
}
#[cfg(not(all(feature = "winml", target_os = "windows")))]
fn nn_wit_image_classification_winml_named() -> Result<()> {
- anyhow::bail!("this test requires the `winml` feature and only runs on windows")
+ wasmtime::bail!("this test requires the `winml` feature and only runs on windows")
}
/// Helper for keeping track of what tests should do when pre-test checks fail.