Struct FileSystemCache 

pub struct FileSystemCache { /* private fields */ }

Representation of a directory that contains compiled wasm artifacts.

The FileSystemCache type implements the Cache trait, which allows it to be used generically when some sort of cache is required.

Usage:

use wasmer_runtime::cache::{Cache, FileSystemCache, WasmHash};

fn store_module(module: Module) -> Result<Module, CacheError> {
    // Create a new file system cache.
    // This is unsafe because we can't ensure that the artifact wasn't
    // corrupted or tampered with.
    let mut fs_cache = unsafe { FileSystemCache::new("some/directory/goes/here")? };
    // Compute a key for a given WebAssembly binary
    let key = WasmHash::generate(&[]);
    // Store a module into the cache given a key
    fs_cache.store(key, module.clone())?;
    Ok(module)
}

Implementations

impl FileSystemCache

pub unsafe fn new<P: Into<PathBuf>>(path: P) -> Result<Self>

Construct a new FileSystemCache around the specified directory. The contents of the cache are stored in sub-versioned directories.

Note:

This method is unsafe because there’s no way to ensure the artifacts stored in this cache haven’t been corrupted or tampered with.

Trait Implementations

impl Cache for FileSystemCache

type LoadError = Error

Error type to return when load error occurs

type StoreError = Error

Error type to return when store error occurs

fn load(&self, key: WasmHash) -> Result<Module, CacheError>

loads a module using the default Backend

fn load_with_backend( &self, key: WasmHash, backend: Backend, ) -> Result<Module, CacheError>

loads a cached module using a specific Backend

fn store(&mut self, key: WasmHash, module: Module) -> Result<(), CacheError>

Store a module into the cache with the given key