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
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

use std::collections::{HashMap, HashSet};

use common::{InitError, PeerId, SessionId};

use crate::*;

/// TODO: docs
#[derive(Default)]
#[cfg_attr(any(test, feature = "__tests"), derive(Clone))]
pub(crate) struct Sessions {
    active: HashMap<SessionId, Session>,
}

impl Sessions {
    /// TODO: docs
    #[cfg(any(test, feature = "__tests"))]
    pub(crate) fn active(&self) -> &HashMap<SessionId, Session> {
        &self.active
    }

    /// TODO: docs
    #[inline]
    pub fn join(
        &mut self,
        session_id: SessionId,
        peer_id: PeerId,
    ) -> Result<PeerSender, InitError> {
        let Some(session) = self.active.get_mut(&session_id) else {
            return Err(InitError::SessionDoesNotExist(session_id));
        };

        session.add_peer(peer_id)?;

        Ok(session.sender.fork(peer_id))
    }

    /// TODO: docs
    #[inline]
    pub fn new() -> Self {
        Self::default()
    }

    /// Removes the peer from the given session.
    ///
    /// If the peer was the last in the session, the session itself is also
    /// removed.
    #[inline]
    pub fn remove_peer(&mut self, session_id: SessionId, peer_id: PeerId) {
        let Some(session) = self.active.get_mut(&session_id) else {
            // TODO: log the error.
            return;
        };

        session.peers.remove(&peer_id);

        if session.peers.is_empty() {
            self.active.remove(&session_id);
        }
    }

    /// TODO: docs
    #[inline]
    pub fn start(
        &mut self,
        peer_id: PeerId,
    ) -> (SessionId, PeerSender, PeerReceiver) {
        let id = SessionId::new_random();
        let (sender, receiver) = broadcast::channel(16);
        let sender = PeerSender::new(sender, peer_id);
        let receiver = PeerReceiver::new(receiver, peer_id);
        let session = Session::new(peer_id, sender.clone());
        self.active.insert(id, session);
        (id, sender, receiver)
    }
}

/// TODO: docs
#[cfg_attr(any(test, feature = "__tests"), derive(Clone))]
pub(crate) struct Session {
    sender: PeerSender,
    peers: HashSet<PeerId>,
}

impl Session {
    #[inline]
    fn add_peer(&mut self, peer: PeerId) -> Result<(), InitError> {
        if self.peers.contains(&peer) {
            return Err(InitError::PeerAlreadyPresent(peer));
        }

        self.peers.insert(peer);

        Ok(())
    }

    #[inline]
    fn new(first_peer: PeerId, sender: PeerSender) -> Self {
        let mut peers = HashSet::new();
        peers.insert(first_peer);
        Self { sender, peers }
    }

    /// TODO: docs
    #[cfg(any(test, feature = "__tests"))]
    pub(crate) fn peers(&self) -> &HashSet<PeerId> {
        &self.peers
    }
}