actix_async_handler 0.1.0

Support for async syntax for Actix
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

use std::time::Duration;

use actix::{Actor, Addr, Context, Handler, Message};
use actix::clock::sleep;

use actix_async_handler::async_handler;

#[derive(Message)]
#[rtype(result = "u64")]
struct Ping(u64);

struct Ponger {}

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

#[async_handler]
impl Handler<Ping> for Ponger {
    type Result = u64;

    async fn handle(&mut self, msg: Ping, _ctx: &mut Self::Context) -> Self::Result {
        println!("[Ponger] sleeping for {} secs", msg.0);
        sleep(Duration::from_secs(msg.0)).await;
        println!("[Ponger] woke up.");
        msg.0
    }
}

struct Pinger {
    ponger: Addr<Ponger>
}

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

#[async_handler]
impl Handler<Ping> for Pinger {

    type Result = u64;

    async fn handle(&mut self, msg: Ping, ctx: &mut Self::Context) -> Self::Result {
        let result = self.ponger.send(msg).await;
        result.unwrap() + 1
    }

}

#[actix_rt::main]
async fn main() {

    let ponger = Ponger {}.start();
    let pinger = Pinger { ponger }.start();

    println!("Result {}", pinger.send(Ping(2)).await.unwrap());
}