Struct Ctx 

pub struct Ctx<H>
where
    H: MinimalHandler,
{ /* private fields */ }

Wasmtime Context for a component instance, with access to WASI context, HTTP context, and WRPC Invocation context. This is a low-level API and has to be paired with Component::new_with_linker.

Trait Implementations

impl<H: MinimalHandler> Debug for Ctx<H>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<H> Host for Ctx<H>

where H: Handler,

async fn create_container( &mut self, name: ContainerName, ) -> Result<Result<Resource<Container>, Error>>

creates a new empty container

async fn get_container( &mut self, name: ContainerName, ) -> Result<Result<Resource<Container>, Error>>

retrieves a container by name

async fn delete_container( &mut self, name: ContainerName, ) -> Result<Result<(), Error>>

deletes a container and all objects within it

async fn container_exists( &mut self, name: ContainerName, ) -> Result<Result<bool, Error>>

returns true if the container exists

async fn copy_object( &mut self, src: ObjectId, dest: ObjectId, ) -> Result<Result<(), Error>>

copies (duplicates) an object, to the same or a different container. returns an error if the target container does not exist. overwrites destination object if it already existed.

async fn move_object( &mut self, src: ObjectId, dest: ObjectId, ) -> Result<Result<(), Error>>

moves or renames an object, to the same or a different container returns an error if the destination container does not exist. overwrites destination object if it already existed.

impl<H> Host for Ctx<H>

where H: Handler,

async fn open( &mut self, name: String, ) -> Result<Result<Resource<Bucket>, Error>>

Get the bucket with the specified identifier.

impl<H> Host for Ctx<H>

where H: Handler,

async fn get_many( &mut self, bucket: Resource<Bucket>, keys: Vec<String>, ) -> Result<Result<Vec<Option<(String, Vec<u8>)>>, Error>>

Get the key-value pairs associated with the keys in the store. It returns a list of key-value pairs.

async fn set_many( &mut self, bucket: Resource<Bucket>, entries: Vec<(String, Vec<u8>)>, ) -> Result<Result<(), Error>>

Set the values associated with the keys in the store. If the key already exists in the store, it overwrites the value.

async fn delete_many( &mut self, bucket: Resource<Bucket>, keys: Vec<String>, ) -> Result<Result<(), Error>>

Delete the key-value pairs associated with the keys in the store.

impl<H: Handler> Host for Ctx<H>

async fn log( &mut self, level: Level, context: String, message: String, ) -> Result<()>

Emit a log message.

impl<H: Handler> Host for Ctx<H>

async fn log( &mut self, level: Level, context: String, message: String, ) -> Result<()>

Emit a log message.

impl<H> Host for Ctx<H>

where H: Handler,

async fn request( &mut self, subject: String, body: Vec<u8>, timeout_ms: u32, ) -> Result<Result<BrokerMessage, String>>

Perform a request operation on a subject

async fn publish(&mut self, msg: BrokerMessage) -> Result<Result<(), String>>

Publish a message to a subject without awaiting a response

impl<H> Host for Ctx<H>

where H: Handler,

async fn send( &mut self, client: Resource<Box<dyn Client + Send + Sync>>, topic: Topic, message: Resource<Message>, ) -> Result<Result<(), Error>>

Sends the message using the given client.

impl<H> Host for Ctx<H>

where H: Handler,

async fn request( &mut self, client: Resource<Box<dyn Client + Send + Sync>>, topic: Topic, message: Resource<Message>, options: Option<Resource<RequestOptions>>, ) -> Result<Result<Vec<Resource<Message>>, Error>>

Performs a blocking request/reply operation with an optional set of request options.

async fn reply( &mut self, reply_to: Resource<Message>, message: Resource<Message>, ) -> Result<Result<(), Error>>

Replies to the given message with the given response message. The details of which topic the message is sent to is up to the implementation. This allows for reply-to details to be handled in the best way possible for the underlying messaging system.

impl<H: Handler> Host for Ctx<H>

async fn get( &mut self, key: String, ) -> Result<Result<Resource<Secret>, SecretsError>>

Gets a single opaque secrets value set at the given key if it exists

impl<H: Handler> Host for Ctx<H>

async fn reveal(&mut self, secret: Resource<Secret>) -> Result<SecretValue>

Reveals the value of a secret to the caller. This lets you easily audit your code to discover where secrets are being used.

impl<H: Handler> Host for Ctx<H>

async fn set_link_name( &mut self, link_name: String, interfaces: Vec<Resource<Arc<CallTargetInterface>>>, ) -> Result<Result<(), String>>

