coerce 0.8.11

Async actor runtime and distributed systems framework
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

pub mod util;

#[macro_use]
extern crate serde;

#[macro_use]
extern crate async_trait;

#[macro_use]
extern crate coerce_macros;

use coerce::actor::system::ActorSystem;
use coerce::actor::{ActorCreationErr, ActorFactory, ActorRecipe};

use coerce::remote::system::RemoteActorSystem;
use util::*;

#[derive(Serialize, Deserialize)]
struct TestActorRecipe;

#[derive(Clone)]
struct TestActorFactory;

impl ActorRecipe for TestActorRecipe {
    fn read_from_bytes(bytes: &Vec<u8>) -> Option<Self> {
        serde_json::from_slice(bytes).unwrap()
    }

    fn write_to_bytes(&self) -> Option<Vec<u8>> {
        serde_json::to_vec(&self).ok()
    }
}

#[async_trait]
impl ActorFactory for TestActorFactory {
    type Actor = TestActor;
    type Recipe = TestActorRecipe;

    async fn create(&self, _recipe: Self::Recipe) -> Result<Self::Actor, ActorCreationErr> {
        Ok(TestActor {
            status: None,
            counter: 0,
        })
    }
}

#[coerce_test]
pub async fn test_remote_get_actor() {
    util::create_trace_logger();

    let system = ActorSystem::new();
    let remote = RemoteActorSystem::builder()
        .with_actor_system(system)
        .with_handlers(|builder| builder.with_actor::<TestActorFactory>(TestActorFactory {}))
        .build()
        .await;

    let created_actor = remote
        .actor_system()
        .new_tracked_actor(TestActor::new())
        .await
        .unwrap();

    let actor_id = created_actor.actor_id().clone();
    let actor = remote.actor_ref::<TestActor>(actor_id).await;
    assert_eq!(actor.is_some(), true);
}

//
// #[coerce_test]
// pub async fn test_remote_cluster_client_create_actor() {
//     let mut system = ActorSystem::new();
//     let _actor = system.new_tracked_actor(TestActor::new()).await.unwrap();
//     let remote = RemoteActorSystem::builder()
//         .with_actor_system(system)
//         .with_handlers(|builder| {
//             builder.with_actor::<TestActorFactory>("TestActor", TestActorFactory {})
//         })
//         .build()
//         .await;
//
//     let mut client = remote.cluster_client().build();
//
//     let actor = client
//         .create_actor::<TestActorFactory>(TestActorRecipe {}, Some(format!("TestActor")))
//         .await;
//
//     assert_eq!(actor.is_some(), false);
// }