Imports
- interface
componentized:services/types - interface
wasi:config/store@0.2.0-draft - interface
wasi:sockets/network@0.2.3 - interface
wasi:sockets/instance-network@0.2.3 - interface
wasi:io/poll@0.2.3 - interface
wasi:io/error@0.2.3 - interface
wasi:io/streams@0.2.3 - interface
wasi:sockets/tcp@0.2.3 - interface
wasi:sockets/tcp-create-socket@0.2.3 - interface
wasi:sockets/ip-name-lookup@0.2.3
Exports
- interface
componentized:services/credential-admin
Composition
Focused on
Drag to pan · Ctrl + scroll to zoom
WIT
package root:component;
world root {
import componentized:services/types;
import wasi:config/store@0.2.0-draft;
import wasi:sockets/network@0.2.3;
import wasi:sockets/instance-network@0.2.3;
import wasi:io/poll@0.2.3;
import wasi:io/error@0.2.3;
import wasi:io/streams@0.2.3;
import wasi:sockets/tcp@0.2.3;
import wasi:sockets/tcp-create-socket@0.2.3;
import wasi:sockets/ip-name-lookup@0.2.3;
export componentized:services/credential-admin;
}
The WIT of its dependencies, as it was built against them
This version keeps the parts of its dependencies it uses, as they were when it was built: their indexed versions differ from them, e.g. a pre-release that has since moved, or aren't indexed.
package componentized:services {
interface types {
type service-binding-id = string;
record credential {
key: string,
value: string,
}
type error = string;
}
interface credential-admin {
use types.{service-binding-id, credential, error};
publish: func(binding-id: service-binding-id, credentials: list<credential>) -> result<_, error>;
destroy: func(binding-id: service-binding-id) -> result<_, error>;
}
}
package wasi:config@0.2.0-draft {
interface store {
variant error {
upstream(string),
io(string),
}
get: func(key: string) -> result<option<string>, error>;
}
}
package wasi:io@0.2.3 {
interface poll {
resource pollable {
block: func();
}
}
interface error {
resource error {
to-debug-string: func() -> string;
}
}
interface streams {
use error.{error};
resource input-stream {
blocking-read: func(len: u64) -> result<list<u8>, stream-error>;
}
variant stream-error {
last-operation-failed(error),
closed,
}
resource output-stream {
blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>;
}
}
}
package wasi:sockets@0.2.3 {
interface network {
resource network;
type ipv4-address = tuple<u8, u8, u8, u8>;
record ipv4-socket-address {
port: u16,
address: ipv4-address,
}
type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
record ipv6-socket-address {
port: u16,
flow-info: u32,
address: ipv6-address,
scope-id: u32,
}
variant ip-socket-address {
ipv4(ipv4-socket-address),
ipv6(ipv6-socket-address),
}
enum error-code {
unknown,
access-denied,
not-supported,
invalid-argument,
out-of-memory,
timeout,
concurrency-conflict,
not-in-progress,
would-block,
invalid-state,
new-socket-limit,
address-not-bindable,
address-in-use,
remote-unreachable,
connection-refused,
connection-reset,
connection-aborted,
datagram-too-large,
name-unresolvable,
temporary-resolver-failure,
permanent-resolver-failure,
}
enum ip-address-family {
ipv4,
ipv6,
}
variant ip-address {
ipv4(ipv4-address),
ipv6(ipv6-address),
}
}
interface instance-network {
use network.{network};
instance-network: func() -> network;
}
interface tcp {
use network.{network, ip-socket-address, error-code};
use wasi:io/streams@0.2.3.{input-stream, output-stream};
use wasi:io/poll@0.2.3.{pollable};
resource tcp-socket {
start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>;
finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>;
subscribe: func() -> pollable;
}
}
interface tcp-create-socket {
use network.{ip-address-family};
use tcp.{tcp-socket};
use network.{error-code};
create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
}
interface ip-name-lookup {
use network.{ip-address, error-code};
use wasi:io/poll@0.2.3.{pollable};
use network.{network};
resource resolve-address-stream {
resolve-next-address: func() -> result<option<ip-address>, error-code>;
subscribe: func() -> pollable;
}
resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
}
}