antarc-protocol 0.1.0

Antarc custom procotol
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 core::time::Duration;
use std::time::Instant;

use crate::{errors::*, events::*, packets::*, Protocol};

pub mod service;

pub use service::*;

impl Protocol<Server> {
    pub fn new_server(capacity: usize, reliable_ttl: Duration) -> Self {
        let service = Server::new(capacity);

        Self {
            packet_id_tracker: 0,
            timer: Instant::now(),
            service,
            receiver_pipe: Vec::with_capacity(capacity),
            reliable_ttl,
        }
    }

    /// NOTE(alex): API function that feeds the internal* event pipe.
    pub fn on_received(&mut self, raw_packet: RawPacket<Server>) -> Result<(), ProtocolError> {
        let update_packet_id =
            self.service
                .on_received(raw_packet, self.packet_id_tracker, self.timer.elapsed())?;

        if update_packet_id {
            self.packet_id_tracker += 1;
        }

        Ok(())
    }

    // REGION(alex): Connection Accepted
    pub fn create_connection_accepted(
        &self,
        scheduled: Scheduled<Reliable, ConnectionAccepted>,
    ) -> Packet<ToSend, ConnectionAccepted> {
        self.service
            .create_connection_accepted(scheduled, self.timer.elapsed())
    }

    // TODO(alex) [mid] 2021-08-02: There must be a way to have a generic version of this function.
    // If `Messager` or some other `Packet` trait implements an `Into<SentEvent>` it would work.
    //
    // Check the `client.rs` file that contains a comment with this possible function.
    pub fn sent_connection_accepted(&mut self, packet: Packet<ToSend, ConnectionAccepted>) {
        self.service
            .sent_connection_accepted(packet, self.timer.elapsed(), self.reliable_ttl);
    }

    pub fn retry_reliable_connection_accepted(
        &mut self,
    ) -> Option<Packet<ToSend, ConnectionAccepted>> {
        self.service
            .retry_reliable_connection_accepted(self.timer.elapsed())
    }

    pub fn poll(&mut self) -> std::vec::Drain<ProtocolEvent<ServerEvent>> {
        self.service.reliability_handler.poll(self.timer.elapsed());

        // NOTE(alex): Iterate over connected peers and call `poll` on each to remove dead packets
        // in reassembler.
        let now = self.timer.elapsed();
        for peer in self.service.connected.values_mut() {
            peer.poll(now);
        }

        self.service.api.drain(..)
    }
}