collab-server 0.0.7

Nomad's collab server
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

use common::{ClientMessage, PeerId, SessionResponse};
use tokio::sync::mpsc;

/// TODO: docs
#[derive(Debug, Clone)]
pub(crate) enum PeerMessage {
    /// TODO: docs
    GetClientState {
        requested_by: PeerId,
        sender: mpsc::Sender<SessionResponse>,
    },

    /// TODO: docs
    PeerJoined(PeerId),

    /// TODO: docs
    PeerLeft(PeerId),

    /// TODO: docs
    Relay(ClientMessage),

    /// TODO: docs
    #[allow(dead_code)]
    RelayMany(Vec<ClientMessage>),
}

impl PeerMessage {
    #[inline]
    pub fn get_client_state(
        requested_by: PeerId,
        sender: mpsc::Sender<SessionResponse>,
    ) -> Self {
        Self::GetClientState { requested_by, sender }
    }

    #[inline]
    pub fn peer_left(peer_by: PeerId) -> Self {
        Self::PeerLeft(peer_by)
    }

    #[inline]
    pub fn peer_joined(peer_by: PeerId) -> Self {
        Self::PeerJoined(peer_by)
    }

    #[inline]
    pub fn relay(client_msg: ClientMessage) -> Self {
        Self::Relay(client_msg)
    }

    #[inline]
    #[allow(dead_code)]
    pub fn relay_many(client_msgs: Vec<ClientMessage>) -> Self {
        assert!(!client_msgs.is_empty());

        debug_assert!({
            let sent_by = client_msgs[0].sent_by();
            client_msgs.iter().all(|msg| msg.sent_by() == sent_by)
        });

        Self::RelayMany(client_msgs)
    }

    #[inline]
    pub fn sent_by(&self) -> PeerId {
        match self {
            Self::GetClientState { requested_by, .. } => *requested_by,
            Self::PeerJoined(peer_by) => *peer_by,
            Self::PeerLeft(peer_by) => *peer_by,
            Self::Relay(client_msg) => client_msg.sent_by(),
            Self::RelayMany(client_msgs) => client_msgs[0].sent_by(),
        }
    }
}