Set a link name to use for all interfaces specified. This is advanced functionality only available within wasmcloud and, as such, is exposed here as part of the wasmcloud:bus package. This is used when you are linking multiple of the same interfaces (i.e. a keyvalue implementation for caching and another one for secrets) to a component.

impl<H: Handler> Host for Ctx<H>

async fn set_link_name( &mut self, link_name: String, interfaces: Vec<Resource<Arc<CallTargetInterface>>>, ) -> Result<()>

Set a link name to use for all interfaces specified. This is advanced functionality only available within wasmcloud and, as such, is exposed here as part of the wasmcloud:bus package. This is used when you are linking multiple of the same interfaces (i.e. a keyvalue implementation for caching and another one for secrets) to a component.

impl<H: Handler> Host for Ctx<H>

async fn get(&mut self, key: String) -> Result<Result<Option<String>, Error>>

Gets a configuration value of type string associated with the key.

async fn get_all(&mut self) -> Result<Result<Vec<(String, String)>, Error>>

Gets a list of configuration key-value pairs of type string.

impl<H: Handler> Host for Ctx<H>

async fn get( &mut self, key: String, ) -> Result<Result<Option<String>, ConfigError>>

Gets a single opaque config value set at the given key if it exists

async fn get_all( &mut self, ) -> Result<Result<Vec<(String, String)>, ConfigError>>

Gets a list of all set config data

impl<H: Handler> Host for Ctx<H>

async fn get( &mut self, audience: String, ) -> Result<Result<Option<String>, Error>>

Gets a single JWT-SVID represented in the form of a (token) string.

impl<H> Host for Ctx<H>

where H: Handler,

async fn increment( &mut self, bucket: Resource<Bucket>, key: String, delta: u64, ) -> Result<Result<u64, Error>>

Atomically increment the value associated with the key in the store by the given delta. It returns the new value.

impl<H> HostBucket for Ctx<H>

where H: Handler,

async fn get( &mut self, bucket: Resource<Bucket>, key: String, ) -> Result<Result<Option<Vec<u8>>, Error>>

Get the value associated with the specified key

async fn set( &mut self, bucket: Resource<Bucket>, key: String, outgoing_value: Vec<u8>, ) -> Result<Result<(), Error>>

Set the value associated with the key in the store. If the key already exists in the store, it overwrites the value.

async fn delete( &mut self, bucket: Resource<Bucket>, key: String, ) -> Result<Result<(), Error>>

Delete the key-value pair associated with the key in the store.

async fn exists( &mut self, bucket: Resource<Bucket>, key: String, ) -> Result<Result<bool, Error>>

Check if the key exists in the store.

async fn list_keys( &mut self, bucket: Resource<Bucket>, cursor: Option<u64>, ) -> Result<Result<KeyResponse, Error>>

Get all the keys in the store with an optional cursor (for use in pagination). It returns a list of keys. Please note that for most KeyValue implementations, this is a can be a very expensive operation and so it should be used judiciously. Implementations can return any number of keys in a single response, but they should never attempt to send more data than is reasonable (i.e. on a small edge device, this may only be a few KB, while on a large machine this could be several MB). Any response should also return a cursor that can be used to fetch the next page of keys. See the key-response record for more information.

async fn drop(&mut self, bucket: Resource<Bucket>) -> Result<()>

impl<H: Handler> HostCallTargetInterface for Ctx<H>

async fn new( &mut self, namespace: String, package: String, interface: String, ) -> Result<Resource<Arc<CallTargetInterface>>>

async fn drop( &mut self, interface: Resource<Arc<CallTargetInterface>>, ) -> Result<()>

impl<H: Handler> HostCallTargetInterface for Ctx<H>

async fn new( &mut self, namespace: String, package: String, interface: String, ) -> Result<Resource<Arc<CallTargetInterface>>>

async fn drop( &mut self, interface: Resource<Arc<CallTargetInterface>>, ) -> Result<()>

impl<H> HostClient for Ctx<H>

where H: Handler,

async fn connect( &mut self, name: String, ) -> Result<Result<Resource<Box<dyn Client + Send + Sync>>, Error>>

async fn disconnect( &mut self, client: Resource<Box<dyn Client + Send + Sync>>, ) -> Result<Result<(), Error>>

async fn drop( &mut self, client: Resource<Box<dyn Client + Send + Sync>>, ) -> Result<()>

impl<H> HostContainer for Ctx<H>

