rsactor 0.14.1

A Simple and Efficient In-Process Actor Model Implementation for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// Copyright 2022 Jeff Kim <hiking90@gmail.com>
// SPDX-License-Identifier: Apache-2.0

//! Example demonstrating the different termination scenarios with tracing.

use anyhow::Result;
use rsactor::{message_handlers, Actor, ActorRef, ActorWeak};
use tracing::info;

// Simple actor for demonstration
#[derive(Debug)]
struct DemoActor {
    name: String,
}

impl Actor for DemoActor {
    type Args = String;
    type Error = anyhow::Error;

    async fn on_start(
        args: Self::Args,
        actor_ref: &ActorRef<Self>,
    ) -> std::result::Result<Self, Self::Error> {
        info!(
            "DemoActor '{}' (id: {}) started!",
            args,
            actor_ref.identity()
        );
        Ok(DemoActor { name: args })
    }

    async fn on_stop(
        &mut self,
        actor_ref: &ActorWeak<Self>,
        killed: bool,
    ) -> std::result::Result<(), Self::Error> {
        let status = if killed { "killed" } else { "stopped" };
        info!(
            "DemoActor '{}' (id: {}) {} gracefully",
            self.name,
            actor_ref.identity(),
            status
        );
        Ok(())
    }
}

// Message types
#[derive(Debug)]
struct Ping;

// Message implementations
#[message_handlers]
impl DemoActor {
    #[handler]
    async fn handle_ping(&mut self, _msg: Ping, _: &ActorRef<Self>) -> String {
        format!("{} pong!", self.name)
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .with_target(false)
        .init();

    println!("=== Kill Termination Demo ===\n");

    // Spawn an actor
    let (actor_ref, join_handle) = rsactor::spawn::<DemoActor>("KillTestActor".to_string());

    // Send a message first
    let response: String = actor_ref.ask(Ping).await?;
    println!("Response: {response}");

    println!("Calling kill() on the actor...");

    // Kill the actor (this should trigger the kill scenario)
    actor_ref.kill()?;

    // Wait for the actor to complete
    println!("Waiting for actor to terminate...");
    let result = join_handle.await?;

    match result {
        rsactor::ActorResult::Completed { actor, killed } => {
            println!("Actor '{}' completed. Killed: {}", actor.name, killed);
        }
        rsactor::ActorResult::Failed {
            actor,
            error,
            phase,
            killed,
        } => {
            println!(
                "Actor failed: {}. Phase: {:?}, Killed: {}, Final name: {}",
                error,
                phase,
                killed,
                actor
                    .as_ref()
                    .map(|a| &a.name)
                    .unwrap_or(&"Unknown".to_string())
            );
        }
    }

    println!("\n=== Demo Complete ===");
    Ok(())
}