dactor 0.3.3

An abstract framework for distributed actors in 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
112
113
114
115
116
117
118
119
120

//! Bounded mailbox with overflow strategies.
//!
//! Run with: cargo run --example bounded_mailbox --features test-support

use std::time::Duration;

use async_trait::async_trait;
use dactor::actor::{Actor, ActorContext, ActorRef, Handler};
use dactor::mailbox::{MailboxConfig, OverflowStrategy};
use dactor::message::Message;
use dactor::{SpawnOptions, TestRuntime};

// ---------------------------------------------------------------------------
// A deliberately slow actor that sleeps inside its handler
// ---------------------------------------------------------------------------

struct SlowActor;

impl Actor for SlowActor {
    type Args = ();
    type Deps = ();
    fn create(_: (), _: ()) -> Self {
        SlowActor
    }
}

struct SlowMsg(u32);
impl Message for SlowMsg {
    type Reply = ();
}

#[async_trait]
impl Handler<SlowMsg> for SlowActor {
    async fn handle(&mut self, msg: SlowMsg, _ctx: &mut ActorContext) {
        println!("  [SlowActor] processing message #{}", msg.0);
        // Simulate slow processing so the mailbox fills up.
        tokio::time::sleep(Duration::from_secs(5)).await;
    }
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

#[tokio::main]
async fn main() {
    println!("=== Bounded Mailbox Example ===\n");

    let runtime = TestRuntime::new();

    // --- RejectWithError strategy ---
    println!("--- Bounded(5) + RejectWithError ---");
    let reject_actor = runtime.spawn_with_options::<SlowActor>(
        "reject-actor",
        (),
        SpawnOptions {
            mailbox: MailboxConfig::Bounded {
                capacity: 5,
                overflow: OverflowStrategy::RejectWithError,
            },
            ..Default::default()
        },
    ).await.unwrap();

    // The first message starts processing (occupies the actor task).
    reject_actor.tell(SlowMsg(0)).unwrap();
    // Give the actor a moment to pick up message #0 from the channel.
    tokio::time::sleep(Duration::from_millis(20)).await;

    // Fill the bounded channel (capacity = 5).
    for i in 1..=5 {
        match reject_actor.tell(SlowMsg(i)) {
            Ok(()) => println!("  message #{} accepted", i),
            Err(e) => println!("  message #{} REJECTED: {}", i, e),
        }
    }

    // The next message should be rejected because the mailbox is full.
    match reject_actor.tell(SlowMsg(99)) {
        Ok(()) => println!("  message #99 accepted (unexpected!)"),
        Err(e) => println!("  message #99 REJECTED: {}", e),
    }

    println!();

    // --- DropNewest strategy ---
    println!("--- Bounded(5) + DropNewest ---");
    let drop_actor = runtime.spawn_with_options::<SlowActor>(
        "drop-actor",
        (),
        SpawnOptions {
            mailbox: MailboxConfig::Bounded {
                capacity: 5,
                overflow: OverflowStrategy::DropNewest,
            },
            ..Default::default()
        },
    ).await.unwrap();

    // First message starts processing.
    drop_actor.tell(SlowMsg(0)).unwrap();
    tokio::time::sleep(Duration::from_millis(20)).await;

    // Fill the mailbox.
    for i in 1..=5 {
        match drop_actor.tell(SlowMsg(i)) {
            Ok(()) => println!("  message #{} accepted", i),
            Err(e) => println!("  message #{} error: {}", i, e),
        }
    }

    // With DropNewest the send returns Ok(()) even when the mailbox is full,
    // but the message is silently dropped.
    match drop_actor.tell(SlowMsg(99)) {
        Ok(()) => println!("  message #99 accepted (silently dropped — mailbox full)"),
        Err(e) => println!("  message #99 error: {}", e),
    }

    println!("\n=== Done ===");
}