Skip to content

Latest commit

 

History

History
2551 lines (2551 loc) · 145 KB

messaging-service.md

File metadata and controls

2551 lines (2551 loc) · 145 KB
Raw

World messaging-service

The messaging-service world is a world that exports a single asyncrhonous messaging handler that can be used to handle incoming messages from some message broker provider, and a set of capabilities that can be used to interact with the platform / runtime.

Import interface wasi:keyvalue/[email protected]

A keyvalue interface that provides eventually consistent key-value operations.

Each of these operations acts on a single key-value pair.

The value in the key-value pair is defined as a u8 byte array and the intention is that it is the common denominator for all data types defined by different key-value stores to handle data, ensuring compatibility between different key-value stores. Note: the clients will be expecting serialization/deserialization overhead to be handled by the key-value store. The value could be a serialized object from JSON, HTML or vendor-specific data types like AWS S3 objects.

Data consistency in a key value store refers to the guarantee that once a write operation completes, all subsequent read operations will return the value that was written.

Any implementation of this interface must have enough consistency to guarantee "reading your writes." In particular, this means that the client should never get a value that is older than the one it wrote, but it MAY get a newer value if one was written around the same time. These guarantees only apply to the same client (which will likely be provided by the host or an external capability of some kind). In this context a "client" is referring to the caller or guest that is consuming this interface. Once a write request is committed by a specific client, all subsequent read requests by the same client will reflect that write or any subsequent writes. Another client running in a different context may or may not immediately see the result due to the replication lag. As an example of all of this, if a value at a given key is A, and the client writes B, then immediately reads, it should get B. If something else writes C in quick succession, then the client may get C. However, a client running in a separate context may still see A or B

Types

variant error

The set of errors which may be raised by functions in this package

Variant Cases

  • no-such-store

    The host does not recognize the store identifier requested.

  • access-denied

    The requesting component does not have access to the specified store (which may or may not exist).

  • other: string

    Some implementation-specific error has occurred (e.g. I/O)

record key-response

A response to a list-keys operation.

Record Fields

  • keys: list<string>

    The list of keys returned by the query.

  • cursor: option<string>

    The continuation token to use to fetch the next page of keys. If this is `null`, then there are no more keys to fetch.

resource bucket

A bucket is a collection of key-value pairs. Each key-value pair is stored as a entry in the bucket, and the bucket itself acts as a collection of all these entries.

It is worth noting that the exact terminology for bucket in key-value stores can very depending on the specific implementation. For example:

  1. Amazon DynamoDB calls a collection of key-value pairs a table
  2. Redis has hashes, sets, and sorted sets as different types of collections
  3. Cassandra calls a collection of key-value pairs a column family
  4. MongoDB calls a collection of key-value pairs a collection
  5. Riak calls a collection of key-value pairs a bucket
  6. Memcached calls a collection of key-value pairs a slab
  7. Azure Cosmos DB calls a collection of key-value pairs a container

In this interface, we use the term bucket to refer to a collection of key-value pairs

Functions

open: func

Get the bucket with the specified identifier.

identifier must refer to a bucket provided by the host.

error::no-such-store will be raised if the identifier is not recognized.

Params
  • identifier: string
Return values

[method]bucket.get: func

Get the value associated with the specified key

The value is returned as an option. If the key-value pair exists in the store, it returns Ok(value). If the key does not exist in the store, it returns Ok(none).

If any other error occurs, it returns an Err(error).

Params
  • self: borrow<bucket>
  • key: string
Return values
  • result<option<list<u8>>, error>

[method]bucket.set: func

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

If the key does not exist in the store, it creates a new key-value pair.

If any other error occurs, it returns an Err(error).

Params
  • self: borrow<bucket>
  • key: string
  • value: list<u8>
Return values

[method]bucket.delete: func

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

If the key does not exist in the store, it does nothing.

If any other error occurs, it returns an Err(error).

Params
  • self: borrow<bucket>
  • key: string
Return values

[method]bucket.exists: func

Check if the key exists in the store.

If the key exists in the store, it returns Ok(true). If the key does not exist in the store, it returns Ok(false).

If any other error occurs, it returns an Err(error).

Params
  • self: borrow<bucket>
  • key: string
Return values

[method]bucket.list-keys: func

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.

Note that the keys are not guaranteed to be returned in any particular order.

If the store is empty, it returns an empty list.

MAY show an out-of-date list of keys if there are concurrent writes to the store.

If any error occurs, it returns an Err(error).

Params
  • self: borrow<bucket>
  • cursor: option<string>
Return values

Import interface wasi:keyvalue/[email protected]

A keyvalue interface that provides atomic operations.

Atomic operations are single, indivisible operations. When a fault causes an atomic operation to fail, it will appear to the invoker of the atomic operation that the action either completed successfully or did nothing at all.

Please note that this interface is bare functions that take a reference to a bucket. This is to get around the current lack of a way to "extend" a resource with additional methods inside of wit. Future version of the interface will instead extend these methods on the base bucket resource.

Types

type bucket

bucket

#### `type error` [`error`](#error)

#### `resource cas`

A handle to a CAS (compare-and-swap) operation.

variant cas-error

The error returned by a CAS operation

Variant Cases

  • store-error: error

    A store error occurred when performing the operation

  • cas-failed: own<cas>

    The CAS operation failed because the value was too old. This returns a new CAS handle for easy retries. Implementors MUST return a CAS handle that has been updated to the latest version or transaction.

Functions

[static]cas.new: func

Construct a new CAS operation. Implementors can map the underlying functionality (transactions, versions, etc) as desired.

Params
Return values

[method]cas.current: func

Get the current value of the key (if it exists). This allows for avoiding reads if all that is needed to ensure the atomicity of the operation

Params
  • self: borrow<cas>
Return values
  • result<option<list<u8>>, error>

increment: func

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

If the key does not exist in the store, it creates a new key-value pair with the value set to the given delta.

If any other error occurs, it returns an Err(error).

Params
Return values

swap: func

