componentized/directory

componentized:services-filesystem-credential-admin

component

Imports

Exports

WIT

package root:component;

world root {
  import componentized:services/types;
  import wasi:config/store@0.2.0-draft;
  import wasi:io/error@0.2.3;
  import wasi:io/poll@0.2.3;
  import wasi:io/streams@0.2.3;
  import wasi:clocks/wall-clock@0.2.3;
  import wasi:filesystem/types@0.2.3;
  import wasi:filesystem/preopens@0.2.3;
  import wasi:cli/environment@0.2.3;
  import wasi:cli/exit@0.2.3;
  import wasi:cli/stdin@0.2.3;
  import wasi:cli/stdout@0.2.3;
  import wasi:cli/stderr@0.2.3;
  import wasi:sockets/udp@0.2.3;
  import wasi:sockets/tcp@0.2.3;
  import wasi:random/random@0.2.3;

  export componentized:services/credential-admin;
}
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 error {
    resource error;
  }
  interface poll {
    resource pollable;
  }
  interface streams {
    use error.{error};

    resource input-stream;

    resource output-stream {
      check-write: func() -> result<u64, stream-error>;
      write: func(contents: list<u8>) -> result<_, stream-error>;
      blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>;
      blocking-flush: func() -> result<_, stream-error>;
    }

    variant stream-error {
      last-operation-failed(error),
      closed,
    }
  }
}


package wasi:clocks@0.2.3 {
  interface wall-clock {
    record datetime {
      seconds: u64,
      nanoseconds: u32,
    }
  }
}


package wasi:filesystem@0.2.3 {
  interface types {
    use wasi:io/streams@0.2.3.{output-stream};
    use wasi:clocks/wall-clock@0.2.3.{datetime};
    use wasi:io/streams@0.2.3.{error};

    resource descriptor {
      write-via-stream: func(offset: filesize) -> result<output-stream, error-code>;
      append-via-stream: func() -> result<output-stream, error-code>;
      get-type: func() -> result<descriptor-type, error-code>;
      create-directory-at: func(path: string) -> result<_, error-code>;
      stat: func() -> result<descriptor-stat, error-code>;
      stat-at: func(path-flags: path-flags, path: string) -> result<descriptor-stat, error-code>;
      open-at: func(path-flags: path-flags, path: string, open-flags: open-flags, %flags: descriptor-flags) -> result<descriptor, error-code>;
      unlink-file-at: func(path: string) -> result<_, error-code>;
      metadata-hash-at: func(path-flags: path-flags, path: string) -> result<metadata-hash-value, error-code>;
    }

    type filesize = u64;

    enum error-code {
      access,
      would-block,
      already,
      bad-descriptor,
      busy,
      deadlock,
      quota,
      exist,
      file-too-large,
      illegal-byte-sequence,
      in-progress,
      interrupted,
      invalid,
      io,
      is-directory,
      loop,
      too-many-links,
      message-size,
      name-too-long,
      no-device,
      no-entry,
      no-lock,
      insufficient-memory,
      insufficient-space,
      not-directory,
      not-empty,
      not-recoverable,
      unsupported,
      no-tty,
      no-such-device,
      overflow,
      not-permitted,
      pipe,
      read-only,
      invalid-seek,
      text-file-busy,
      cross-device,
    }

    enum descriptor-type {
      unknown,
      block-device,
      character-device,
      directory,
      fifo,
      symbolic-link,
      regular-file,
      socket,
    }

    type link-count = u64;

    record descriptor-stat {
      %type: descriptor-type,
      link-count: link-count,
      size: filesize,
      data-access-timestamp: option<datetime>,
      data-modification-timestamp: option<datetime>,
      status-change-timestamp: option<datetime>,
    }

    flags path-flags {
      symlink-follow,
    }

    flags open-flags {
      create,
      directory,
      exclusive,
      truncate,
    }

    flags descriptor-flags {
      read,
      write,
      file-integrity-sync,
      data-integrity-sync,
      requested-write-sync,
      mutate-directory,
    }

    record metadata-hash-value {
      lower: u64,
      upper: u64,
    }

    resource directory-entry-stream;

    filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
  }
  interface preopens {
    use types.{descriptor};

    get-directories: func() -> list<tuple<descriptor, string>>;
  }
}


package wasi:cli@0.2.3 {
  interface environment {
    get-environment: func() -> list<tuple<string, string>>;
  }
  interface exit {
    exit: func(status: result);
  }
  interface stdin {
    use wasi:io/streams@0.2.3.{input-stream};

    get-stdin: func() -> input-stream;
  }
  interface stdout {
    use wasi:io/streams@0.2.3.{output-stream};

    get-stdout: func() -> output-stream;
  }
  interface stderr {
    use wasi:io/streams@0.2.3.{output-stream};

    get-stderr: func() -> output-stream;
  }
}


package wasi:sockets@0.2.3 {
  interface udp {
    resource udp-socket;

    resource incoming-datagram-stream;

    resource outgoing-datagram-stream;
  }
  interface tcp {
    resource tcp-socket;
  }
}


package wasi:random@0.2.3 {
  interface random {
    get-random-bytes: func(len: u64) -> list<u8>;
  }
}