wasi:io/error@0.2.0wasi:io/poll@0.2.0wasi:io/streams@0.2.0wasi:blobstore/types@0.1.0wasi:blobstore/container@0.1.0wasi:blobstore/blobstore@0.1.0resource errorA 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, errors 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>.
error into a more
+concrete type is open.[method]error.to-debug-string: funcReturns 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.
+self: borrow<error>A poll API intended to let users wait for I/O events on multiple handles +at once.
+resource pollablepollable represents a single I/O event which may be ready, or not.[method]pollable.ready: funcReturn the readiness of a pollable. This function never blocks.
+Returns true when the pollable is ready, and false otherwise.
self: borrow<pollable>[method]pollable.block: funcblock 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.
self: borrow<pollable>poll: funcPoll 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.
in: list<borrow<pollable>>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.
+type error+#### `type pollable` +[`pollable`](#pollable) +
+#### `variant stream-error` +
An error for input-stream and output-stream operations.
+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-streamAn 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-streamAn 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.[method]input-stream.read: funcPerform 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.
self: borrow<input-stream>len: u64u8>, stream-error>[method]input-stream.blocking-read: funcRead bytes from a stream, after blocking until at least one byte can
+be read. Except for blocking, behavior is identical to read.
self: borrow<input-stream>len: u64u8>, stream-error>[method]input-stream.skip: funcSkip 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.
self: borrow<input-stream>len: u64u64, stream-error>[method]input-stream.blocking-skip: funcSkip bytes from a stream, after blocking until at least one byte
+can be skipped. Except for blocking behavior, identical to skip.
self: borrow<input-stream>len: u64u64, stream-error>[method]input-stream.subscribe: funcCreate 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.
self: borrow<input-stream>pollable>[method]output-stream.check-write: funcCheck 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.
self: borrow<output-stream>u64, stream-error>[method]output-stream.write: funcPerform 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.
+self: borrow<output-stream>contents: list<u8>stream-error>[method]output-stream.blocking-write-and-flush: funcPerform 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
+self: borrow<output-stream>contents: list<u8>stream-error>[method]output-stream.flush: funcRequest 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.
self: borrow<output-stream>stream-error>[method]output-stream.blocking-flush: funcRequest to flush buffered output, and block until flush completes +and stream is ready for writing again.
+self: borrow<output-stream>stream-error>[method]output-stream.subscribe: funcCreate 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 pollables created with this function are dropped.
self: borrow<output-stream>pollable>[method]output-stream.write-zeroes: funcWrite 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.
self: borrow<output-stream>len: u64stream-error>[method]output-stream.blocking-write-zeroes-and-flush: funcPerform 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
+self: borrow<output-stream>len: u64stream-error>[method]output-stream.splice: funcRead from one stream and write to another.
+The behavior of splice is equivelant to:
+check-write on the output-streamread on the input-stream with the smaller of the
+check-write permitted length and the len provided to splicewrite 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.
self: borrow<output-stream>src: borrow<input-stream>len: u64u64, stream-error>[method]output-stream.blocking-splice: funcRead 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.
self: borrow<output-stream>src: borrow<input-stream>len: u64u64, stream-error>Types used by blobstore
+type 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-namestring
name of an object within a container +The object name may be any valid UTF-8 string. +
type timestampu64
TODO: define timestamp to include seconds since +Unix epoch and nanoseconds +https://github.com/WebAssembly/wasi-blob-store/issues/7 +
type object-sizeu64
size of an object, in bytes +
type errorstring
+#### `record container-metadata` +
information about a container
+name: container-name
the container's name +
created-at: timestamp
date and time container was created +
record object-metadatainformation about an object
+name: object-name
the object's name +
the object's parent container +
created-at: timestamp
date and time the object was created +
size: object-size
size of the object, in bytes +
record object-ididentifier for an object that includes its container name
+container: container-nameobject: object-nameresource outgoing-valueA 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-valueA 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.
+Soon: switch to resource incoming-value { ... }type incoming-value-async-body+#### `type incoming-value-sync-body` +[`incoming-value-sync-body`](#incoming_value_sync_body) +
+---- +
[static]outgoing-value.new-outgoing-value: funcoutgoing-value>[method]outgoing-value.outgoing-value-write-body: funcself: borrow<outgoing-value>output-stream>>[method]incoming-value.incoming-value-consume-sync: funcself: borrow<incoming-value>incoming-value-sync-body, error>[method]incoming-value.incoming-value-consume-async: funcself: borrow<incoming-value>incoming-value-async-body>, error>[method]incoming-value.size: funcself: borrow<incoming-value>a Container is a collection of objects
+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) +
this defines the container resource
resource stream-object-namesstream-object-names resource which is a representation of stream[method]container.name: funcreturns container name
+self: borrow<container>string, error>[method]container.info: funcreturns container metadata
+self: borrow<container>container-metadata, error>[method]container.get-data: funcretrieves 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.
+self: borrow<container>name: object-namestart: u64end: u64incoming-value>, error>[method]container.write-data: funccreates or replaces an object with the data blob.
+self: borrow<container>name: object-namedata: borrow<outgoing-value>error>[method]container.list-objects: funcreturns list of objects in the container. Order is undefined.
+self: borrow<container>stream-object-names>, error>[method]container.delete-object: funcdeletes object. +does not return error if object did not exist.
+self: borrow<container>name: object-nameerror>[method]container.delete-objects: funcdeletes multiple objects in the container
+self: borrow<container>names: list<object-name>error>[method]container.has-object: funcreturns true if the object exists in this container
+self: borrow<container>name: object-namebool, error>[method]container.object-info: funcreturns metadata for the object
+self: borrow<container>name: object-nameobject-metadata, error>[method]container.clear: funcremoves all objects within the container, leaving the container empty.
+self: borrow<container>error>[method]stream-object-names.read-stream-object-names: funcreads 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.
+self: borrow<stream-object-names>len: u64object-name>, bool), error>[method]stream-object-names.skip-stream-object-names: funcskip 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.
+self: borrow<stream-object-names>num: u64u64, bool), error>wasi-cloud Blobstore service definition
+type container+#### `type error` +[`error`](#error) +
+#### `type container-name` +[`container-name`](#container_name) +
+#### `type object-id` +[`object-id`](#object_id) +
+---- +
create-container: funccreates a new empty container
+name: container-nameget-container: funcretrieves a container by name
+name: container-namedelete-container: funcdeletes a container and all objects within it
+name: container-nameerror>container-exists: funcreturns true if the container exists
+name: container-namebool, error>copy-object: funccopies (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.
+error>move-object: funcmoves 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.
+error>