Perform the swap on a CAS operation. This consumes the CAS handle and returns an error if the CAS operation failed.

Params
  • cas: own<cas>
  • value: list<u8>
Return values

Import interface wasi:keyvalue/[email protected]

A keyvalue interface that provides batch operations.

A batch operation is an operation that operates on multiple keys at once.

Batch operations are useful for reducing network round-trip time. For example, if you want to get the values associated with 100 keys, you can either do 100 get operations or you can do 1 batch get operation. The batch operation is faster because it only needs to make 1 network call instead of 100.

A batch operation does not guarantee atomicity, meaning that if the batch operation fails, some of the keys may have been modified and some may not.

This interface does has the same consistency guarantees as the store interface, meaning that you should be able to "read your writes."

Please note that this interface is bare functions that take a reference to a bucket. This is to get around the current lack of a way to "extend" a resource with additional methods inside of wit. Future version of the interface will instead extend these methods on the base bucket resource.

Types

type bucket

bucket

#### `type error` [`error`](#error)

----

Functions

get-many: func

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

If any of the keys do not exist in the store, it returns a none value for that pair in the list.

MAY show an out-of-date value if there are concurrent writes to the store.

If any other error occurs, it returns an Err(error).

Params
Return values
  • result<list<option<(string, list<u8>)>>, error>

set-many: func

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

Note that the key-value pairs are not guaranteed to be set in the order they are provided.

If any of the keys do not exist in the store, it creates a new key-value pair.

If any other error occurs, it returns an Err(error). When an error occurs, it does not rollback the key-value pairs that were already set. Thus, this batch operation does not guarantee atomicity, implying that some key-value pairs could be set while others might fail.

Other concurrent operations may also be able to see the partial results.

Params
  • bucket: borrow<bucket>
  • key-values: list<(string, list<u8>)>
Return values

delete-many: func

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

Note that the key-value pairs are not guaranteed to be deleted in the order they are provided.

If any of the keys do not exist in the store, it skips the key.

If any other error occurs, it returns an Err(error). When an error occurs, it does not rollback the key-value pairs that were already deleted. Thus, this batch operation does not guarantee atomicity, implying that some key-value pairs could be deleted while others might fail.

Other concurrent operations may also be able to see the partial results.

Params
Return values

Import interface wasi:io/[email protected]

Types

resource error

A resource which represents some error information.

The only method provided by this resource is to-debug-string, which provides some human-readable information about the error.

In the wasi:io package, this resource is returned through the wasi:io/streams/stream-error type.

To provide more specific error information, other interfaces may offer functions to "downcast" this error into more specific types. For example, errors returned from streams derived from filesystem types can be described using the filesystem's own error-code type. This is done using the function wasi:filesystem/types/filesystem-error-code, which takes a borrow<error> parameter and returns an option<wasi:filesystem/types/error-code>.

The set of functions which can "downcast" an error into a more concrete type is open.

Functions

[method]error.to-debug-string: func

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

WARNING: The returned string should not be consumed mechanically! It may change across platforms, hosts, or other implementation details. Parsing this string is a major platform-compatibility hazard.

Params
Return values
  • string

Import interface wasi:io/[email protected]

A poll API intended to let users wait for I/O events on multiple handles at once.

Types

resource pollable

pollable represents a single I/O event which may be ready, or not.

Functions

[method]pollable.ready: func

Return the readiness of a pollable. This function never blocks.

Returns true when the pollable is ready, and false otherwise.

Params
Return values
  • bool

[method]pollable.block: func

block returns immediately if the pollable is ready, and otherwise blocks until ready.

This function is equivalent to calling poll.poll on a list containing only this pollable.

Params

poll: func

Poll for completion on a set of pollables.

This function takes a list of pollables, which identify I/O sources of interest, and waits until one or more of the events is ready for I/O.

The result list<u32> contains one or more indices of handles in the argument list that is ready for I/O.

This function traps if either:

  • the list is empty, or:
  • the list contains more elements than can be indexed with a u32 value.

A timeout can be implemented by adding a pollable from the wasi-clocks API to the list.

This function does not return a result; polling in itself does not do any I/O so it doesn't fail. If any of the I/O sources identified by the pollables has an error, it is indicated by marking the source as being ready for I/O.

Params
Return values
  • list<u32>

Import interface wasi:io/[email protected]

WASI I/O is an I/O abstraction API which is currently focused on providing stream types.

In the future, the component model is expected to add built-in stream types; when it does, they are expected to subsume this API.

Types

type error

error

#### `type pollable` [`pollable`](#pollable)

#### `variant stream-error`

An error for input-stream and output-stream operations.

Variant Cases

  • last-operation-failed: own<error>

    The last operation (a write or flush) failed before completion.

    More information is available in the error payload.

    After this, the stream will be closed. All future operations return stream-error::closed.

  • closed

    The stream is closed: no more input will be accepted by the stream. A closed output-stream will return this error on all future operations.

resource input-stream

An input bytestream.

input-streams are non-blocking to the extent practical on underlying platforms. I/O operations always return promptly; if fewer bytes are promptly available than requested, they return the number of bytes promptly available, which could even be zero. To wait for data to be available, use the subscribe function to obtain a pollable which can be polled for using wasi:io/poll.

resource output-stream

An output bytestream.

output-streams are non-blocking to the extent practical on underlying platforms. Except where specified otherwise, I/O operations also always return promptly, after the number of bytes that can be written promptly, which could even be zero. To wait for the stream to be ready to accept data, the subscribe function to obtain a pollable which can be polled for using wasi:io/poll.

Dropping an output-stream while there's still an active write in progress may result in the data being lost. Before dropping the stream, be sure to fully flush your writes.

Functions

[method]input-stream.read: func

Perform a non-blocking read from the stream.

When the source of a read is binary data, the bytes from the source are returned verbatim. When the source of a read is known to the implementation to be text, bytes containing the UTF-8 encoding of the text are returned.

