flmodules 0.10.0

Modules used in fledger
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

use flarch::{
    broker::{Broker, SubsystemHandler, Translate},
    nodeids::{NodeID, U256},
    platform_async_trait,
};

use crate::{
    nodeconfig::{NodeConfig, NodeInfo},
    router::{
        broker::BrokerRouter,
        messages::{RouterIn, RouterOut},
    },
};

pub struct RouterSimul {
    nsh_broker: Broker<NSHubMessageIn, NSHubMessageOut>,
}

impl RouterSimul {
    pub async fn new() -> anyhow::Result<Self> {
        let mut nsh_broker = Broker::new();
        nsh_broker
            .add_handler(Box::new(NSHub { nodes: vec![] }))
            .await?;
        Ok(Self { nsh_broker })
    }

    pub async fn new_node(&mut self) -> anyhow::Result<(NodeConfig, BrokerRouter)> {
        self.new_node_id(None).await
    }

    pub async fn new_node_id(
        &mut self,
        id_opt: Option<NodeID>,
    ) -> anyhow::Result<(NodeConfig, BrokerRouter)> {
        let (id, nc) = if let Some(id) = id_opt {
            (id, NodeConfig::new_id(id))
        } else {
            let nc = NodeConfig::new();
            (nc.info.get_id(), nc)
        };
        let nm_broker = Broker::new();

        self.nsh_broker
            .add_translator_direct(
                nm_broker.clone(),
                Self::nsh_net(id.clone()),
                Self::net_nsh(id),
            )
            .await?;
        self.nsh_broker
            .emit_msg_in(NSHubMessageIn::NewClient(nc.info.clone()))?;

        Ok((nc, nm_broker))
    }

    fn nsh_net(our_id: U256) -> Translate<NSHubMessageOut, RouterOut> {
        Box::new(move |msg| {
            let NSHubMessageOut::ToClient(dst, net_msg) = msg;
            return (dst == our_id).then_some(net_msg);
        })
    }

    fn net_nsh(our_id: U256) -> Translate<RouterIn, NSHubMessageIn> {
        Box::new(move |msg| Some(NSHubMessageIn::FromClient(our_id, msg)))
    }
}

#[derive(Clone, Debug, PartialEq)]
enum NSHubMessageIn {
    FromClient(U256, RouterIn),
    NewClient(NodeInfo),
}

#[derive(Clone, Debug, PartialEq)]
enum NSHubMessageOut {
    ToClient(U256, RouterOut),
}

struct NSHub {
    nodes: Vec<NodeInfo>,
}

impl NSHub {
    fn net_msg(&self, id: U256, msg: RouterIn) -> Vec<NSHubMessageOut> {
        let RouterIn::NetworkWrapperToNetwork(id_dst, msg_node) = msg;
        log::debug!("{id} -> {id_dst}: {:?}", msg_node);
        vec![NSHubMessageOut::ToClient(
            id_dst,
            RouterOut::NetworkWrapperFromNetwork(id, msg_node),
        )]
    }
}

#[platform_async_trait()]
impl SubsystemHandler<NSHubMessageIn, NSHubMessageOut> for NSHub {
    async fn messages(&mut self, msgs: Vec<NSHubMessageIn>) -> Vec<NSHubMessageOut> {
        let mut out = vec![];

        for msg in msgs {
            match msg {
                NSHubMessageIn::FromClient(id, net_msg) => {
                    out.append(&mut self.net_msg(id, net_msg));
                }
                NSHubMessageIn::NewClient(info) => {
                    self.nodes.push(info);
                }
            }
        }

        out
    }
}