eldegoss 0.1.0

eldegoss net
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

use ractor::{async_trait, Actor, ActorProcessingErr, ActorRef, RpcReplyPort};
use tracing::{info, warn};

pub enum MyFirstActorMessage {
    PrintHelloWorld,
    HowManyHelloWorlds(RpcReplyPort<u16>),
}

pub struct MyFirstActor;

#[async_trait]
impl Actor for MyFirstActor {
    type State = u16;
    type Msg = MyFirstActorMessage;
    type Arguments = ();

    async fn pre_start(
        &self,
        _myself: ActorRef<Self::Msg>,
        _arguments: Self::Arguments,
    ) -> Result<Self::State, ActorProcessingErr> {
        Ok(0)
    }

    async fn handle(
        &self,
        _myself: ActorRef<Self::Msg>,
        message: Self::Msg,
        state: &mut Self::State,
    ) -> Result<(), ActorProcessingErr> {
        match message {
            MyFirstActorMessage::PrintHelloWorld => {
                info!("Hello world!");
                *state += 1;
            }
            MyFirstActorMessage::HowManyHelloWorlds(reply) => {
                if reply.send(*state).is_err() {
                    warn!("Listener dropped their port before we could reply");
                }
            }
        }
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    common_x::log::init_log_filter("debug");

    let (actor, actor_handle) = Actor::spawn(Some("actor".to_string()), MyFirstActor, ())
        .await
        .expect("Actor failed to start");

    for _i in 0..10 {
        // Sends a message, with no reply
        actor
            .cast(MyFirstActorMessage::PrintHelloWorld)
            .expect("Failed to send message to actor");
    }

    let hello_world_count =
        ractor::call_t!(actor, MyFirstActorMessage::HowManyHelloWorlds, 100).expect("RPC failed");

    info!("Actor replied with {} hello worlds!", hello_world_count);

    // Cleanup
    actor.stop(None);
    actor_handle.await.unwrap();
}