This function returns a list of bytes containing the read data, when successful. The returned list will contain up to len bytes; it may return fewer than requested, but not more. The list is empty when no bytes are available for reading at this time. The pollable given by subscribe will be ready when more bytes are available.

This function fails with a stream-error when the operation encounters an error, giving last-operation-failed, or when the stream is closed, giving closed.

When the caller gives a len of 0, it represents a request to read 0 bytes. If the stream is still open, this call should succeed and return an empty list, or otherwise fail with closed.

The len parameter is a u64, which could represent a list of u8 which is not possible to allocate in wasm32, or not desirable to allocate as as a return value by the callee. The callee may return a list of bytes less than len in size while more bytes are available for reading.

Params
Return values

[method]input-stream.blocking-read: func

Read bytes from a stream, after blocking until at least one byte can be read. Except for blocking, behavior is identical to read.

Params
Return values

[method]input-stream.skip: func

Skip bytes from a stream. Returns number of bytes skipped.

Behaves identical to read, except instead of returning a list of bytes, returns the number of bytes consumed from the stream.

Params
Return values

[method]input-stream.blocking-skip: func

Skip bytes from a stream, after blocking until at least one byte can be skipped. Except for blocking behavior, identical to skip.

Params
Return values

[method]input-stream.subscribe: func

Create a pollable which will resolve once either the specified stream has bytes available to read or the other end of the stream has been closed. The created pollable is a child resource of the input-stream. Implementations may trap if the input-stream is dropped before all derived pollables created with this function are dropped.

Params
Return values

[method]output-stream.check-write: func

Check readiness for writing. This function never blocks.

Returns the number of bytes permitted for the next call to write, or an error. Calling write with more bytes than this function has permitted will trap.

When this function returns 0 bytes, the subscribe pollable will become ready when this function will report at least 1 byte, or an error.

Params
Return values

[method]output-stream.write: func

Perform a write. This function never blocks.

When the destination of a write is binary data, the bytes from contents are written verbatim. When the destination of a write is known to the implementation to be text, the bytes of contents are transcoded from UTF-8 into the encoding of the destination and then written.

Precondition: check-write gave permit of Ok(n) and contents has a length of less than or equal to n. Otherwise, this function will trap.

returns Err(closed) without writing if the stream has closed since the last call to check-write provided a permit.

Params
Return values

[method]output-stream.blocking-write-and-flush: func

Perform a write of up to 4096 bytes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

This is a convenience wrapper around the use of check-write, subscribe, write, and flush, and is implemented with the following pseudo-code:

let pollable = this.subscribe();
while !contents.is_empty() {
  // Wait for the stream to become writable
  pollable.block();
  let Ok(n) = this.check-write(); // eliding error handling
  let len = min(n, contents.len());
  let (chunk, rest) = contents.split_at(len);
  this.write(chunk  );            // eliding error handling
  contents = rest;
}
this.flush();
// Wait for completion of `flush`
pollable.block();
// Check for any errors that arose during `flush`
let _ = this.check-write();         // eliding error handling
Params
Return values

[method]output-stream.flush: func

Request to flush buffered output. This function never blocks.

This tells the output-stream that the caller intends any buffered output to be flushed. the output which is expected to be flushed is all that has been passed to write prior to this call.

Upon calling this function, the output-stream will not accept any writes (check-write will return ok(0)) until the flush has completed. The subscribe pollable will become ready when the flush has completed and the stream can accept more writes.

Params
Return values

[method]output-stream.blocking-flush: func

Request to flush buffered output, and block until flush completes and stream is ready for writing again.

Params
Return values

[method]output-stream.subscribe: func

Create a pollable which will resolve once the output-stream is ready for more writing, or an error has occurred. When this pollable is ready, check-write will return ok(n) with n>0, or an error.

If the stream is closed, this pollable is always ready immediately.

The created pollable is a child resource of the output-stream. Implementations may trap if the output-stream is dropped before all derived pollables created with this function are dropped.

Params
Return values

[method]output-stream.write-zeroes: func

Write zeroes to a stream.

This should be used precisely like write with the exact same preconditions (must use check-write first), but instead of passing a list of bytes, you simply pass the number of zero-bytes that should be written.

Params
Return values

[method]output-stream.blocking-write-zeroes-and-flush: func

Perform a write of up to 4096 zeroes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

This is a convenience wrapper around the use of check-write, subscribe, write-zeroes, and flush, and is implemented with the following pseudo-code:

let pollable = this.subscribe();
while num_zeroes != 0 {
  // Wait for the stream to become writable
  pollable.block();
  let Ok(n) = this.check-write(); // eliding error handling
  let len = min(n, num_zeroes);
  this.write-zeroes(len);         // eliding error handling
  num_zeroes -= len;
}
this.flush();
// Wait for completion of `flush`
pollable.block();
// Check for any errors that arose during `flush`
let _ = this.check-write();         // eliding error handling
Params
Return values

[method]output-stream.splice: func

Read from one stream and write to another.

The behavior of splice is equivalent to:

  1. calling check-write on the output-stream
  2. calling read on the input-stream with the smaller of the check-write permitted length and the len provided to splice
  3. calling write on the output-stream with that read data.

Any error reported by the call to check-write, read, or write ends the splice and reports that error.

This function returns the number of bytes transferred; it may be less than len.

Params
Return values

[method]output-stream.blocking-splice: func

Read from one stream and write to another, with blocking.

This is similar to splice, except that it blocks until the output-stream is ready for writing, and the input-stream is ready for reading, before performing the splice.

Params
Return values

Import interface wasi:blobstore/[email protected]

Types used by blobstore

Types

type input-stream

input-stream

#### `type output-stream` [`output-stream`](#output_stream)

#### `type container-name` `string`

name of a container, a collection of objects. The container name may be any valid UTF-8 string.

type object-name

string

name of an object within a container The object name may be any valid UTF-8 string.

type timestamp

u64

TODO: define timestamp to include seconds since Unix epoch and nanoseconds WebAssembly/wasi-blobstore#7

type object-size

u64

size of an object, in bytes

