msrt 0.1.8

Portable MSRT protocol implementation.
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

//! Scheduler polling helpers.

use crate::core::{Error, Result};
use crate::engine::state::{ack::AckState, numbers::NumberState, recovery::RecoveryState};
use crate::engine::{EngineConfig, EnginePoll};

use super::event::{EngineOutput, WriteEvent, WritePriority};

pub(super) fn poll_pending_ack<'a>(
    config: &EngineConfig,
    ack: &mut AckState,
    _numbers: &mut NumberState,
    tx_buf: &'a mut [u8],
) -> Result<EnginePoll<'a>> {
    let Some(key) = ack.pop() else {
        return Ok(EnginePoll::Idle);
    };

    let written =
        crate::engine::codec::outgoing::encode_ack_packet(key, tx_buf, &config.integrity)?;

    Ok(EnginePoll::Transmit {
        bytes: &tx_buf[..written],
        attempts: 0,
    })
}

pub(crate) fn poll_event<'a>(
    event: EngineOutput,
    recovery: &mut RecoveryState,
    now_ms: u64,
    tx_buf: &'a mut [u8],
) -> Result<EnginePoll<'a>> {
    match event {
        EngineOutput::Write(write) => poll_write(write, recovery, now_ms, tx_buf),
        EngineOutput::SendFailed(failed) => Ok(EnginePoll::SendFailed(failed)),
    }
}

fn poll_write<'a>(
    write: WriteEvent,
    recovery: &mut RecoveryState,
    now_ms: u64,
    tx_buf: &'a mut [u8],
) -> Result<EnginePoll<'a>> {
    if tx_buf.len() < write.len {
        return Err(Error::buffer_too_small());
    }

    match write.priority {
        WritePriority::Retransmit => {
            recovery.note_retransmit_sent(write.key, now_ms);
        }
        WritePriority::Control | WritePriority::NewData => {
            recovery.note_sent(write.key, now_ms);
        }
    }

    tx_buf[..write.len].copy_from_slice(write.as_bytes());

    Ok(EnginePoll::Transmit {
        bytes: &tx_buf[..write.len],
        attempts: write.attempts,
    })
}