use std::sync::mpsc::{self, Receiver, SyncSender};
use std::sync::{Arc, Mutex};
use smallvec::SmallVec;
use symqtt_codec::QoS;
use symqtt_codec::v3::{Publish, SubscribeReturnCode};
use super::error::Error;
const DEFAULT_MAX_INFLIGHT: u16 = u16::MAX;
#[derive(Debug, Clone)]
pub enum AckResult {
Success,
SubAck(Vec<SubscribeReturnCode>),
Error(Error),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Retransmit {
Publish(Publish),
PubRel {
pkid: u16,
},
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum SessionError {
#[error("unknown packet id: {0}")]
UnknownPkid(u16),
#[error("unexpected stage for packet id: {0}")]
WrongStage(u16),
}
enum OutStage {
Allocated,
WaitingPubAck(Publish, SyncSender<AckResult>),
WaitingPubRec(Publish, SyncSender<AckResult>),
WaitingPubComp(SyncSender<AckResult>),
}
struct OutgoingSlab {
slots: Vec<Option<OutStage>>,
count: u16,
max: u16,
next: u16,
}
impl OutgoingSlab {
fn new(max: u16) -> Self {
let slots = (0..max).map(|_| None).collect::<Vec<_>>();
Self {
max,
slots,
count: 0,
next: 0,
}
}
fn alloc(&mut self) -> Option<u16> {
if self.count >= self.max {
return None;
}
let start = self.next;
loop {
let idx = self.next as usize;
self.next = (self.next + 1) % self.max;
if self.slots[idx].is_none() {
self.slots[idx] = Some(OutStage::Allocated);
self.count += 1;
return Some(idx as u16 + 1);
}
if self.next == start {
return None;
}
}
}
fn release(&mut self, pkid: u16) {
let idx = (pkid - 1) as usize;
if idx < self.slots.len() && self.slots[idx].is_some() {
self.slots[idx] = None;
self.count -= 1;
}
}
fn track(&mut self, pkid: u16, publish: Publish, tx: SyncSender<AckResult>) {
let idx = (pkid - 1) as usize;
let stage = match publish.qos {
QoS::AtLeastOnce => OutStage::WaitingPubAck(publish, tx),
QoS::ExactlyOnce => OutStage::WaitingPubRec(publish, tx),
QoS::AtMostOnce => return,
};
self.slots[idx] = Some(stage);
}
fn track_sub(&mut self, pkid: u16, tx: SyncSender<AckResult>) {
let idx = (pkid - 1) as usize;
self.slots[idx] = Some(OutStage::WaitingPubAck(
Publish {
dup: false,
qos: QoS::AtLeastOnce,
retain: false,
topic: String::new(),
pkid: None,
payload: bytes::Bytes::new(),
},
tx,
));
}
fn on_puback(&mut self, pkid: u16) -> Result<(), SessionError> {
let idx = (pkid - 1) as usize;
let Some(stage) = self.slots.get_mut(idx).and_then(Option::take) else {
return Err(SessionError::UnknownPkid(pkid));
};
let OutStage::WaitingPubAck(_, tx) = stage else {
self.slots[idx] = Some(stage);
return Err(SessionError::WrongStage(pkid));
};
let _ = tx.try_send(AckResult::Success);
self.count -= 1;
Ok(())
}
fn on_pubrec(&mut self, pkid: u16) -> Result<(), SessionError> {
let idx = (pkid - 1) as usize;
let Some(stage) = self.slots.get_mut(idx).and_then(Option::take) else {
return Err(SessionError::UnknownPkid(pkid));
};
let OutStage::WaitingPubRec(_, tx) = stage else {
self.slots[idx] = Some(stage);
return Err(SessionError::WrongStage(pkid));
};
self.slots[idx] = Some(OutStage::WaitingPubComp(tx));
Ok(())
}
fn on_pubcomp(&mut self, pkid: u16) -> Result<(), SessionError> {
let idx = (pkid - 1) as usize;
let Some(stage) = self.slots.get_mut(idx).and_then(Option::take) else {
return Err(SessionError::UnknownPkid(pkid));
};
let OutStage::WaitingPubComp(tx) = stage else {
self.slots[idx] = Some(stage);
return Err(SessionError::WrongStage(pkid));
};
let _ = tx.try_send(AckResult::Success);
self.count -= 1;
Ok(())
}
fn on_suback(&mut self, pkid: u16, codes: Vec<SubscribeReturnCode>) {
let idx = (pkid - 1) as usize;
let Some(stage) = self.slots.get_mut(idx).and_then(Option::take) else {
return;
};
let OutStage::WaitingPubAck(_, tx) = stage else {
self.slots[idx] = Some(stage);
return;
};
let _ = tx.try_send(AckResult::SubAck(codes));
self.count -= 1;
}
fn on_unsuback(&mut self, pkid: u16) {
let idx = (pkid - 1) as usize;
let Some(stage) = self.slots.get_mut(idx).and_then(Option::take) else {
return;
};
let OutStage::WaitingPubAck(_, tx) = stage else {
self.slots[idx] = Some(stage);
return;
};
let _ = tx.try_send(AckResult::Success);
self.count -= 1;
}
fn wake_all(&mut self, error: Error) {
for slot in &mut self.slots {
let Some(stage) = slot.take() else {
continue;
};
match stage {
OutStage::Allocated => {}
OutStage::WaitingPubAck(_, tx) | OutStage::WaitingPubRec(_, tx) | OutStage::WaitingPubComp(tx) => {
let _ = tx.try_send(AckResult::Error(error.clone()));
}
}
}
self.count = 0;
}
fn pending_retransmit(&self) -> Vec<Retransmit> {
let mut out = Vec::with_capacity(16);
for (idx, slot) in self.slots.iter().enumerate() {
let Some(stage) = slot.as_ref() else {
continue;
};
let pkid = idx as u16 + 1;
match stage {
OutStage::WaitingPubAck(publish, _) | OutStage::WaitingPubRec(publish, _) => {
let mut p = publish.clone();
p.dup = true;
p.pkid = Some(pkid);
out.push(Retransmit::Publish(p));
}
OutStage::WaitingPubComp(_) => {
out.push(Retransmit::PubRel { pkid });
}
OutStage::Allocated => {}
}
}
out
}
fn clear(&mut self) {
for slot in &mut self.slots {
*slot = None;
}
self.count = 0;
self.next = 0;
}
}
struct SessionInner {
outgoing: Mutex<OutgoingSlab>,
incoming: Mutex<SmallVec<[u16; 8]>>,
}
#[derive(Clone)]
pub struct Session {
inner: Arc<SessionInner>,
}
impl Session {
pub fn new() -> Self {
Self {
inner: Arc::new(SessionInner {
outgoing: Mutex::new(OutgoingSlab::new(DEFAULT_MAX_INFLIGHT)),
incoming: Mutex::new(SmallVec::new()),
}),
}
}
pub fn with_max_inflight(max: u16) -> Self {
Self {
inner: Arc::new(SessionInner {
outgoing: Mutex::new(OutgoingSlab::new(max)),
incoming: Mutex::new(SmallVec::new()),
}),
}
}
pub fn on_connect(&self, session_present: bool) -> Vec<Retransmit> {
if session_present {
self.inner.outgoing.lock().unwrap().pending_retransmit()
} else {
self.inner.outgoing.lock().unwrap().clear();
self.inner.incoming.lock().unwrap().clear();
Vec::new()
}
}
pub fn on_connection_lost(&self) {
}
pub fn on_disconnect(&self) {
self.inner.outgoing.lock().unwrap().wake_all(Error::Disconnected);
}
pub fn alloc_pkid(&self) -> Option<u16> {
self.inner.outgoing.lock().unwrap().alloc()
}
pub fn release_pkid(&self, pkid: u16) {
self.inner.outgoing.lock().unwrap().release(pkid);
}
pub fn track_publish(&self, pkid: u16, publish: Publish) -> Receiver<AckResult> {
let (tx, rx) = mpsc::sync_channel(1);
self.inner.outgoing.lock().unwrap().track(pkid, publish, tx);
rx
}
pub fn track_sub(&self, pkid: u16) -> Receiver<AckResult> {
let (tx, rx) = mpsc::sync_channel(1);
self.inner.outgoing.lock().unwrap().track_sub(pkid, tx);
rx
}
pub fn on_puback(&self, pkid: u16) -> Result<(), SessionError> {
self.inner.outgoing.lock().unwrap().on_puback(pkid)
}
pub fn on_pubrec(&self, pkid: u16) -> Result<(), SessionError> {
self.inner.outgoing.lock().unwrap().on_pubrec(pkid)
}
pub fn on_pubcomp(&self, pkid: u16) -> Result<(), SessionError> {
self.inner.outgoing.lock().unwrap().on_pubcomp(pkid)
}
pub fn on_suback(&self, pkid: u16, codes: Vec<SubscribeReturnCode>) {
self.inner.outgoing.lock().unwrap().on_suback(pkid, codes);
}
pub fn on_unsuback(&self, pkid: u16) {
self.inner.outgoing.lock().unwrap().on_unsuback(pkid);
}
pub fn track_incoming(&self, pkid: u16) -> bool {
let mut incoming = self.inner.incoming.lock().unwrap();
if incoming.contains(&pkid) {
true
} else {
incoming.push(pkid);
false
}
}
pub fn release_incoming(&self, pkid: u16) -> Result<(), SessionError> {
let mut incoming = self.inner.incoming.lock().unwrap();
if let Some(pos) = incoming.iter().position(|&id| id == pkid) {
incoming.swap_remove(pos);
Ok(())
} else {
Err(SessionError::UnknownPkid(pkid))
}
}
}
impl Default for Session {
fn default() -> Self {
Self::new()
}
}
impl From<Retransmit> for symqtt_codec::v3::Packet {
fn from(retransmit: Retransmit) -> Self {
match retransmit {
Retransmit::Publish(p) => symqtt_codec::v3::Packet::Publish(p),
Retransmit::PubRel { pkid } => symqtt_codec::v3::Packet::PubRel(symqtt_codec::v3::PubRel { pkid }),
}
}
}