type error

string

#### `record container-metadata`

information about a container

Record Fields

record object-metadata

information about an object

Record Fields

record object-id

identifier for an object that includes its container name

Record Fields

resource outgoing-value

A data is the data stored in a data blob. The value can be of any type that can be represented in a byte array. It provides a way to write the value to the output-stream defined in the wasi-io interface. Soon: switch to resource value { ... }

resource incoming-value

A incoming-value is a wrapper around a value. It provides a way to read the value from the input-stream defined in the wasi-io interface.

The incoming-value provides two ways to consume the value:

  1. incoming-value-consume-sync consumes the value synchronously and returns the value as a list of bytes.
  2. incoming-value-consume-async consumes the value asynchronously and returns the value as an input-stream. Soon: switch to resource incoming-value { ... }

type incoming-value-async-body

input-stream

#### `type incoming-value-sync-body` [`incoming-value-sync-body`](#incoming_value_sync_body)

----

Functions

[static]outgoing-value.new-outgoing-value: func

Return values

[method]outgoing-value.outgoing-value-write-body: func

Returns a stream for writing the value contents.

The returned output-stream is a child resource: it must be dropped before the parent outgoing-value resource is dropped (or finished), otherwise the outgoing-value drop or finish will trap.

Returns success on the first call: the output-stream resource for this outgoing-value may be retrieved at most once. Subsequent calls will return error.

Params
Return values

[static]outgoing-value.finish: func

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.

Params
Return values

[static]incoming-value.incoming-value-consume-sync: func

Params
Return values

[static]incoming-value.incoming-value-consume-async: func

Params
Return values

[method]incoming-value.size: func

Params
Return values
  • u64

Import interface wasi:blobstore/[email protected]

a Container is a collection of objects

Types

type input-stream

input-stream

#### `type output-stream` [`output-stream`](#output_stream)

#### `type container-metadata` [`container-metadata`](#container_metadata)

#### `type error` [`error`](#error)

#### `type incoming-value` [`incoming-value`](#incoming_value)

#### `type object-metadata` [`object-metadata`](#object_metadata)

#### `type object-name` [`object-name`](#object_name)

#### `type outgoing-value` [`outgoing-value`](#outgoing_value)

#### `resource container`

this defines the container resource

resource stream-object-names

this defines the stream-object-names resource which is a representation of stream

Functions

[method]container.name: func

returns container name

Params
Return values

[method]container.info: func

returns container metadata

Params
Return values

[method]container.get-data: func

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.

Params
Return values

[method]container.write-data: func

creates or replaces an object with the data blob.

Params
Return values

[method]container.list-objects: func

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

Params
Return values

[method]container.delete-object: func

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

Params
Return values

[method]container.delete-objects: func

deletes multiple objects in the container

Params
Return values

[method]container.has-object: func

returns true if the object exists in this container

Params
Return values

[method]container.object-info: func

returns metadata for the object

Params
Return values

[method]container.clear: func

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

Params
Return values

[method]stream-object-names.read-stream-object-names: func

reads the next number of objects from the stream

This function returns the list of objects read, and a boolean indicating if the end of the stream was reached.

Params
Return values

[method]stream-object-names.skip-stream-object-names: func

skip the next number of objects in the stream

This function returns the number of objects skipped, and a boolean indicating if the end of the stream was reached.

Params
Return values
  • result<(u64, bool), error>

Import interface wasi:blobstore/[email protected]

wasi-cloud Blobstore service definition

Types

type container

container

#### `type error` [`error`](#error)

#### `type container-name` [`container-name`](#container_name)

#### `type object-id` [`object-id`](#object_id)

----

Functions

create-container: func

creates a new empty container

Params
Return values

get-container: func

retrieves a container by name

Params
Return values

delete-container: func

deletes a container and all objects within it

Params
Return values

container-exists: func

returns true if the container exists

Params
Return values

copy-object: func

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.

Params
Return values

move-object: func

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.

Params
Return values

Import interface wasi:messaging/[email protected]

Types

resource client

A connection to a message-exchange service (e.g., buffer, broker, etc.).

resource error

TODO(danbugs): This should be eventually extracted as an underlying type for other wasi-cloud-core interfaces.

type channel

string

There are two types of channels: - publish-subscribe channel, which is a broadcast channel, and - point-to-point channel, which is a unicast channel.

The interface doesn't highlight this difference in the type itself as that's uniquely a consumer issue.

record guest-configuration

Configuration includes a required list of channels the guest is subscribing to, and an optional list of extensions key-value pairs (e.g., partitions/offsets to read from in Kafka/EventHubs, QoS etc.).

Record Fields
  • channels: list<channel>
  • extensions: option<list<(string, string)>>

enum format-spec

Format specification for messages

Enum Cases
  • cloudevents
  • http
  • amqp
  • mqtt
  • kafka
  • raw

record message

A message with a binary payload, a format specification, and decorative metadata.

Record Fields
  • data: list<u8>
  • format: format-spec
  • metadata: option<list<(string, string)>>

Functions

[static]client.connect: func

Params
  • name: string
Return values

[static]error.trace: func

Return values
  • string

Import interface wasi:messaging/[email protected]

Types

type client

client

#### `type channel` [`channel`](#channel)

#### `type message` [`message`](#message)

#### `type error` [`error`](#error)

----

Functions

send: func

Params
Return values

Import interface wasi:messaging/[email protected]

Types

type client

client

#### `type message` [`message`](#message)

#### `type channel` [`channel`](#channel)

#### `type error` [`error`](#error)

#### `type guest-configuration` [`guest-configuration`](#guest_configuration)

----

Functions

subscribe-try-receive: func

Blocking receive for t-milliseconds with ephemeral subscription – if no message is received, returns None

Params
Return values

subscribe-receive: func

Blocking receive until message with ephemeral subscription

Params
Return values

update-guest-configuration: func

'Fit-all' type function for updating a guest's configuration – this could be useful for:

  • unsubscribing from a channel,
  • checkpointing,
  • etc..