where H: Handler,

async fn drop(&mut self, container: Resource<Container>) -> Result<()>

async fn name( &mut self, container: Resource<Container>, ) -> Result<Result<String, Error>>

returns container name

async fn info( &mut self, container: Resource<Container>, ) -> Result<Result<ContainerMetadata, Error>>

returns container metadata

async fn get_data( &mut self, container: Resource<Container>, name: ObjectName, start: u64, end: u64, ) -> Result<Result<Resource<IncomingValue>, Error>>

retrieves an object or portion of an object, as a resource. Start and end offsets are inclusive. Once a data-blob resource has been created, the underlying bytes are held by the blobstore service for the lifetime of the data-blob resource, even if the object they came from is later deleted.

async fn write_data( &mut self, container: Resource<Container>, object: ObjectName, data: Resource<OutgoingValue>, ) -> Result<Result<(), Error>>

creates or replaces an object with the data blob.

async fn list_objects( &mut self, container: Resource<Container>, ) -> Result<Result<Resource<StreamObjectNames>, Error>>

returns list of objects in the container. Order is undefined.

async fn delete_object( &mut self, container: Resource<Container>, name: ObjectName, ) -> Result<Result<(), Error>>

deletes object. does not return error if object did not exist.

async fn delete_objects( &mut self, container: Resource<Container>, names: Vec<ObjectName>, ) -> Result<Result<(), Error>>

deletes multiple objects in the container

async fn has_object( &mut self, container: Resource<Container>, object: ObjectName, ) -> Result<Result<bool, Error>>

returns true if the object exists in this container

async fn object_info( &mut self, container: Resource<Container>, name: ObjectName, ) -> Result<Result<ObjectMetadata, Error>>

returns metadata for the object

async fn clear( &mut self, container: Resource<Container>, ) -> Result<Result<(), Error>>

removes all objects within the container, leaving the container empty.

impl<H: Handler> HostError for Ctx<H>

async fn from_rpc_error( &mut self, error: Resource<Error>, ) -> Result<Resource<Error>>

Converts wrpc:rpc/error.error into error.

async fn from_io_error( &mut self, error: Resource<Error>, ) -> Result<Result<Resource<Error>, Resource<Error>>>

Attempts to convert wasi:io/error.error into error.

async fn to_debug_string(&mut self, error: Resource<Error>) -> Result<String>

Returns a string that is suitable to assist humans in debugging this error.

async fn drop(&mut self, error: Resource<Error>) -> Result<()>

impl<H: Handler> HostIncomingValue for Ctx<H>

async fn drop(&mut self, incoming_value: Resource<IncomingValue>) -> Result<()>

async fn incoming_value_consume_sync( &mut self, incoming_value: Resource<IncomingValue>, ) -> Result<Result<Vec<u8>, Error>>

async fn incoming_value_consume_async( &mut self, incoming_value: Resource<IncomingValue>, ) -> Result<Result<Resource<DynInputStream>, Error>>

async fn size( &mut self, _incoming_value: Resource<IncomingValue>, ) -> Result<u64>

impl<H> HostMessage for Ctx<H>

where H: Handler,

async fn new(&mut self, data: Vec<u8>) -> Result<Resource<Message>>

async fn topic(&mut self, msg: Resource<Message>) -> Result<Option<Topic>>

The topic/subject/channel this message was received on, if any

async fn content_type( &mut self, msg: Resource<Message>, ) -> Result<Option<String>>

An optional content-type describing the format of the data in the message. This is sometimes described as the “format” type

async fn set_content_type( &mut self, msg: Resource<Message>, content_type: String, ) -> Result<()>

Set the content-type describing the format of the data in the message. This is sometimes described as the “format” type

async fn data(&mut self, msg: Resource<Message>) -> Result<Vec<u8>>

An opaque blob of data

async fn set_data(&mut self, msg: Resource<Message>, buf: Vec<u8>) -> Result<()>

Set the opaque blob of data for this message, discarding the old value

async fn metadata(&mut self, msg: Resource<Message>) -> Result<Option<Metadata>>

Optional metadata (also called headers or attributes in some systems) attached to the message. This metadata is simply decoration and should not be interpreted by a host to ensure portability across different implementors (e.g., Kafka -> NATS, etc.).

async fn add_metadata( &mut self, msg: Resource<Message>, key: String, value: String, ) -> Result<()>

Add a new key-value pair to the metadata, overwriting any existing value for the same key

async fn set_metadata( &mut self, msg: Resource<Message>, meta: Metadata, ) -> Result<()>

