actix 0.13.5

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
126
127
128
129
130
131
132
133

#![cfg(feature = "macros")]

use std::collections::HashSet;

use actix::prelude::*;

struct SessionActor {
    sessions: HashSet<usize>,
}

impl SessionActor {
    fn new() -> Self {
        Self {
            sessions: HashSet::new(),
        }
    }

    fn session_count(&self) -> usize {
        self.sessions.len()
    }

    fn sessions(&self) -> Vec<usize> {
        self.sessions.iter().cloned().collect()
    }

    fn add_session(&mut self, id: usize) -> Result<usize, String> {
        match self.sessions.insert(id) {
            false => Err(String::from("Duplicate session ID")),
            true => Ok(id),
        }
    }
}

impl Actor for SessionActor {
    type Context = Context<Self>;
}

#[derive(Message)]
#[rtype(result = "Result<usize, String>")]
struct AddSession(usize);

impl Handler<AddSession> for SessionActor {
    type Result = Result<usize, String>;

    fn handle(&mut self, id: AddSession, _: &mut Context<Self>) -> Self::Result {
        self.add_session(id.0)
    }
}

#[derive(Message)]
#[rtype(usize)]
struct GetSessionCount;

impl Handler<GetSessionCount> for SessionActor {
    type Result = usize;

    fn handle(&mut self, _: GetSessionCount, _: &mut Context<Self>) -> Self::Result {
        self.session_count()
    }
}

#[derive(Message)]
#[rtype(result = "Vec<usize>")]
struct GetConnectedSessions;

impl Handler<GetConnectedSessions> for SessionActor {
    type Result = Vec<usize>;

    fn handle(&mut self, _: GetConnectedSessions, _: &mut Context<Self>) -> Self::Result {
        self.sessions()
    }
}

#[derive(Message)]
#[rtype(result = "Option<usize>")]
struct GetSessionById(usize);

impl Handler<GetSessionById> for SessionActor {
    type Result = Option<usize>;

    fn handle(&mut self, id: GetSessionById, _: &mut Context<Self>) -> Self::Result {
        self.sessions.get(&id.0).cloned()
    }
}

#[actix::test]
async fn test_different_message_result_types() {
    let actor = SessionActor::new().start();

    let count = actor.send(GetSessionCount).await.unwrap();

    assert!(
        count == 0,
        "Invalid message response as the ActorSession's sessions should be empty by default"
    );

    actor
        .send(AddSession(1))
        .await
        .unwrap()
        .expect("Duplicate session ID");

    actor
        .send(AddSession(2))
        .await
        .unwrap()
        .expect("Duplicate session ID");

    let count = actor.send(GetSessionCount).await.unwrap();
    assert!(count == 2, "2 sessions should have been added");

    let sessions: Vec<usize> = actor.send(GetConnectedSessions).await.unwrap();
    assert!(
        sessions.len() == 2,
        "2 sessions should have been added AND returned from the `GetConnectedSessions` message"
    );

    let id = actor.send(GetSessionById(1)).await.unwrap();
    assert!(id.is_some(), "Session with id `1` should have been added");

    let invalid_id = actor.send(GetSessionById(50)).await.unwrap();
    assert!(
        invalid_id.is_none(),
        "No session with id `50` should be present"
    );

    let duplicate_session = actor.send(AddSession(1)).await.unwrap();

    assert!(
        duplicate_session.is_err(),
        "Session with id `1` should already have been inserted"
    );
}