Params
Return values

complete-message: func

A message can exist under several statuses: (1) available: the message is ready to be read, (2) acquired: the message has been sent to a consumer (but still exists in the queue), (3) accepted (result of complete-message): the message has been received and ACK-ed by a consumer and can be safely removed from the queue, (4) rejected (result of abandon-message): the message has been received and NACK-ed by a consumer, at which point it can be:

  • deleted,
  • sent to a dead-letter queue, or
  • kept in the queue for further processing.
Params
Return values

abandon-message: func

Params
Return values

Import interface wasi:config/[email protected]

Types

variant error

An error type that encapsulates the different errors that can occur fetching configuration values.

Variant Cases

  • upstream: string

    This indicates an error from an "upstream" config source. As this could be almost _anything_ (such as Vault, Kubernetes ConfigMaps, KeyValue buckets, etc), the error message is a string.

  • io: string

    This indicates an error from an I/O operation. As this could be almost _anything_ (such as a file read, network connection, etc), the error message is a string. Depending on how this ends up being consumed, we may consider moving this to use the `wasi:io/error` type instead. For simplicity right now in supporting multiple implementations, it is being left as a string.

Functions

get: func

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

The value is returned as an option<string>. If the key is not found, Ok(none) is returned. If an error occurs, an Err(error) is returned.

Params
  • key: string
Return values
  • result<option<string>, error>

get-all: func

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

If an error occurs, an Err(error) is returned.

Return values
  • result<list<(string, string)>, error>

Import interface wasi:clocks/[email protected]

WASI Monotonic Clock is a clock API intended to let users measure elapsed time.

It is intended to be portable at least between Unix-family platforms and Windows.

A monotonic clock is a clock which has an unspecified initial value, and successive reads of the clock will produce non-decreasing values.

Types

type pollable

pollable

#### `type instant` `u64`

An instant in time, in nanoseconds. An instant is relative to an unspecified initial value, and can only be compared to instances from the same monotonic-clock.

type duration

u64

A duration of time, in nanoseconds.

Functions

now: func

Read the current value of the clock.

The clock is monotonic, therefore calling this function repeatedly will produce a sequence of non-decreasing values.

Return values

resolution: func

Query the resolution of the clock. Returns the duration of time corresponding to a clock tick.

Return values

subscribe-instant: func

Create a pollable which will resolve once the specified instant has occurred.

Params
Return values

subscribe-duration: func

Create a pollable that will resolve after the specified duration has elapsed from the time this function is invoked.

Params
Return values

Import interface wasi:clocks/[email protected]

WASI Wall Clock is a clock API intended to let users query the current time. The name "wall" makes an analogy to a "clock on the wall", which is not necessarily monotonic as it may be reset.

It is intended to be portable at least between Unix-family platforms and Windows.

A wall clock is a clock which measures the date and time according to some external reference.

External references may be reset, so this clock is not necessarily monotonic, making it unsuitable for measuring elapsed time.

It is intended for reporting the current date and time for humans.

Types

record datetime

A time and date in seconds plus nanoseconds.

Record Fields
  • seconds: u64
  • nanoseconds: u32

Functions

now: func

Read the current value of the clock.

This clock is not monotonic, therefore calling this function repeatedly will not necessarily produce a sequence of non-decreasing values.

The returned timestamps represent the number of seconds since 1970-01-01T00:00:00Z, also known as POSIX's Seconds Since the Epoch, also known as Unix Time.

The nanoseconds field of the output is always less than 1000000000.

Return values

resolution: func

Query the resolution of the clock.

The nanoseconds field of the output is always less than 1000000000.

Return values

Import interface wasi:random/[email protected]

WASI Random is a random data API.

It is intended to be portable at least between Unix-family platforms and Windows.

Functions

get-random-bytes: func

Return len cryptographically-secure random or pseudo-random bytes.

This function must produce data at least as cryptographically secure and fast as an adequately seeded cryptographically-secure pseudo-random number generator (CSPRNG). It must not block, from the perspective of the calling program, under any circumstances, including on the first request and on requests for numbers of bytes. The returned data must always be unpredictable.

This function must always return fresh data. Deterministic environments must omit this function, rather than implementing it with deterministic data.

Params
  • len: u64
Return values
  • list<u8>

get-random-u64: func

Return a cryptographically-secure random or pseudo-random u64 value.

This function returns the same type of data as get-random-bytes, represented as a u64.

Return values
  • u64

Import interface wasi:cli/[email protected]

Types

type output-stream

output-stream

----

Functions

get-stdout: func

Return values

Import interface wasi:cli/[email protected]

Types

type output-stream

output-stream

----

Functions

get-stderr: func

Return values

Import interface wasi:cli/[email protected]

Types

type input-stream

input-stream

----

Functions

get-stdin: func

Return values

Import interface wasi:http/[email protected]

This interface defines all of the types and methods for implementing HTTP Requests and Responses, both incoming and outgoing, as well as their headers, trailers, and bodies.

Types

type duration

duration

#### `type input-stream` [`input-stream`](#input_stream)

#### `type output-stream` [`output-stream`](#output_stream)

#### `type io-error` [`error`](#error)

#### `type pollable` [`pollable`](#pollable)

#### `variant method`

This type corresponds to HTTP standard Methods.

Variant Cases
  • get
  • head
  • post
  • put
  • delete
  • connect
  • options
  • trace
  • patch
  • other: string

variant scheme

This type corresponds to HTTP standard Related Schemes.

Variant Cases
  • HTTP
  • HTTPS
  • other: string

record DNS-error-payload

Defines the case payload type for DNS-error above:

Record Fields
  • rcode: option<string>
  • info-code: option<u16>

record TLS-alert-received-payload

Defines the case payload type for TLS-alert-received above:

Record Fields
  • alert-id: option<u8>
  • alert-message: option<string>

record field-size-payload

Defines the case payload type for HTTP-response-{header,trailer}-size above:

Record Fields
  • field-name: option<string>
  • field-size: option<u32>