Set the metadata

async fn remove_metadata( &mut self, msg: Resource<Message>, key: String, ) -> Result<()>

Remove a key-value pair from the metadata

async fn drop(&mut self, rep: Resource<Message>) -> Result<()>

impl<H: Handler> HostOutgoingValue for Ctx<H>

async fn drop(&mut self, outgoing_value: Resource<OutgoingValue>) -> Result<()>

async fn new_outgoing_value(&mut self) -> Result<Resource<OutgoingValue>>

async fn outgoing_value_write_body( &mut self, outgoing_value: Resource<OutgoingValue>, ) -> Result<Result<Resource<DynOutputStream>, ()>>

Returns a stream for writing the value contents.

async fn finish( &mut self, this: Resource<OutgoingValue>, ) -> Result<Result<(), Error>>

Finalize an outgoing value. This must be called to signal that the outgoing value is complete. If the outgoing-value is dropped without calling outgoing-value.finalize, the implementation should treat the value as corrupted.

impl<H> HostRequestOptions for Ctx<H>

where H: Handler,

async fn new(&mut self) -> Result<Resource<RequestOptions>>

Creates a new request options resource with no options set.

async fn set_timeout_ms( &mut self, opts: Resource<RequestOptions>, timeout_ms: u32, ) -> Result<()>

The maximum amount of time to wait for a response. If the timeout value is not set, then the request/reply operation will block until a message is received in response.

async fn set_expected_replies( &mut self, opts: Resource<RequestOptions>, expected_replies: u32, ) -> Result<()>

The maximum number of replies to expect before returning.

async fn drop(&mut self, opts: Resource<RequestOptions>) -> Result<()>

impl<H: Handler> HostSecret for Ctx<H>

async fn drop(&mut self, secret: Resource<Secret>) -> Result<()>

impl<H: Handler> HostStreamObjectNames for Ctx<H>

async fn drop(&mut self, names: Resource<StreamObjectNames>) -> Result<()>

async fn read_stream_object_names( &mut self, this: Resource<StreamObjectNames>, len: u64, ) -> Result<Result<(Vec<ObjectName>, bool), Error>>

reads the next number of objects from the stream

async fn skip_stream_object_names( &mut self, this: Resource<StreamObjectNames>, num: u64, ) -> Result<Result<(u64, bool), Error>>

skip the next number of objects in the stream

impl<H> WasiHttpView for Ctx<H>

where H: Handler,

fn ctx(&mut self) -> &mut WasiHttpCtx

Returns a mutable reference to the WASI HTTP context.

fn table(&mut self) -> &mut ResourceTable

Returns the table used to manage resources.

fn send_request( &mut self, request: Request<HyperOutgoingBody>, config: OutgoingRequestConfig, ) -> HttpResult<HostFutureIncomingResponse>

where Self: Sized,

Send an outgoing request.

fn new_incoming_request<B>( &mut self, scheme: Scheme, req: Request<B>, ) -> Result<Resource<HostIncomingRequest>, Error>

where B: Body<Data = Bytes, Error = Error> + Send + Sync + 'static, Self: Sized,

Create a new incoming request resource.

fn new_response_outparam( &mut self, result: Sender<Result<Response<BoxBody<Bytes, ErrorCode>>, ErrorCode>>, ) -> Result<Resource<HostResponseOutparam>, Error>

Create a new outgoing response resource.

fn is_forbidden_header(&mut self, name: &HeaderName) -> bool

Whether a given header should be considered forbidden and not allowed.

fn outgoing_body_buffer_chunks(&mut self) -> usize

Number of distinct write calls to the outgoing body’s output-stream that the implementation will buffer. Default: 1.

fn outgoing_body_chunk_size(&mut self) -> usize

Maximum size allowed in a write call to the outgoing body’s output-stream. Default: 1024 * 1024.

impl<H: MinimalHandler> WasiView for Ctx<H>

fn ctx(&mut self) -> WasiCtxView<'_>

Yields mutable access to the WasiCtx configuration used for this context.

impl<H: Handler> WrpcView for Ctx<H>

type Invoke = H

fn wrpc(&mut self) -> WrpcCtxView<'_, Self::Invoke>

impl<H: Handler> Host for Ctx<H>

impl<H> Host for Ctx<H>

where H: Handler,

impl<H> Host for Ctx<H>

where H: Handler,

impl<H> Host for Ctx<H>

where H: Handler,

impl<H: Handler> Host for Ctx<H>