Crate wasmrs_guest
source ·Expand description
wasmrs-guest
This crate provides the WebAssembly-side logic for wasmRS modules using the wasmRS RSocket protocol.
Usage
This is a basic implementation of a WebAssembly module that exports three operations:
greeting::sayHello(input: string) -> string
- returns a greeting, e.g. `Hello World!’echo::chars(input: string) -> stream string
- returns a stream ofstring
representing each character in the input stringecho::reverse(input: stream string) -> stream string
- reverses eachstring
from the input stream and outputs it on a stream.
use guest::*;
use wasmrs_guest as guest;
#[no_mangle]
extern "C" fn __wasmrs_init(guest_buffer_size: u32, host_buffer_size: u32, max_host_frame_len: u32) {
guest::init(guest_buffer_size, host_buffer_size, max_host_frame_len);
guest::register_request_response("greeting", "sayHello", request_response);
guest::register_request_stream("echo", "chars", request_stream);
guest::register_request_channel("echo", "reverse", request_channel);
}
fn request_response(input: Mono<ParsedPayload, PayloadError>) -> Result<Mono<Payload, PayloadError>, GenericError> {
Ok(async move {
let input = deserialize::<String>(&input.await.unwrap().data).unwrap();
let output = format!("Hello, {}!", input);
Ok(Payload::new_data(None, Some(serialize(&output).unwrap().into())))
}.boxed())
}
fn request_stream(
input: Mono<ParsedPayload, PayloadError>,
) -> Result<FluxReceiver<Payload, PayloadError>, GenericError> {
let channel = FluxChannel::<Payload, PayloadError>::new();
let rx = channel.take_rx().unwrap();
spawn(async move {
let input = deserialize::<String>(&input.await.unwrap().data).unwrap();
for char in input.chars() {
channel
.send(Payload::new_data(None, Some(serialize(&char).unwrap().into())))
.unwrap();
}
});
Ok(rx)
}
fn request_channel(
mut input: FluxReceiver<ParsedPayload, PayloadError>,
) -> Result<FluxReceiver<Payload, PayloadError>, GenericError> {
let channel = FluxChannel::<Payload, PayloadError>::new();
let rx = channel.take_rx().unwrap();
spawn(async move {
while let Some(payload) = input.next().await {
if let Err(e) = payload {
println!("{}", e);
continue;
}
let payload = payload.unwrap();
let input = deserialize::<String>(&payload.data).unwrap();
let output: String = input.chars().rev().collect();
if let Err(e) = channel.send(Payload::new_data(None, Some(serialize(&output).unwrap().into()))) {
println!("{}", e);
}
}
});
Ok(rx)
}
Apex Code generators
NanoBus iota code generators use the wasmRS protocol. You can build wasmRS
modules from those templates using the https://github.com/apexlang/apex
CLI.
Run the following command to get started:
$ apex new git@github.com:nanobus/iota.git -p templates/rust [your-project]
From there, edit the apex.axdl
interface definition to match your needs and run apex build
to generate the wasmRS module.
More Information
WasmRS makes heavy use of generated code from apex
specs and generators to automate all of the boilerplate. See the getting-started for usage.
For more information on wasmRS, see the core wasmrs crate.
Contributing
See CONTRIBUTING.md
License
See the root LICENSE.txt
Re-exports
pub use error::Error;
pub use wasmrs_runtime as runtime;
Modules
- The wasmRS-guest error module.
- An unbounded set of streams
Structs
- A cheaply cloneable and sliceable chunk of contiguous memory.
- An implementation of the
Flux
as seen in RSocket and reactive streams. It is similar to a [Stream<Item = Result<Item, Err>>] or an unbounded channel. - A FluxPipe is the result of piping one [Flux] into another.
- The receving end-only of a crate::Flux
- The Host inside a WebAssembly module that implements RSocket
- Metadata associated with the frame.
- An implementation of Mono as seen in RSocket and reactive streams. It is similar to a [Future<Output = Result<Item, Err>>] that can be pushed to after instantiation.
- A list of imports/exports for a wasmRS module.
- The error type used for all [wasmrs_rx::Mono]/[wasmrs_rx::Flux] payloads.
- A complete [Payload] object that includes metadata and data bytes.
Enums
- An enum that can hold any time of wasmrs frame.
- The types of RSocket operations supported by wasmRS.
- The Signal is the wrapper payload that wasmrx types pass around.
- Represents any valid JSON value.
Traits
- A generic trait to wrap over Flux, Mono, and supporting types.
- An extension trait for
Future
s that provides a variety of convenient adapters. - The wasmrs-rx implementation of an Rx Observable trait
- The wasmrs-rx implementation of an Rx Observer trait
- A trait for an RSocket client/server (host/guest).
- A stream of values produced asynchronously.
- An extension trait for
Stream
s that provides a variety of convenient combinator functions. - Adapters specific to
Result
-returning streams
Functions
- Add an imported wasmRS method for the module.
- The standard function for de-serializing codec structs from a format suitable. for message exchange between actor and host. Use of any other function to. deserialize could result in breaking incompatibilities.
- Deserialize a generic Value from CBOR bytes.
- This is called as part of the module initialization for wasmRS.
- Turn on logging for the guest (WASI only).
- Register a fire & forget handler under the specified namespace and operation.
- Register a request/channel handler under the specified namespace and operation.
- Register a request/response handler under the specified namespace and operation.
- Register a request/stream handler under the specified namespace and operation.
- Convert a list of streams into a
Stream
of results from the streams. - The standard function for serializing codec structs into a format that can be. used for message exchange between actor and host. Use of any other function to. serialize could result in breaking incompatibilities.
- Set the MAX_N value for the guest.
Type Aliases
- A utility type for a boxed stream.
- A utility type for a boxed future.
- A pinned, boxed [Flux].
- An alias to [Box<dyn std::error::Error + Send + Sync + ’static>]
- An alias for [Mono<ParsedPayload, PayloadError>]
- An alias for [FluxReceiver<ParsedPayload, PayloadError>]
- An alias for [Mono<Payload, PayloadError>]
- An alias for [FluxReceiver<Payload, PayloadError>]