use heapless::Vec;
use crate::config::MAX_UDP_PAYLOAD;
use crate::exchange::{EXCHANGE_IDLE_TIMEOUT, ExchangeKey};
use crate::im::ReadCursor;
use crate::msg::SessionId;
use crate::platform::Instant;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct PendingSubscribe {
pub(crate) id: u32,
pub(crate) max_interval_s: u16,
pub(crate) more_chunks: bool,
}
#[derive(Debug)]
pub(crate) struct Interaction {
pub(crate) read_cursor: ReadCursor,
pub(crate) pending_read: Vec<u8, MAX_UDP_PAYLOAD>,
pub(crate) pending_subscribe: Option<PendingSubscribe>,
}
impl Interaction {
const fn new() -> Self {
Self {
read_cursor: ReadCursor::START,
pending_read: Vec::new(),
pending_subscribe: None,
}
}
pub(crate) fn idle(&self) -> bool {
self.pending_read.is_empty() && self.pending_subscribe.is_none()
}
}
#[derive(Debug)]
pub(crate) struct Interactions<const I: usize> {
entries: Vec<(ExchangeKey, Instant, Interaction), I>,
}
impl<const I: usize> Interactions<I> {
pub(crate) const fn new() -> Self {
const {
assert!(I > 0, "an interaction table must hold at least one series");
}
Self {
entries: Vec::new(),
}
}
pub(crate) fn get(&mut self, key: ExchangeKey, now: Instant) -> Option<&mut Interaction> {
self.entries.retain(|(k, seen, _)| {
*k == key || now.saturating_duration_since(*seen) <= EXCHANGE_IDLE_TIMEOUT
});
if !self.entries.iter().any(|(k, _, _)| *k == key) {
if self.entries.is_full() {
self.entries.remove(0);
}
self.entries.push((key, now, Interaction::new())).ok()?;
}
let entry = self.entries.iter_mut().find(|(k, _, _)| *k == key)?;
entry.1 = now;
Some(&mut entry.2)
}
pub(crate) fn find(&self, key: ExchangeKey) -> Option<&Interaction> {
self.entries
.iter()
.find(|(k, _, _)| *k == key)
.map(|(_, _, i)| i)
}
pub(crate) fn idle(&self, key: ExchangeKey) -> bool {
self.find(key).is_none_or(Interaction::idle)
}
pub(crate) fn priming(&self, subscription: u32) -> bool {
self.entries.iter().any(|(_, _, state)| {
state
.pending_subscribe
.is_some_and(|p| p.id == subscription)
})
}
pub(crate) fn forget(&mut self, key: ExchangeKey) {
self.entries.retain(|(k, _, _)| *k != key);
}
pub(crate) fn forget_session(&mut self, session: SessionId) {
self.entries.retain(|(k, _, _)| k.session != session);
}
#[cfg(test)]
pub(crate) fn len(&self) -> usize {
self.entries.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::exchange::Role;
use crate::msg::ExchangeId;
use crate::platform::Duration;
fn key(id: u16) -> ExchangeKey {
ExchangeKey {
session: SessionId(1),
id: ExchangeId(id),
role: Role::Responder,
}
}
#[test]
fn a_full_table_drops_the_oldest_series() {
let mut table = Interactions::<2>::new();
let now = Instant::ZERO;
table
.get(key(1), now)
.unwrap()
.pending_read
.push(1)
.unwrap();
table
.get(key(2), now)
.unwrap()
.pending_read
.push(2)
.unwrap();
table
.get(key(3), now)
.unwrap()
.pending_read
.push(3)
.unwrap();
assert!(
table.idle(key(1)),
"the oldest series was dropped, not resumed"
);
assert_eq!(table.find(key(2)).unwrap().pending_read[..], [2]);
assert_eq!(table.find(key(3)).unwrap().pending_read[..], [3]);
assert_eq!(table.len(), 2);
}
#[test]
fn an_expired_series_is_not_continued_on_a_reused_exchange_id() {
let mut table = Interactions::<4>::new();
table
.get(key(7), Instant::ZERO)
.unwrap()
.pending_read
.push(0xAA)
.unwrap();
let later = Instant::ZERO
.saturating_add(EXCHANGE_IDLE_TIMEOUT)
.saturating_add(Duration::from_secs(1));
table.get(key(8), later);
assert!(table.find(key(7)).is_none());
assert!(table.get(key(7), later).unwrap().idle());
}
#[test]
fn priming_is_asked_per_subscription() {
let mut table = Interactions::<4>::new();
table.get(key(1), Instant::ZERO).unwrap().pending_subscribe = Some(PendingSubscribe {
id: 9,
max_interval_s: 60,
more_chunks: true,
});
assert!(table.priming(9));
assert!(!table.priming(10));
table.forget_session(SessionId(1));
assert!(!table.priming(9));
}
}