ractor 0.15.12

A actor framework 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
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::{Actor, ActorProcessingErr, ActorRef, RpcReplyPort};

#[derive(Debug)]
enum TestMessage {
    Add(i32, i32, RpcReplyPort<i32>),
    Echo(String, RpcReplyPort<String>),
    #[allow(dead_code)]
    CastOnly(i32),
}

#[cfg(feature = "cluster")]
impl crate::Message for TestMessage {}

struct TestActor;

#[cfg_attr(feature = "async-trait", crate::async_trait)]
impl Actor for TestActor {
    type Msg = TestMessage;
    type Arguments = ();
    type State = ();

    async fn pre_start(
        &self,
        _this_actor: ActorRef<Self::Msg>,
        _: (),
    ) -> Result<Self::State, ActorProcessingErr> {
        Ok(())
    }

    async fn handle(
        &self,
        _: ActorRef<Self::Msg>,
        message: Self::Msg,
        _: &mut Self::State,
    ) -> Result<(), ActorProcessingErr> {
        match message {
            TestMessage::Add(a, b, reply) => {
                let _ = reply.send(a + b);
            }
            TestMessage::Echo(s, reply) => {
                let _ = reply.send(s);
            }
            TestMessage::CastOnly(_) => {}
        }
        Ok(())
    }
}

async fn spawn_test_actor() -> (
    ActorRef<TestMessage>,
    impl std::future::Future<Output = Result<(), Box<dyn std::error::Error + Send + Sync>>>,
) {
    let (actor, handle) = Actor::spawn(None, TestActor, ())
        .await
        .expect("Actor spawn failed");
    let wrapped_handle = async move {
        let result = handle.await;

        #[cfg(not(feature = "async-std"))]
        {
            result.map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)
        }

        #[cfg(feature = "async-std")]
        {
            result.map_err(|()| {
                Box::new(std::io::Error::new(
                    std::io::ErrorKind::Other,
                    "async task error",
                )) as Box<dyn std::error::Error + Send + Sync>
            })
        }
    };
    (actor, wrapped_handle)
}

#[crate::concurrency::test]
async fn test_call_macro() {
    let (actor, handle) = spawn_test_actor().await;

    let result = call!(actor, TestMessage::Add, 2, 3);
    assert!(result.is_ok(), "call! macro failed: {:?}", result.err());
    assert_eq!(result.unwrap(), 5);

    actor.stop(None);
    assert!(handle.await.is_ok(), "Actor handle join failed");
}

#[crate::concurrency::test]
async fn test_call_macro_echo() {
    let (actor, handle) = spawn_test_actor().await;

    let msg = "hello".to_string();
    let result = call!(actor, TestMessage::Echo, msg.clone());
    assert!(result.is_ok(), "call! macro failed: {:?}", result.err());
    assert_eq!(result.unwrap(), msg);

    actor.stop(None);
    assert!(handle.await.is_ok(), "Actor handle join failed");
}

#[crate::concurrency::test]
async fn test_call_t_macro_success() {
    let (actor, handle) = spawn_test_actor().await;

    let result = call_t!(actor, TestMessage::Add, 100, 4, 6);
    assert!(result.is_ok(), "call_t! macro failed: {:?}", result.err());
    assert_eq!(result.unwrap(), 10);

    actor.stop(None);
    assert!(handle.await.is_ok(), "Actor handle join failed");
}

#[crate::concurrency::test]
async fn test_cast_macro() {
    let (actor, handle) = spawn_test_actor().await;

    let res = cast!(actor, TestMessage::CastOnly(42));
    assert!(res.is_ok(), "cast! macro failed: {:?}", res.err());

    actor.stop(None);
    assert!(handle.await.is_ok(), "Actor handle join failed");
}

// TODO: forward! macro is not tested here due to its complexity and need for two actors.