elfo-network 0.2.0-alpha.21

Distributed actors for elfo
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

use fxhash::FxHashMap;
use parking_lot::Mutex;

use elfo_core::{
    addr::{GroupNo, NodeLaunchId, NodeNo},
    topology::Topology,
};

use crate::protocol::{internode::GroupInfo, GroupMeta};

// TODO: move to discovery?

pub(crate) struct NodeMap {
    pub(crate) nodes: Mutex<FxHashMap<NodeNo, NodeInfo>>,
    pub(crate) this: NodeInfo,
}

impl NodeMap {
    #[cfg(test)]
    pub(crate) fn empty(node_no: NodeNo, launch_id: NodeLaunchId) -> Self {
        Self {
            nodes: Mutex::new(Default::default()),
            this: NodeInfo::empty(node_no, launch_id),
        }
    }

    pub(crate) fn new(topology: &Topology) -> Self {
        let this = NodeInfo {
            node_no: topology.node_no(),
            launch_id: topology.launch_id(),
            groups: topology
                .locals()
                .map(|group| {
                    let interests = topology
                        .connections()
                        .filter_map(|conn| {
                            (conn.from == group.addr)
                                .then(|| conn.to.into_remote())
                                .flatten()
                        })
                        .collect();

                    GroupInfo {
                        group_no: group.addr.group_no().expect("invalid group no"),
                        name: group.name,
                        interests,
                    }
                })
                .collect(),
        };

        Self {
            nodes: Default::default(),
            this,
        }
    }

    pub(crate) fn local_group_meta(&self, group_no: GroupNo) -> Option<GroupMeta> {
        make_group_meta(&self.this, group_no)
    }

    pub(crate) fn remote_group_meta(
        &self,
        node_no: NodeNo,
        group_no: GroupNo,
    ) -> Option<GroupMeta> {
        make_group_meta(self.nodes.lock().get(&node_no)?, group_no)
    }
}

#[derive(Clone)]
pub(crate) struct NodeInfo {
    pub(crate) node_no: NodeNo,
    pub(crate) launch_id: NodeLaunchId,
    pub(crate) groups: Vec<GroupInfo>,
}

#[cfg(test)]
impl NodeInfo {
    pub(crate) fn empty(node_no: NodeNo, launch_id: NodeLaunchId) -> Self {
        Self {
            node_no,
            launch_id,
            groups: vec![],
        }
    }
}

fn make_group_meta(node: &NodeInfo, group_no: GroupNo) -> Option<GroupMeta> {
    node.groups
        .iter()
        .find(|g| g.group_no == group_no)
        .map(|g| g.name.clone())
        .map(|group_name| GroupMeta {
            node_no: node.node_no,
            group_no,
            group_name,
        })
}