Struct Supervisor 

pub struct Supervisor;

Actor supervisor

Supervisor gives the actor the ability to restart after failure. When the actor fails, recreate a new actor instance and replace it.

Implementations

impl Supervisor

pub async fn start<A, F>(f: F) -> Result<Addr<A>>

where A: Actor, F: Fn() -> A + Send + 'static,

Start a supervisor

Examples

use xactor::*;
use std::time::Duration;

#[message]
struct Die;

#[message]
struct Add;

#[message(result = "i32")]
struct Get;

struct MyActor(i32);

impl Actor for MyActor {}

#[async_trait::async_trait]
impl Handler<Add> for MyActor {
    async fn handle(&mut self, ctx: &mut Context<Self>, _: Add) {
        self.0 += 1;
    }
}

#[async_trait::async_trait]
impl Handler<Get> for MyActor {
    async fn handle(&mut self, ctx: &mut Context<Self>, _: Get) -> i32 {
        self.0
    }
}

#[async_trait::async_trait]
impl Handler<Die> for MyActor {
    async fn handle(&mut self, ctx: &mut Context<Self>, _: Die) {
        ctx.stop(None);
    }
}

#[xactor::main]
async fn main() -> Result<()> {
    let mut addr = Supervisor::start(|| MyActor(0)).await?;

    addr.send(Add)?;
    assert_eq!(addr.call(Get).await?, 1);

    addr.send(Add)?;
    assert_eq!(addr.call(Get).await?, 2);

    addr.send(Die)?;
    sleep(Duration::from_secs(1)).await; // Wait for actor restart

    assert_eq!(addr.call(Get).await?, 0);
    Ok(())
}

Examples found in repository

examples/supervisor_clear_send_later.rs (line 44)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let service_supervisor = xactor::Supervisor::start(PingLater::default).await?;
    let service_addr = service_supervisor.clone();

    let supervisor_task = xactor::spawn(async {
        service_supervisor.wait_for_stop().await;
    });

    let send_ping = async {
        println!("  main  :: sending Ping");
        service_addr.send(Ping("before halt")).unwrap();
    };

    let send_halt = async {
        xactor::sleep(Duration::from_millis(1_000)).await;
        println!("  main  :: sending Halt");
        service_addr.send(Halt).unwrap();
    };

    let _ = futures::join!(supervisor_task, send_halt, send_ping);

    Ok(())
}

examples/supervisor_clear_interval.rs (line 69)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let service_supervisor = xactor::Supervisor::start(PingTimer::default).await?;
    let service_addr = service_supervisor.clone();

    let supervisor_task = xactor::spawn(async {
        service_supervisor.wait_for_stop().await;
    });

    let send_halt = async {
        xactor::sleep(Duration::from_millis(5_200)).await;
        println!("  main  :: sending Halt");
        service_addr.send(Halt).unwrap();
    };

    let _ = futures::join!(supervisor_task, send_halt);
    // run this to see that the interval is not properly stopped if the ctx is stopped
    // futures::join!(supervisor_task, send_panic); // there is no panic recovery

    Ok(())
}