variant error-code

These cases are inspired by the IANA HTTP Proxy Error Types: https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types

Variant Cases
  • DNS-timeout
  • DNS-error: DNS-error-payload
  • destination-not-found
  • destination-unavailable
  • destination-IP-prohibited
  • destination-IP-unroutable
  • connection-refused
  • connection-terminated
  • connection-timeout
  • connection-read-timeout
  • connection-write-timeout
  • connection-limit-reached
  • TLS-protocol-error
  • TLS-certificate-error
  • TLS-alert-received: TLS-alert-received-payload
  • HTTP-request-denied
  • HTTP-request-length-required
  • HTTP-request-body-size: option<u64>
  • HTTP-request-method-invalid
  • HTTP-request-URI-invalid
  • HTTP-request-URI-too-long
  • HTTP-request-header-section-size: option<u32>
  • HTTP-request-header-size: option<field-size-payload>
  • HTTP-request-trailer-section-size: option<u32>
  • HTTP-request-trailer-size: field-size-payload
  • HTTP-response-incomplete
  • HTTP-response-header-section-size: option<u32>
  • HTTP-response-header-size: field-size-payload
  • HTTP-response-body-size: option<u64>
  • HTTP-response-trailer-section-size: option<u32>
  • HTTP-response-trailer-size: field-size-payload
  • HTTP-response-transfer-coding: option<string>
  • HTTP-response-content-coding: option<string>
  • HTTP-response-timeout
  • HTTP-upgrade-failed
  • HTTP-protocol-error
  • loop-detected
  • configuration-error
  • internal-error: option<string>

    This is a catch-all error for anything that doesn't fit cleanly into a more specific case. It also includes an optional string for an unstructured description of the error. Users should not depend on the string for diagnosing errors, as it's not required to be consistent between implementations.

variant header-error

This type enumerates the different kinds of errors that may occur when setting or appending to a fields resource.

Variant Cases

  • invalid-syntax

    This error indicates that a `field-name` or `field-value` was syntactically invalid when used with an operation that sets headers in a `fields`.

  • forbidden

    This error indicates that a forbidden `field-name` was used when trying to set a header in a `fields`.

  • immutable

    This error indicates that the operation on the `fields` was not permitted because the fields are immutable.

type field-key

string

Field keys are always strings.

Field keys should always be treated as case insensitive by the fields resource for the purposes of equality checking.

Deprecation

This type has been deprecated in favor of the field-name type.

type field-name

field-key

Field names are always strings.

Field names should always be treated as case insensitive by the fields resource for the purposes of equality checking.

type field-value

field-value

Field values should always be ASCII strings. However, in reality, HTTP implementations often have to interpret malformed values, so they are provided as a list of bytes.

resource fields

This following block defines the fields resource which corresponds to HTTP standard Fields. Fields are a common representation used for both Headers and Trailers.

A fields may be mutable or immutable. A fields created using the constructor, from-list, or clone will be mutable, but a fields resource given by other means (including, but not limited to, incoming-request.headers, outgoing-request.headers) might be be immutable. In an immutable fields, the set, append, and delete operations will fail with header-error.immutable.

type headers

fields

Headers is an alias for Fields.

type trailers

fields

Trailers is an alias for Fields.

resource incoming-request

Represents an incoming HTTP Request.

resource outgoing-request

Represents an outgoing HTTP Request.

resource request-options

Parameters for making an HTTP Request. Each of these parameters is currently an optional timeout applicable to the transport layer of the HTTP protocol.

These timeouts are separate from any the user may use to bound a blocking call to wasi:io/poll.poll.

resource response-outparam

Represents the ability to send an HTTP Response.

This resource is used by the wasi:http/incoming-handler interface to allow a Response to be sent corresponding to the Request provided as the other argument to incoming-handler.handle.

type status-code

u16

This type corresponds to the HTTP standard Status Code.

resource incoming-response

Represents an incoming HTTP Response.

resource incoming-body

Represents an incoming HTTP Request or Response's Body.

A body has both its contents - a stream of bytes - and a (possibly empty) set of trailers, indicating that the full contents of the body have been received. This resource represents the contents as an input-stream and the delivery of trailers as a future-trailers, and ensures that the user of this interface may only be consuming either the body contents or waiting on trailers at any given time.

resource future-trailers

Represents a future which may eventually return trailers, or an error.

In the case that the incoming HTTP Request or Response did not have any trailers, this future will resolve to the empty set of trailers once the complete Request or Response body has been received.

resource outgoing-response

Represents an outgoing HTTP Response.

resource outgoing-body

Represents an outgoing HTTP Request or Response's Body.

A body has both its contents - a stream of bytes - and a (possibly empty) set of trailers, inducating the full contents of the body have been sent. This resource represents the contents as an output-stream child resource, and the completion of the body (with optional trailers) with a static function that consumes the outgoing-body resource, and ensures that the user of this interface may not write to the body contents after the body has been finished.

If the user code drops this resource, as opposed to calling the static method finish, the implementation should treat the body as incomplete, and that an error has occurred. The implementation should propagate this error to the HTTP protocol by whatever means it has available, including: corrupting the body on the wire, aborting the associated Request, or sending a late status code for the Response.

resource future-incoming-response

Represents a future which may eventually return an incoming HTTP Response, or an error.

This resource is returned by the wasi:http/outgoing-handler interface to provide the HTTP Response corresponding to the sent Request.

Functions

http-error-code: func

Attempts to extract a http-related error from the wasi:io error provided.

Stream operations which return wasi:io/stream/stream-error::last-operation-failed have a payload of type wasi:io/error/error with more information about the operation that failed. This payload can be passed through to this function to see if there's http-related information about the error to return.

Note that this function is fallible because not all io-errors are http-related errors.

Params
Return values

[constructor]fields: func

Construct an empty HTTP Fields.

The resulting fields is mutable.

Return values

[static]fields.from-list: func

Construct an HTTP Fields.

The resulting fields is mutable.

