interfaces
World interfaces
- Imports:
- interface
wasi:io/error@0.2.0-rc-2023-11-10
- interface
wasi:io/poll@0.2.0-rc-2023-11-10
- interface
wasi:io/streams@0.2.0-rc-2023-11-10
- interface
wasmcloud:bus/lattice
- interface
wasmcloud:bus/host
- interface
wasmcloud:bus/guest-config
- interface
wasi:blobstore/types
- interface
wasi:blobstore/container
- interface
wasi:blobstore/blobstore
- interface
wasi:clocks/monotonic-clock@0.2.0-rc-2023-11-10
- interface
wasi:http/types@0.2.0-rc-2023-12-05
- interface
wasi:http/outgoing-handler@0.2.0-rc-2023-12-05
- interface
wasi:keyvalue/wasi-cloud-error
- interface
wasi:keyvalue/types
- interface
wasi:keyvalue/atomic
- interface
wasi:keyvalue/readwrite
- interface
wasi:logging/logging
- interface
wasmcloud:messaging/types
- interface
wasmcloud:messaging/consumer
- interface
Import interface wasi:io/error@0.2.0-rc-2023-11-10
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
provide functions to further "downcast" this error into more specific
error information. For example, error
s returned in streams derived
from filesystem types to be described using the filesystem's own
error-code type, using the function
wasi:filesystem/types/filesystem-error-code
, which takes a parameter
borrow<error>
and returns
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
Import interface wasi:io/poll@0.2.0-rc-2023-11-10
A poll API intended to let users wait for I/O events on multiple handles at once.
Types
resource pollable
pollable
epresents 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
[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.
If the list contains more elements than can be indexed with a u32
value, this function traps.
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 reaedy for I/O.
Params
Return values
Import interface wasi:io/streams@0.2.0-rc-2023-11-10
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
#### `type pollable` [`pollable`](#pollable)
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. -
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-stream
s 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-stream
s 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
.
Functions
[method]input-stream.read: func
Perform a non-blocking read from the stream.
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
self
: borrow<input-stream
>len
:u64
Return values
- result<list<
u8
>,stream-error
>
[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
self
: borrow<input-stream
>len
:u64
Return values
- result<list<
u8
>,stream-error
>
[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
self
: borrow<input-stream
>len
:u64
Return values
- result<
u64
,stream-error
>
[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
self
: borrow<input-stream
>len
:u64
Return values
- result<
u64
,stream-error
>
[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 pollable
s created with this function are dropped.
Params
self
: borrow<input-stream
>
Return values
- own<
pollable
>
[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
self
: borrow<output-stream
>
Return values
- result<
u64
,stream-error
>
[method]output-stream.write: func
Perform a write. This function never blocks.
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
self
: borrow<output-stream
>contents
: list<u8
>
Return values
- result<_,
stream-error
>
[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
poll-one(pollable);
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`
poll-one(pollable);
// Check for any errors that arose during `flush`
let _ = this.check-write(); // eliding error handling
Params
self
: borrow<output-stream
>contents
: list<u8
>
Return values
- result<_,
stream-error
>
[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
self
: borrow<output-stream
>
Return values
- result<_,
stream-error
>
[method]output-stream.blocking-flush: func
Request to flush buffered output, and block until flush completes and stream is ready for writing again.
Params
self
: borrow<output-stream
>
Return values
- result<_,
stream-error
>
[method]output-stream.subscribe: func
Create a pollable
which will resolve once the output-stream
is ready for more writing, or an error has occured. 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 pollable
s created with this function are dropped.
Params
self
: borrow<output-stream
>
Return values
- own<
pollable
>
[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
self
: borrow<output-stream
>len
:u64
Return values
- result<_,
stream-error
>
[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
poll-one(pollable);
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`
poll-one(pollable);
// Check for any errors that arose during `flush`
let _ = this.check-write(); // eliding error handling
Params
self
: borrow<output-stream
>len
:u64
Return values
- result<_,
stream-error
>
[method]output-stream.splice: func
Read from one stream and write to another.
The behavior of splice is equivelant to:
- calling
check-write
on theoutput-stream
- calling
read
on theinput-stream
with the smaller of thecheck-write
permitted length and thelen
provided tosplice
- calling
write
on theoutput-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
self
: borrow<output-stream
>src
: borrow<input-stream
>len
:u64
Return values
- result<
u64
,stream-error
>
[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
self
: borrow<output-stream
>src
: borrow<input-stream
>len
:u64
Return values
- result<
u64
,stream-error
>
Import interface wasmcloud:bus/lattice
Types
resource target-interface
Interface target. This represents an interface, which can be selected by set-target
.
The set of target-*
functions defines all "selectable" interfaces provided by the host.
Implementations of wasmcloud:bus/lattice
may extend the set of "selectable" interfaces.
variant actor-identifier
Actor identifier
Variant Cases
-
public-key
:string
Actor public key
-
alias
:string
Actor call alias
variant target-entity
Target entity
Variant Cases
-
link
: option<string
>Link target paired with an optional link name
-
Actor target
Functions
[constructor]target-interface: func
Params
Return values
- own<
target-interface
>
[static]target-interface.wasi-blobstore-blobstore: func
wasi:blobstore/blobstore
interface target
Return values
- own<
target-interface
>
[static]target-interface.wasi-keyvalue-atomic: func
wasi:keyvalue/atomic
interface target
Return values
- own<
target-interface
>
[static]target-interface.wasi-keyvalue-readwrite: func
wasi:keyvalue/readwrite
interface target
Return values
- own<
target-interface
>
[static]target-interface.wasi-logging-logging: func
wasi:logging/logging
interface target
Return values
- own<
target-interface
>
[static]target-interface.wasmcloud-messaging-consumer: func
wasmcloud:messaging/consumer
interface target
Return values
- own<
target-interface
>
[static]target-interface.wasi-http-outgoing-handler: func
wasi:http/outgoing-handler
interface target
Return values
- own<
target-interface
>
set-target: func
Set an optional target for all interfaces specified. If target
is none
, then target is set to default.
Params
target
: option<target-entity
>interfaces
: list<own<target-interface
>>
Import interface wasmcloud:bus/host
Types
type input-stream
#### `type output-stream` [`output-stream`](#output_stream)
#### `type pollable` [`pollable`](#pollable)
#### `type target-interface` [`target-interface`](#target_interface)
#### `type target-entity` [`target-entity`](#target_entity)
#### `type future-result` `u32`
----
Functions
drop-future-result: func
Params
future-result-get: func
Params
Return values
listen-to-future-result: func
Params
Return values
- own<
pollable
>
call: func
Call an operation of form namespace:package/interface.operation
, e.g. wasmcloud:bus/host.call
Params
target
: option<target-entity
>operation
:string
Return values
- result<(
future-result
, own<input-stream
>, own<output-stream
>),string
>
call-sync: func
Synchronously call an operation of form namespace:package/interface.operation
, e.g. wasmcloud:bus/host.call-sync
Params
target
: option<target-entity
>operation
:string
payload
: list<u8
>
Return values
Import interface wasmcloud:bus/guest-config
An interface for getting configuration data for a wasm module
Types
variant config-error
Errors that can be returned from config sources
Variant Cases
-
upstream
:string
An error occurred on the config source when fetching data
-
io
:string
I/O or connection failure
Functions
get: func
Gets a single opaque config value set at the given key if it exists
Params
key
:string
Return values
- result<option<list<
u8
>>,config-error
>
get-all: func
Gets a list of all set config data
Return values
- result<list<(
string
, list<u8
>)>,config-error
>
Import interface wasi:blobstore/types
Types
type input-stream
#### `type output-stream` [`output-stream`](#output_stream)
#### `type container-name` `string`
#### `type object-name` `string`
#### `type timestamp` `u64`
#### `type object-size` `u64`
#### `type error` `string`
#### `record container-metadata`
Record Fields
record object-metadata
Record Fields
record object-id
Record Fields
type outgoing-value
u32
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.
type incoming-value
u32
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:
incoming-value-consume-sync
consumes the value synchronously and returns the value as a list of bytes.incoming-value-consume-async
consumes the value asynchronously and returns the value as an input-stream.
type incoming-value-async-body
#### `type incoming-value-sync-body` [`incoming-value-sync-body`](#incoming_value_sync_body)
----
Functions
drop-outgoing-value: func
Params
new-outgoing-value: func
Return values
outgoing-value-write-body: func
Params
Return values
- result<own<
output-stream
>>
drop-incoming-value: func
Params
incoming-value-consume-sync: func
Params
Return values
- result<
incoming-value-sync-body
,error
>
incoming-value-consume-async: func
Params
Return values
- result<own<
incoming-value-async-body
>,error
>
size: func
Params
Return values
Import interface wasi:blobstore/container
Types
type 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)
#### `type container` `u32`
#### `type stream-object-names` `u32`
----
Functions
drop-container: func
Params
name: func
Params
Return values
- result<
string
,error
>
info: func
Params
Return values
- result<
container-metadata
,error
>
get-data: func
Params
Return values
- result<
incoming-value
,error
>
write-data: func
Params
Return values
- result<_,
error
>
drop-stream-object-names: func
Params
read-stream-object-names: func
Params
this
:stream-object-names
len
:u64
Return values
- result<(list<
object-name
>,bool
),error
>
skip-stream-object-names: func
Params
this
:stream-object-names
num
:u64
Return values
- result<(
u64
,bool
),error
>
list-objects: func
Params
Return values
- result<
stream-object-names
,error
>
delete-object: func
Params
Return values
- result<_,
error
>
delete-objects: func
Params
container
:container
names
: list<object-name
>
Return values
- result<_,
error
>
has-object: func
Params
Return values
- result<
bool
,error
>
object-info: func
Params
Return values
- result<
object-metadata
,error
>
clear: func
Params
Return values
- result<_,
error
>
Import interface wasi:blobstore/blobstore
Types
type container
#### `type error` [`error`](#error)
#### `type container-name` [`container-name`](#container_name)
#### `type object-id` [`object-id`](#object_id)
----
Functions
create-container: func
Params
Return values
get-container: func
Params
Return values
delete-container: func
Params
Return values
- result<_,
error
>
container-exists: func
Params
Return values
- result<
bool
,error
>
copy-object: func
Params
Return values
- result<_,
error
>
move-object: func
Params
Return values
- result<_,
error
>
Import interface wasi:clocks/monotonic-clock@0.2.0-rc-2023-11-10
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.
It is intended for measuring elapsed time.
Types
type 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
occured.
Params
Return values
- own<
pollable
>
subscribe-duration: func
Create a pollable
which will resolve once the given duration has
elapsed, starting at the time at which this function was called.
occured.
Params
Return values
- own<
pollable
>
Import interface wasi:http/types@0.2.0-rc-2023-12-05
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
#### `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
variant scheme
This type corresponds to HTTP standard Related Schemes.
Variant Cases
record DNS-error-payload
Defines the case payload type for DNS-error
above:
Record Fields
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
-
This error indicates that a `field-key` or `field-value` was syntactically invalid when used with an operation that sets headers in a `fields`.
-
This error indicates that a forbidden `field-key` was used when trying to set a header in a `fields`.
-
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.
type 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
Headers is an alias for Fields.
type trailers
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 eventaully 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 occured. The implementation should propogate 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 eventaully 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
- option<
error-code
>
[constructor]fields: func
Construct an empty HTTP Fields.
The resulting fields
is mutable.
Return values
- own<
fields
>
[static]fields.from-list: func
Construct an HTTP Fields.
The resulting fields
is mutable.
The list represents each key-value pair in the Fields. Keys which have multiple values are represented by multiple entries in this list with the same key.
The tuple is a pair of the field key, represented as a string, and Value, represented as a list of bytes. In a valid Fields, all keys and values are valid UTF-8 strings. However, values are not always well-formed, so they are represented as a raw list of bytes.
An error result will be returned if any header or value was syntactically invalid, or if a header was forbidden.
Params
entries
: list<(field-key
,field-value
)>
Return values
- result<own<
fields
>,header-error
>
[method]fields.get: func
Get all of the values corresponding to a key. If the key is not present
in this fields
, an empty list is returned. However, if the key is
present but empty, this is represented by a list with one or more
empty field-values present.
Params
Return values
- list<
field-value
>
[method]fields.has: func
Returns true
when the key is present in this fields
. If the key is
syntactically invalid, false
is returned.
Params
Return values
[method]fields.set: func
Set all of the values for a key. Clears any existing values for that key, if they have been set.
Fails with header-error.immutable
if the fields
are immutable.
Params
Return values
- result<_,
header-error
>
[method]fields.delete: func
Delete all values for a key. Does nothing if no values for the key exist.
Fails with header-error.immutable
if the fields
are immutable.
Params
Return values
- result<_,
header-error
>
[method]fields.append: func
Append a value for a key. Does not change or delete any existing values for that key.
Fails with header-error.immutable
if the fields
are immutable.
Params
Return values
- result<_,
header-error
>
[method]fields.entries: func
Retrieve the full set of keys and values in the Fields. Like the constructor, the list represents each key-value pair.
The outer list represents each key-value pair in the Fields. Keys which have multiple values are represented by multiple entries in this list with the same key.
Params
Return values
- list<(
field-key
,field-value
)>
[method]fields.clone: func
Make a deep copy of the Fields. Equivelant in behavior to calling the
fields
constructor on the return value of entries
. The resulting
fields
is mutable.
Params
Return values
- own<
fields
>
[method]incoming-request.method: func
Returns the method of the incoming request.
Params
self
: borrow<incoming-request
>
Return values
[method]incoming-request.path-with-query: func
Returns the path with query parameters from the request, as a string.
Params
self
: borrow<incoming-request
>
Return values
[method]incoming-request.scheme: func
Returns the protocol scheme from the request.
Params
self
: borrow<incoming-request
>
Return values
- option<
scheme
>
[method]incoming-request.authority: func
Returns the authority from the request, if it was present.
Params
self
: borrow<incoming-request
>
Return values
[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
self
: borrow<incoming-request
>
Return values
- own<
headers
>
[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
self
: borrow<incoming-request
>
Return values
- result<own<
incoming-body
>>
[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
- own<
outgoing-request
>
[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
self
: borrow<outgoing-request
>
Return values
- result<own<
outgoing-body
>>
[method]outgoing-request.method: func
Get the Method for the Request.
Params
self
: borrow<outgoing-request
>
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
self
: borrow<outgoing-request
>method
:method
Return values
[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
self
: borrow<outgoing-request
>
Return values
[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
self
: borrow<outgoing-request
>path-with-query
: option<string
>
Return values
[method]outgoing-request.scheme: func
Get the HTTP Related Scheme for the Request. When none
, the
implementation may choose an appropriate default scheme.
Params
self
: borrow<outgoing-request
>
Return values
- option<
scheme
>
[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
self
: borrow<outgoing-request
>scheme
: option<scheme
>
Return values
[method]outgoing-request.authority: func
Get the HTTP Authority for the Request. 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
self
: borrow<outgoing-request
>
Return values
[method]outgoing-request.set-authority: func
Set the HTTP Authority for the Request. 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
self
: borrow<outgoing-request
>authority
: option<string
>
Return values
[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 transfered to
another component by e.g. outgoing-handler.handle
.
Params
self
: borrow<outgoing-request
>
Return values
- own<
headers
>
[constructor]request-options: func
Construct a default request-options
value.
Return values
- own<
request-options
>
[method]request-options.connect-timeout: func
The timeout for the initial connect to the HTTP Server.
Params
self
: borrow<request-options
>
Return values
- option<
duration
>
[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
self
: borrow<request-options
>duration
: option<duration
>
Return values
[method]request-options.first-byte-timeout: func
The timeout for receiving the first byte of the Response body.
Params
self
: borrow<request-options
>
Return values
- option<
duration
>
[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
self
: borrow<request-options
>duration
: option<duration
>
Return values
[method]request-options.between-bytes-timeout: func
The timeout for receiving subsequent chunks of bytes in the Response body stream.
Params
self
: borrow<request-options
>
Return values
- option<
duration
>
[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
self
: borrow<request-options
>duration
: option<duration
>
Return values
[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
param
: own<response-outparam
>response
: result<own<outgoing-response
>,error-code
>
[method]incoming-response.status: func
Returns the status code from the incoming response.
Params
self
: borrow<incoming-response
>
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
self
: borrow<incoming-response
>
Return values
- own<
headers
>
[method]incoming-response.consume: func
Returns the incoming body. May be called at most once. Returns error if called additional times.
Params
self
: borrow<incoming-response
>
Return values
- result<own<
incoming-body
>>
[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
self
: borrow<incoming-body
>
Return values
- result<own<
input-stream
>>
[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
this
: own<incoming-body
>
Return values
- own<
future-trailers
>
[method]future-trailers.subscribe: func
Returns a pollable which becomes ready when either the trailers have
been received, or an error has occured. When this pollable is ready,
the get
method will return some
.
Params
self
: borrow<future-trailers
>
Return values
- own<
pollable
>
[method]future-trailers.get: func
Returns the contents of the trailers, or an error which occured, 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 occured 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
self
: borrow<future-trailers
>
Return values
- option<result<result<option<own<
trailers
>>,error-code
>>>
[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
- own<
outgoing-response
>
[method]outgoing-response.status-code: func
Get the HTTP Status Code for the Response.
Params
self
: borrow<outgoing-response
>
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
self
: borrow<outgoing-response
>status-code
:status-code
Return values
[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 transfered to
another component by e.g. outgoing-handler.handle
.
Params
self
: borrow<outgoing-response
>
Return values
- own<
headers
>
[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
self
: borrow<outgoing-response
>
Return values
- result<own<
outgoing-body
>>
[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
self
: borrow<outgoing-body
>
Return values
- result<own<
output-stream
>>
[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
this
: own<outgoing-body
>trailers
: option<own<trailers
>>
Return values
- result<_,
error-code
>
[method]future-incoming-response.subscribe: func
Returns a pollable which becomes ready when either the Response has
been received, or an error has occured. When this pollable is ready,
the get
method will return some
.
Params
self
: borrow<future-incoming-response
>
Return values
- own<
pollable
>
[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 recieved successfully, or that an error
occured. Errors may also occur while consuming the response body,
but those will be reported by the incoming-body
and its
output-stream
child.
Params
self
: borrow<future-incoming-response
>
Return values
- option<result<result<own<
incoming-response
>,error-code
>>>
Import interface wasi:http/outgoing-handler@0.2.0-rc-2023-12-05
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
#### `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
request
: own<outgoing-request
>options
: option<own<request-options
>>
Return values
- result<own<
future-incoming-response
>,error-code
>
Import interface wasi:keyvalue/wasi-cloud-error
Types
type error
u32
An error resource type for keyvalue operations. Currently, this provides only one function to return a string representation of the error. In the future, this will be extended to provide more information about the error.
Functions
drop-error: func
Params
trace: func
Params
Return values
Import interface wasi:keyvalue/types
Types
type input-stream
#### `type output-stream` [`output-stream`](#output_stream)
#### `type error` [`error`](#error)
#### `type bucket` `u32`
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,
- Amazon DynamoDB calls a collection of key-value pairs a table
- Redis has hashes, sets, and sorted sets as different types of collections
- Cassandra calls a collection of key-value pairs a column family
- MongoDB calls a collection of key-value pairs a collection
- Riak calls a collection of key-value pairs a bucket
- Memcached calls a collection of key-value pairs a slab
- 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
type key
string
A key is a unique identifier for a value in a bucket. The key is used to retrieve the value from the bucket.
type keys
A list of keys
type outgoing-value
u32
A value is the data stored in a key-value pair. 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.
type outgoing-value-body-async
#### `type outgoing-value-body-sync` [`outgoing-value-body-sync`](#outgoing_value_body_sync)
#### `type incoming-value` `u32`
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:
incoming-value-consume-sync
consumes the value synchronously and returns the value as a list of bytes.incoming-value-consume-async
consumes the value asynchronously and returns the value as an input-stream.
type incoming-value-async-body
#### `type incoming-value-sync-body` [`incoming-value-sync-body`](#incoming_value_sync_body)
----
Functions
drop-bucket: func
Params
open-bucket: func
Params
name
:string
Return values
drop-outgoing-value: func
Params
new-outgoing-value: func
Return values
outgoing-value-write-body-async: func
Params
Return values
- result<own<
outgoing-value-body-async
>,error
>
outgoing-value-write-body-sync: func
Params
Return values
- result<_,
error
>
drop-incoming-value: func
Params
incoming-value-consume-sync: func
Params
Return values
- result<
incoming-value-sync-body
,error
>
incoming-value-consume-async: func
Params
Return values
- result<own<
incoming-value-async-body
>,error
>
size: func
Params
Return values
Import interface wasi:keyvalue/atomic
A keyvalue interface that provides atomic operations.
Types
type bucket
#### `type error` [`error`](#error)
#### `type key` [`key`](#key)
----
Functions
increment: func
Atomically increment the value associated with the key in the bucket by the given delta. It returns the new value.
If the key does not exist in the bucket, it creates a new key-value pair with the value set to the given delta.
If any other error occurs, it returns an error.
Params
Return values
- result<
u64
,error
>
compare-and-swap: func
Atomically compare and swap the value associated with the key in the bucket. It returns a boolean indicating if the swap was successful.
If the key does not exist in the bucket, it returns an error.
Params
Return values
- result<
bool
,error
>
Import interface wasi:keyvalue/readwrite
A keyvalue interface that provides simple read and write operations.
Types
type bucket
#### `type error` [`error`](#error)
#### `type incoming-value` [`incoming-value`](#incoming_value)
#### `type key` [`key`](#key)
#### `type outgoing-value` [`outgoing-value`](#outgoing_value)
----
Functions
get: func
Get the value associated with the key in the bucket. It returns a incoming-value that can be consumed to get the value.
If the key does not exist in the bucket, it returns an error.
Params
Return values
- result<
incoming-value
,error
>
set: func
Set the value associated with the key in the bucket. If the key already exists in the bucket, it overwrites the value.
If the key does not exist in the bucket, it creates a new key-value pair. If any other error occurs, it returns an error.
Params
Return values
- result<_,
error
>
delete: func
Delete the key-value pair associated with the key in the bucket.
If the key does not exist in the bucket, it returns an error.
Params
Return values
- result<_,
error
>
exists: func
Check if the key exists in the bucket.
Params
Return values
- result<
bool
,error
>
Import interface wasi:logging/logging
WASI Logging is a logging API intended to let users emit log messages with simple priority levels and context values.
Types
enum level
A log level, describing a kind of message.
Enum Cases
-
Describes messages about the values of variables and the flow of control within a program.
-
Describes messages likely to be of interest to someone debugging a program.
-
Describes messages likely to be of interest to someone monitoring a program.
-
Describes messages indicating hazardous situations.
-
Describes messages indicating serious errors.
-
Describes messages indicating fatal errors.
Functions
log: func
Emit a log message.
A log message has a level
describing what kind of message is being
sent, a context, which is an uninterpreted string meant to help
consumers group similar messages, and a string containing the message
text.
Params
Import interface wasmcloud:messaging/types
Types
record broker-message
Record Fields
Import interface wasmcloud:messaging/consumer
Types
type broker-message
----
Functions
request: func
Params
subject
:string
body
: option<list<u8
>>timeout-ms
:u32
Return values
- result<
broker-message
,string
>
request-multi: func
Params
subject
:string
body
: option<list<u8
>>timeout-ms
:u32
max-results
:u32
Return values
- result<list<
broker-message
>,string
>