Crate kinode_process_lib

kinode process standard library for Rust compiled to WASM Must be used in context of bindings generated by kinode.wit.

This library provides a set of functions for interacting with the kinode kernel interface, which is a WIT file. The types generated by this file are available in processes via the wit_bindgen macro, if a process needs to use them directly. However, the most convenient way to do most things will be via this library.

We define wrappers over the wit bindings to make them easier to use. This library encourages the use of IPC body and metadata types serialized and deserialized to JSON, which is not optimal for performance, but useful for applications that want to maximize composability and introspectability. For blobs, we recommend bincode to serialize and deserialize to bytes.

Re-exports

• pub use process_id::ProcessId;
• pub use address::Address;
• pub use capability::Capability;
• pub use crate::kinode::process::standard::*;

Modules

• http
  Interact with the HTTP server and client modules. Contains types from the http crate to use as well.
• kernel_types
  The types that the kernel itself uses – warning – these will be incompatible with WIT types in some cases, leading to annoying errors. Use only to interact with the kernel or runtime in certain ways.
• kinode
• kv
  Interact with the key_value module
• sqlite
  Interact with the sqlite module
• timer
  Interact with the timer runtime module.
• vfs
  Interact with the virtual filesystem

Macros

• call_init
  Implement the wit-bindgen specific code that the kernel uses to hook into a process. Write an init(our: Address) function and call it with this.
• println
  Override the println! macro to print to the terminal. Uses the print_to_terminal function from the WIT interface on maximally-verbose mode, i.e., this print will always show up in the terminal. To control the verbosity, use the print_to_terminal function directly.

Structs

• PackageId
  PackageId is like a ProcessId, but for a package. Only contains the name of the package and the name of the publisher.
• Request
  Request builder. Use Request::new() to start a request, then build it, then call Request::send() on it to fire.
• Response
  Response builder. Use Response::new() to start a response, then build it, then call Response::send() on it to fire.
• SendError

Enums

• AddressParseError
  Error type for parsing an Address from a string.
• Message
  The basic message type. A message is either a request or a response. Best practice when handling a message is to do this:
• OnExit
• ProcessIdParseError
• SendErrorKind

Functions

• await_message
  Await the next message sent to this process. The runtime will handle the queueing of incoming messages, and calling this function will provide the next one. Interwoven with incoming messages are errors from the network. If your process attempts to send a message to another node, that message may bounce back with a SendError. Those should be handled here.
• can_message
  See if we have the capability to message a certain process. Note if you have not saved the capability, you will not be able to message the other process.
• get_capability
  Get a capability in our store NOTE unfortunatly this is O(n), not sure if wit let’s us do any better
• get_typed_blob
  Fetch the blob of the most recent message we’ve received. Returns None if that message had no blob. If it does have one, attempt to deserialize it from bytes with the provided function.
• get_typed_state
  Fetch the persisted state blob associated with this process. This blob is saved using the set_state function. Returns None if this process has no saved state. If it does, attempt to deserialize it from bytes with the provided function.
• make_blob
  Create a blob with no MIME type and a generic type, plus a serializer function that turns that type into bytes.
• spawn
  Simple wrapper over spawn() in WIT to make use of our good types