Crate zestors

A fast and flexible actor-framework for building fault-tolerant Rust applications.

Documentation

All items are self-documented, but for a new user it is recommended to go skim through the docs in the following order. Every module gives an overview of what is contained inside, introduces some new concepts and then gives an example on how to use it.

• messaging - Defining a protocol in order to send messages.
• actor_reference - Interacting with an actor through it’s child or address.
• actor_type - Specifying the type of an actor statically and dynamically.
• spawning - Spawning of actors.
• handler - A simpler way to write your actors.
• runtime - Runtime configuration.
• supervision - (Not yet implemented)
• distribution - (Not yet implemented)

Minimal example

#[macro_use]
extern crate zestors;
use zestors::{messaging::RecvError, prelude::*};

// Let's define a single request ..
#[derive(Message, Envelope, Debug)]
#[request(u32)]
struct MyRequest {
    param: String,
}

// .. and create a protocol that accepts this request.
#[protocol]
enum MyProtocol {
    MyRequest(MyRequest),
    String(String),
}

#[tokio::main]
async fn main() {
    // Now we can spawn a simple actor ..
    let (child, address) = spawn(|mut inbox: Inbox<MyProtocol>| async move {
        loop {
            match inbox.recv().await {
                Ok(msg) => match msg {
                    MyProtocol::MyRequest((request, tx)) => {
                        println!("Received request: {:?}", request.param);
                        tx.send(100).unwrap();
                    }
                    MyProtocol::String(string) => {
                        println!("Received message: {:?}", string);
                    }
                },
                Err(e) => match e {
                    RecvError::Halted => break "Halted",
                    RecvError::ClosedAndEmpty => break "Closed",
                },
            }
        }
    });

    // .. and send it some messages!
    address.send("Hi".to_string()).await.unwrap();

    let response = address
        .request(MyRequest {
            param: "Hi".to_string(),
        })
        .await
        .unwrap();
    assert_eq!(response, 100);

    let response = address
        .my_request("Hi".to_string())
        .request()
        .await
        .unwrap();
    assert_eq!(response, 100);

    child.halt();
    assert_eq!(child.await.unwrap(), "Halted");
}

Modules

actor_reference

Overview

actor_type

Overview

distribution

TODO

export

handler

Overview

messaging

Overview

prelude

runtime

Overview

spawning

Spawn functions

supervision

TODO

Macros

DynActor

Macro for writing a DynActor<dyn _>:

action

A macro for creating Actions.

Attribute Macros

protocol

Modifies the enum to implement protocol:

Derive Macros

Envelope

Generates a trait that can be used to send Envelopes of this message.

Handler

Implements HandleExit for your Handler.

Message

Derive the Message trait.