use alloc::collections::BTreeMap;
use alloc::vec::Vec;
use crate::types::Timestamp;
use super::{Outgoing, Session};
#[derive(Debug, Default)]
pub struct SessionSet<K, S> {
sessions: BTreeMap<K, S>,
}
impl<K: Ord, S: Session> SessionSet<K, S> {
#[must_use]
pub fn new() -> Self {
Self {
sessions: BTreeMap::new(),
}
}
pub fn insert(&mut self, key: K, session: S) -> Option<S> {
self.sessions.insert(key, session)
}
pub fn remove(&mut self, key: &K) -> Option<S> {
self.sessions.remove(key)
}
pub fn get(&self, key: &K) -> Option<&S> {
self.sessions.get(key)
}
pub fn get_mut(&mut self, key: &K) -> Option<&mut S> {
self.sessions.get_mut(key)
}
#[must_use]
pub fn len(&self) -> usize {
self.sessions.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.sessions.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = (&K, &S)> {
self.sessions.iter()
}
pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut S)> {
self.sessions.iter_mut()
}
pub fn open_all(&mut self, now: Timestamp) {
for session in self.sessions.values_mut() {
session.open(now);
}
}
#[must_use]
pub fn poll_timeout(&self) -> Option<Timestamp> {
self.sessions
.values()
.filter_map(Session::poll_timeout)
.min()
}
#[must_use]
pub fn next_deadline(&self) -> Option<(&K, Timestamp)> {
self.sessions
.iter()
.filter_map(|(key, session)| session.poll_timeout().map(|at| (key, at)))
.min_by_key(|(_, at)| *at)
}
pub fn handle_timeout(&mut self, now: Timestamp) {
for session in self.sessions.values_mut() {
if session.poll_timeout().is_some_and(|at| at <= now) {
session.handle_timeout(now);
}
}
}
pub fn drain_transmit(&mut self) -> Vec<(K, Outgoing)>
where
K: Clone,
{
let mut out = Vec::new();
for (key, session) in &mut self.sessions {
while let Some(frame) = session.poll_transmit() {
out.push((key.clone(), frame));
}
}
out
}
pub fn drain_events(&mut self) -> Vec<(K, S::Event)>
where
K: Clone,
{
let mut out = Vec::new();
for (key, session) in &mut self.sessions {
while let Some(event) = session.poll_event() {
out.push((key.clone(), event));
}
}
out
}
pub fn retain_open(&mut self) -> usize {
let before = self.sessions.len();
self.sessions
.retain(|_, session| !session.state().is_closed());
before - self.sessions.len()
}
pub fn close_all(&mut self) {
for session in self.sessions.values_mut() {
session.close();
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::session::{CemConfig, CemSession, RmConfig, RmSession};
use alloc::string::{String, ToString};
use alloc::vec;
fn t(secs: i64) -> Timestamp {
Timestamp::from_unix(1_700_000_000 + secs, 0)
}
fn fleet() -> SessionSet<String, CemSession> {
let mut set = SessionSet::new();
set.insert("a".to_string(), CemSession::new(CemConfig::default()));
set.insert("b".to_string(), CemSession::new(CemConfig::default()));
set
}
#[test]
fn a_drain_can_be_acted_on_while_the_set_is_still_there() {
let mut set = fleet();
set.open_all(t(0));
let frames = set.drain_transmit();
assert_eq!(frames.len(), 2, "one handshake each");
for (key, frame) in frames {
assert!(frame.text.contains("Handshake"));
set.get_mut(&key).expect("still there").close();
}
assert_eq!(set.retain_open(), 2);
}
#[test]
fn a_fleet_has_one_deadline_not_a_thousand() {
let mut set = fleet();
set.open_all(t(0));
let soonest = set.poll_timeout().expect("both are waiting on something");
let (_, same) = set.next_deadline().expect("and one of them owns it");
assert_eq!(soonest, same);
assert!(soonest > t(0));
}
#[test]
fn every_due_deadline_fires_in_one_sweep() {
let mut set = fleet();
set.open_all(t(0));
let _ = set.drain_transmit();
let deadline = set.poll_timeout().expect("a deadline");
set.handle_timeout(deadline);
let events = set.drain_events();
let mut keys: Vec<&str> = events.iter().map(|(k, _)| k.as_str()).collect();
keys.sort_unstable();
keys.dedup();
assert_eq!(keys.len(), 2, "both sessions should have timed out");
}
#[test]
fn transmissions_are_tagged_with_whose_they_are() {
let mut set = fleet();
set.open_all(t(0));
let frames = set.drain_transmit();
assert!(!frames.is_empty());
for (key, out) in &frames {
assert!(key.as_str() == "a" || key.as_str() == "b");
assert!(out.text.contains("message_type"));
}
assert!(set.drain_transmit().is_empty());
}
#[test]
fn closed_sessions_are_pruned_rather_than_accumulated() {
let mut set = fleet();
set.open_all(t(0));
assert_eq!(set.retain_open(), 0);
set.get_mut(&"a".to_string()).expect("session a").close();
let _ = set.drain_transmit();
assert_eq!(set.retain_open(), 1);
assert_eq!(set.len(), 1);
assert!(set.get(&"a".to_string()).is_none());
}
fn details() -> crate::types::common::ResourceManagerDetails {
use crate::types::common::{
Commodity, CommodityQuantity, ControlType, ResourceManagerDetails, Role, RoleType,
};
use crate::types::{Duration, Id};
ResourceManagerDetails::builder()
.message_id(Id::new_const("rmd-1"))
.resource_id(Id::new_const("battery-1"))
.roles(vec![Role::new(
RoleType::EnergyStorage,
Commodity::Electricity,
)])
.instruction_processing_delay(Duration::from_millis(500))
.available_control_types(vec![ControlType::FillRateBasedControl])
.provides_forecast(false)
.provides_power_measurement_types(vec![CommodityQuantity::ElectricPower3PhaseSymmetric])
.build()
}
#[test]
fn the_set_works_for_resource_managers_too() {
let mut set: SessionSet<u32, RmSession> = SessionSet::new();
set.insert(1, RmSession::new(RmConfig::default(), details()));
set.insert(2, RmSession::new(RmConfig::default(), details()));
set.open_all(t(0));
assert_eq!(set.len(), 2);
assert!(set.poll_timeout().is_some());
assert!(!set.drain_transmit().is_empty());
set.close_all();
let _ = set.drain_transmit();
assert_eq!(set.retain_open(), 2);
assert!(set.is_empty());
}
}