Struct WasiFilesystemNamed 

pub struct WasiFilesystemNamed<T>(/* private fields */);

A helper struct which implements HasData for the wasi:filesystem APIs when used in combination with named imports.

This structure is similar in purpose to WasiFilesystem and is used when using the named_imports module for wasi:filesystem. This structure serves as the D type parameter for add_to_linker functions.

Meaning of the T parameter

Here the T must be something that implements WasiFilesystemNamedView. The corresponding Data for this type is WasiCtxNamedView which internally will contain &mut T.

Effectively you’re going to implement WasiFilesystemNamedView for something in your embedding, and that’s the T you’ll fill in here.

Examples

use wasmtime::component::{Linker, Component, ResourceTable};
use wasmtime::{Engine, Result};
use wasmtime_wasi::{NamedId, WasiCtxNamedView};
use wasmtime_wasi::filesystem::*;
use wasmtime_wasi::p2::bindings::named_imports;
use std::collections::HashMap;

struct MyStoreState {
    table: ResourceTable,
    states: HashMap<NamedId, WasiFilesystemCtx>,
}

fn main() -> Result<()> {
    let engine = Engine::default();
    let mut linker = Linker::new(&engine);
    let component = Component::new(&engine, "(component)")?;
    let mut name_map = HashMap::new();

    named_imports::wasi::filesystem::preopens::add_to_linker::<MyStoreState, WasiFilesystemNamed<MyStoreState>>(
        &mut linker,
        &component,
        |name| {
            let len = name_map.len();
            Ok(NamedId(*name_map.entry(name.to_string()).or_insert(len)))
        },
        |state| WasiCtxNamedView(state),
    )?;
    Ok(())
}

impl WasiFilesystemNamedView for MyStoreState {
    fn filesystem(&mut self, id: NamedId) -> WasiFilesystemCtxView<'_> {
        let ctx = self.states.get_mut(&id).expect("state for id");
        WasiFilesystemCtxView {
            table: &mut self.table,
            ctx,
        }
    }
}

Trait Implementations

impl<T> HasData for WasiFilesystemNamed<T>

where T: WasiFilesystemNamedView,

type Data<'a> = WasiCtxNamedView<'a, T>

The data associated with this trait implementation, chiefly used as a generic associated type to allow plumbing the 'a lifetime into the definition here.

impl<T, U> HostDescriptorWithStore<U> for WasiFilesystemNamed<T>

where T: WasiFilesystemNamedView,

Available on crate feature p3 only.

fn read_via_stream( store: Access<'_, U, Self>, id: NamedId, fd: Resource<Descriptor>, offset: Filesize, ) -> Result<(StreamReader<u8>, FutureReader<Result<(), ErrorCode>>)>

Return a stream for reading from a file.

fn write_via_stream( store: Access<'_, U, Self>, id: NamedId, fd: Resource<Descriptor>, data: StreamReader<u8>, offset: Filesize, ) -> Result<FutureReader<Result<(), ErrorCode>>>

Return a stream for writing to a file, if available.

fn append_via_stream( store: Access<'_, U, Self>, id: NamedId, fd: Resource<Descriptor>, data: StreamReader<u8>, ) -> Result<FutureReader<Result<(), ErrorCode>>>

Return a stream for appending to a file, if available.

async fn advise( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, offset: Filesize, length: Filesize, advice: Advice, ) -> FilesystemResult<()>

Provide file advisory information on a descriptor.

async fn sync_data( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, ) -> FilesystemResult<()>

Synchronize the data of a file to disk.

async fn get_flags( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, ) -> FilesystemResult<DescriptorFlags>

Get flags associated with a descriptor.

async fn get_type( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, ) -> FilesystemResult<DescriptorType>

Get the dynamic type of a descriptor.

async fn set_size( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, size: Filesize, ) -> FilesystemResult<()>

Adjust the size of an open file. If this increases the file’s size, the extra bytes are filled with zeros.

async fn set_times( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, data_access_timestamp: NewTimestamp, data_modification_timestamp: NewTimestamp, ) -> FilesystemResult<()>

Adjust the timestamps of an open file or directory.

fn read_directory( store: Access<'_, U, Self>, id: NamedId, fd: Resource<Descriptor>, ) -> Result<(StreamReader<DirectoryEntry>, FutureReader<Result<(), ErrorCode>>)>

Read directory entries from a directory.

async fn sync( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, ) -> FilesystemResult<()>

Synchronize the data and metadata of a file to disk.

async fn create_directory_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, path: String, ) -> FilesystemResult<()>

Create a directory.

async fn stat( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, ) -> FilesystemResult<DescriptorStat>

Return the attributes of an open file or directory.

async fn stat_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, path_flags: PathFlags, path: String, ) -> FilesystemResult<DescriptorStat>

Return the attributes of a file or directory.

async fn set_times_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, path_flags: PathFlags, path: String, data_access_timestamp: NewTimestamp, data_modification_timestamp: NewTimestamp, ) -> FilesystemResult<()>

Adjust the timestamps of a file or directory.

async fn link_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, old_path_flags: PathFlags, old_path: String, new_fd: Resource<Descriptor>, new_path: String, ) -> FilesystemResult<()>

Create a hard link.

async fn open_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, path_flags: PathFlags, path: String, open_flags: OpenFlags, flags: DescriptorFlags, ) -> FilesystemResult<Resource<Descriptor>>

Open a file or directory.

async fn readlink_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, path: String, ) -> FilesystemResult<String>

Read the contents of a symbolic link.

async fn remove_directory_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, path: String, ) -> FilesystemResult<()>

Remove a directory.

async fn rename_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, old_path: String, new_fd: Resource<Descriptor>, new_path: String, ) -> FilesystemResult<()>

Rename a filesystem object.

async fn symlink_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, old_path: String, new_path: String, ) -> FilesystemResult<()>

Create a symbolic link (also known as a “symlink”).

async fn unlink_file_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, path: String, ) -> FilesystemResult<()>

Unlink a filesystem object that is not a directory.

async fn is_same_object( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, other: Resource<Descriptor>, ) -> Result<bool>

Test whether two descriptors refer to the same filesystem object.

async fn metadata_hash( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, ) -> FilesystemResult<MetadataHashValue>

Return a hash of the metadata associated with a filesystem object referred to by a descriptor.

async fn metadata_hash_at( store: &Accessor<U, Self>, id: NamedId, fd: Resource<Descriptor>, path_flags: PathFlags, path: String, ) -> FilesystemResult<MetadataHashValue>

Return a hash of the metadata associated with a filesystem object referred to by a directory descriptor and a relative path.