The list represents each name-value pair in the Fields. Names which have multiple values are represented by multiple entries in this list with the same name.

The tuple is a pair of the field name, represented as a string, and Value, represented as a list of bytes.

An error result will be returned if any field-name or field-value is syntactically invalid, or if a field is forbidden.

Params
Return values

[method]fields.get: func

Get all of the values corresponding to a name. If the name is not present in this fields or is syntactically invalid, an empty list is returned. However, if the name is present but empty, this is represented by a list with one or more empty field-values present.

Params
Return values

[method]fields.has: func

Returns true when the name is present in this fields. If the name is syntactically invalid, false is returned.

Params
Return values
  • bool

[method]fields.set: func

Set all of the values for a name. Clears any existing values for that name, if they have been set.

Fails with header-error.immutable if the fields are immutable.

Fails with header-error.invalid-syntax if the field-name or any of the field-values are syntactically invalid.

Params
Return values

[method]fields.delete: func

Delete all values for a name. Does nothing if no values for the name exist.

Fails with header-error.immutable if the fields are immutable.

Fails with header-error.invalid-syntax if the field-name is syntactically invalid.

Params
Return values

[method]fields.append: func

Append a value for a name. Does not change or delete any existing values for that name.

Fails with header-error.immutable if the fields are immutable.

Fails with header-error.invalid-syntax if the field-name or field-value are syntactically invalid.

Params
Return values

[method]fields.entries: func

Retrieve the full set of names and values in the Fields. Like the constructor, the list represents each name-value pair.

The outer list represents each name-value pair in the Fields. Names which have multiple values are represented by multiple entries in this list with the same name.

The names and values are always returned in the original casing and in the order in which they will be serialized for transport.

Params
Return values

[method]fields.clone: func

Make a deep copy of the Fields. Equivalent in behavior to calling the fields constructor on the return value of entries. The resulting fields is mutable.

Params
Return values

[method]incoming-request.method: func

Returns the method of the incoming request.

Params
Return values

[method]incoming-request.path-with-query: func

Returns the path with query parameters from the request, as a string.

Params
Return values
  • option<string>

[method]incoming-request.scheme: func

Returns the protocol scheme from the request.

Params
Return values

[method]incoming-request.authority: func

Returns the authority of the Request's target URI, if present.

Params
Return values
  • option<string>

[method]incoming-request.headers: func

Get the headers associated with the request.

The returned headers resource is immutable: set, append, and delete operations will fail with header-error.immutable.

The headers returned are a child resource: it must be dropped before the parent incoming-request is dropped. Dropping this incoming-request before all children are dropped will trap.

Params
Return values

[method]incoming-request.consume: func

Gives the incoming-body associated with this request. Will only return success at most once, and subsequent calls will return error.

Params
Return values

[constructor]outgoing-request: func

Construct a new outgoing-request with a default method of GET, and none values for path-with-query, scheme, and authority.

  • headers is the HTTP Headers for the Request.

It is possible to construct, or manipulate with the accessor functions below, an outgoing-request with an invalid combination of scheme and authority, or headers which are not permitted to be sent. It is the obligation of the outgoing-handler.handle implementation to reject invalid constructions of outgoing-request.

Params
Return values

[method]outgoing-request.body: func

Returns the resource corresponding to the outgoing Body for this Request.

Returns success on the first call: the outgoing-body resource for this outgoing-request can be retrieved at most once. Subsequent calls will return error.

Params
Return values

[method]outgoing-request.method: func

Get the Method for the Request.

Params
Return values

[method]outgoing-request.set-method: func

Set the Method for the Request. Fails if the string present in a method.other argument is not a syntactically valid method.

Params
Return values
  • result

[method]outgoing-request.path-with-query: func

Get the combination of the HTTP Path and Query for the Request. When none, this represents an empty Path and empty Query.

Params
Return values
  • option<string>

[method]outgoing-request.set-path-with-query: func

Set the combination of the HTTP Path and Query for the Request. When none, this represents an empty Path and empty Query. Fails is the string given is not a syntactically valid path and query uri component.

Params
Return values
  • result

[method]outgoing-request.scheme: func

Get the HTTP Related Scheme for the Request. When none, the implementation may choose an appropriate default scheme.

Params
Return values

[method]outgoing-request.set-scheme: func

Set the HTTP Related Scheme for the Request. When none, the implementation may choose an appropriate default scheme. Fails if the string given is not a syntactically valid uri scheme.

Params
Return values
  • result

[method]outgoing-request.authority: func

Get the authority of the Request's target URI. A value of none may be used with Related Schemes which do not require an authority. The HTTP and HTTPS schemes always require an authority.

Params
Return values
  • option<string>

[method]outgoing-request.set-authority: func

Set the authority of the Request's target URI. A value of none may be used with Related Schemes which do not require an authority. The HTTP and HTTPS schemes always require an authority. Fails if the string given is not a syntactically valid URI authority.

Params
Return values
  • result

[method]outgoing-request.headers: func

Get the headers associated with the Request.

The returned headers resource is immutable: set, append, and delete operations will fail with header-error.immutable.

This headers resource is a child: it must be dropped before the parent outgoing-request is dropped, or its ownership is transferred to another component by e.g. outgoing-handler.handle.

Params
Return values

[constructor]request-options: func

Construct a default request-options value.

Return values

[method]request-options.connect-timeout: func

The timeout for the initial connect to the HTTP Server.

Params
Return values

[method]request-options.set-connect-timeout: func

Set the timeout for the initial connect to the HTTP Server. An error return value indicates that this timeout is not supported.

Params
Return values
  • result

[method]request-options.first-byte-timeout: func

The timeout for receiving the first byte of the Response body.

Params
Return values

[method]request-options.set-first-byte-timeout: func

Set the timeout for receiving the first byte of the Response body. An error return value indicates that this timeout is not supported.

Params
Return values
  • result

[method]request-options.between-bytes-timeout: func

The timeout for receiving subsequent chunks of bytes in the Response body stream.

Params
Return values

