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

use async_channel::Sender;
use std::collections::HashMap;
use std::net::SocketAddr;
use tdn_types::group::{Group, GroupId};
use tdn_types::message::{GroupSendMessage, SendMessage};
use tdn_types::primitive::PeerAddr;

#[derive(Default, Debug)]
pub struct PermissionlessGroup {
    id: GroupId,
    peers: HashMap<PeerAddr, SocketAddr>,
}

impl Group for PermissionlessGroup {
    type JoinType = ();
    type JoinResultType = ();

    fn id(&self) -> &GroupId {
        &self.id
    }
}

impl PermissionlessGroup {
    pub fn new() {}

    /// directly add a peer to group.
    pub fn add(&mut self, peer_id: PeerAddr, addr: SocketAddr) {
        self.peers
            .entry(peer_id)
            .and_modify(|a| *a = addr)
            .or_insert(addr);
    }

    pub fn join_bytes(&self) -> Vec<u8> {
        vec![]
    }

    /// join: when peer join will call
    pub async fn join(
        &mut self,
        peer_addr: PeerAddr,
        addr: SocketAddr,
        _join_bytes: Vec<u8>,
        return_sender: Sender<SendMessage>,
    ) {
        let is_ok = !self.peers.contains_key(&peer_addr);

        return_sender
            .send(SendMessage::Group(GroupSendMessage::PeerJoinResult(
                peer_addr,
                is_ok,
                false,
                vec![],
            )))
            .await
            .expect("Permissionless group to TDN channel closed");

        if is_ok {
            self.peers.insert(peer_addr, addr);
        }
    }

    pub fn join_result(&mut self, peer_addr: PeerAddr, is_ok: bool, _join_result: Vec<u8>) {
        if !is_ok {
            self.peers.remove(&peer_addr);
        }
    }

    /// leave: when peer leave will call
    pub fn leave(&mut self, peer_addr: &PeerAddr) {
        self.peers.remove(&peer_addr);
    }
}