[method]request-options.set-between-bytes-timeout: func

Set the timeout for receiving subsequent chunks of bytes in the Response body stream. An error return value indicates that this timeout is not supported.

Params
Return values
  • result

[static]response-outparam.set: func

Set the value of the response-outparam to either send a response, or indicate an error.

This method consumes the response-outparam to ensure that it is called at most once. If it is never called, the implementation will respond with an error.

The user may provide an error to response to allow the implementation determine how to respond with an HTTP error response.

Params

[method]incoming-response.status: func

Returns the status code from the incoming response.

Params
Return values

[method]incoming-response.headers: func

Returns the headers from the incoming response.

The returned headers resource is immutable: set, append, and delete operations will fail with header-error.immutable.

This headers resource is a child: it must be dropped before the parent incoming-response is dropped.

Params
Return values

[method]incoming-response.consume: func

Returns the incoming body. May be called at most once. Returns error if called additional times.

Params
Return values

[method]incoming-body.stream: func

Returns the contents of the body, as a stream of bytes.

Returns success on first call: the stream representing the contents can be retrieved at most once. Subsequent calls will return error.

The returned input-stream resource is a child: it must be dropped before the parent incoming-body is dropped, or consumed by incoming-body.finish.

This invariant ensures that the implementation can determine whether the user is consuming the contents of the body, waiting on the future-trailers to be ready, or neither. This allows for network backpressure is to be applied when the user is consuming the body, and for that backpressure to not inhibit delivery of the trailers if the user does not read the entire body.

Params
Return values

[static]incoming-body.finish: func

Takes ownership of incoming-body, and returns a future-trailers. This function will trap if the input-stream child is still alive.

Params
Return values

[method]future-trailers.subscribe: func

Returns a pollable which becomes ready when either the trailers have been received, or an error has occurred. When this pollable is ready, the get method will return some.

Params
Return values

[method]future-trailers.get: func

Returns the contents of the trailers, or an error which occurred, once the future is ready.

The outer option represents future readiness. Users can wait on this option to become some using the subscribe method.

The outer result is used to retrieve the trailers or error at most once. It will be success on the first call in which the outer option is some, and error on subsequent calls.

The inner result represents that either the HTTP Request or Response body, as well as any trailers, were received successfully, or that an error occurred receiving them. The optional trailers indicates whether or not trailers were present in the body.

When some trailers are returned by this method, the trailers resource is immutable, and a child. Use of the set, append, or delete methods will return an error, and the resource must be dropped before the parent future-trailers is dropped.

Params
Return values

[constructor]outgoing-response: func

Construct an outgoing-response, with a default status-code of 200. If a different status-code is needed, it must be set via the set-status-code method.

  • headers is the HTTP Headers for the Response.
Params
Return values

[method]outgoing-response.status-code: func

Get the HTTP Status Code for the Response.

Params
Return values

[method]outgoing-response.set-status-code: func

Set the HTTP Status Code for the Response. Fails if the status-code given is not a valid http status code.

Params
Return values
  • result

[method]outgoing-response.headers: func

Get the headers associated with the Request.

The returned headers resource is immutable: set, append, and delete operations will fail with header-error.immutable.

This headers resource is a child: it must be dropped before the parent outgoing-request is dropped, or its ownership is transferred to another component by e.g. outgoing-handler.handle.

Params
Return values

[method]outgoing-response.body: func

Returns the resource corresponding to the outgoing Body for this Response.

Returns success on the first call: the outgoing-body resource for this outgoing-response can be retrieved at most once. Subsequent calls will return error.

Params
Return values

[method]outgoing-body.write: func

Returns a stream for writing the body contents.

The returned output-stream is a child resource: it must be dropped before the parent outgoing-body resource is dropped (or finished), otherwise the outgoing-body drop or finish will trap.

Returns success on the first call: the output-stream resource for this outgoing-body may be retrieved at most once. Subsequent calls will return error.

Params
Return values

[static]outgoing-body.finish: func

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

Fails if the body's outgoing-request or outgoing-response was constructed with a Content-Length header, and the contents written to the body (via write) does not match the value given in the Content-Length.

Params
Return values

[method]future-incoming-response.subscribe: func

Returns a pollable which becomes ready when either the Response has been received, or an error has occurred. When this pollable is ready, the get method will return some.

Params
Return values

[method]future-incoming-response.get: func

Returns the incoming HTTP Response, or an error, once one is ready.

The outer option represents future readiness. Users can wait on this option to become some using the subscribe method.

The outer result is used to retrieve the response or error at most once. It will be success on the first call in which the outer option is some, and error on subsequent calls.

The inner result represents that either the incoming HTTP Response status and headers have received successfully, or that an error occurred. Errors may also occur while consuming the response body, but those will be reported by the incoming-body and its output-stream child.

Params
Return values

Import interface wasi:http/[email protected]

This interface defines a handler of outgoing HTTP Requests. It should be imported by components which wish to make HTTP Requests.

Types

type outgoing-request

outgoing-request

#### `type request-options` [`request-options`](#request_options)

#### `type future-incoming-response` [`future-incoming-response`](#future_incoming_response)

#### `type error-code` [`error-code`](#error_code)

----

Functions

handle: func

This function is invoked with an outgoing HTTP Request, and it returns a resource future-incoming-response which represents an HTTP Response which may arrive in the future.

The options argument accepts optional parameters for the HTTP protocol's transport layer.

This function may return an error if the outgoing-request is invalid or not allowed to be made. Otherwise, protocol errors are reported through the future-incoming-response.

Params
Return values

Export interface wasi:messaging/[email protected]

Types

type message

message

#### `type guest-configuration` [`guest-configuration`](#guest_configuration)

#### `type error` [`error`](#error)

----

Functions

configure: func

Returns the list of channels (and extension metadata within guest-configuration) that this component should subscribe to and be handled by the subsequent handler within guest-configuration

Return values

handler: func

Whenever this guest receives a message in one of the subscribed channels, the message is sent to this handler

Params
Return values