use std::sync::mpsc::{self, Receiver, SyncSender};
use std::sync::{Arc, Mutex};
use bytes::Bytes;
use smallvec::SmallVec;
use symqtt_codec::QoS;
use symqtt_codec::v5::{
ConnAck, PubAckProperties, PubCompProperties, Publish, ReasonCode, SubAckProperties, UnsubAckProperties,
};
use super::error::Error;
#[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),
}
#[derive(Debug, Clone)]
pub enum AckResult {
Success,
Ack(ReasonCode, PubAckProperties),
SubAck(Vec<ReasonCode>, SubAckProperties),
UnsubAck(Vec<ReasonCode>, UnsubAckProperties),
Error(Error),
}
#[derive(Debug, Clone)]
pub enum Retransmit {
Publish(Box<Publish>),
PubRel {
pkid: u16,
},
}
#[derive(Debug, Clone)]
pub struct ServerProperties {
pub receive_maximum: u16,
pub maximum_packet_size: u32,
pub topic_alias_maximum: u16,
pub maximum_qos: QoS,
pub retain_available: bool,
pub wildcard_sub_available: bool,
pub sub_id_available: bool,
pub shared_sub_available: bool,
pub server_keep_alive: Option<u16>,
pub session_expiry_interval: Option<u32>,
pub assigned_client_id: Option<String>,
pub response_information: Option<String>,
pub server_reference: Option<String>,
}
impl Default for ServerProperties {
fn default() -> Self {
Self {
receive_maximum: 65535,
maximum_packet_size: 0,
topic_alias_maximum: 0,
maximum_qos: QoS::ExactlyOnce,
retain_available: true,
wildcard_sub_available: true,
sub_id_available: true,
shared_sub_available: true,
server_keep_alive: None,
session_expiry_interval: None,
assigned_client_id: None,
response_information: None,
server_reference: None,
}
}
}
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,
next: 0,
count: 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,
properties: Default::default(),
payload: Bytes::new(),
},
tx,
));
}
fn on_puback(&mut self, pkid: u16, reason_code: ReasonCode, props: PubAckProperties) -> 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::Ack(reason_code, props));
self.count -= 1;
Ok(())
}
fn on_pubrec(&mut self, pkid: u16, reason_code: ReasonCode) -> Result<bool, 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));
};
if reason_code.is_error() {
let _ = tx.try_send(AckResult::Ack(reason_code, PubAckProperties::default()));
self.count -= 1;
return Ok(false); }
self.slots[idx] = Some(OutStage::WaitingPubComp(tx));
Ok(true) }
fn on_pubcomp(&mut self, pkid: u16, reason_code: ReasonCode, props: PubCompProperties) -> 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 ack = AckResult::Ack(
reason_code,
PubAckProperties {
reason_string: props.reason_string,
user_properties: props.user_properties,
},
);
let _ = tx.try_send(ack);
self.count -= 1;
Ok(())
}
fn on_suback(&mut self, pkid: u16, codes: Vec<ReasonCode>, props: SubAckProperties) {
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, props));
self.count -= 1;
}
fn on_unsuback(&mut self, pkid: u16, codes: Vec<ReasonCode>, props: UnsubAckProperties) {
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::UnsubAck(codes, props));
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(Box::new(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;
}
fn set_max(&mut self, new_max: u16) {
if new_max == self.max {
return;
}
if new_max < self.max {
self.max = new_max;
} else {
self.slots.resize_with(new_max as usize, || None);
self.max = new_max;
}
}
}
struct SessionInner {
outgoing: Mutex<OutgoingSlab>,
incoming: Mutex<SmallVec<[u16; 8]>>,
server_props: Mutex<ServerProperties>,
}
#[derive(Clone)]
pub struct Session {
inner: Arc<SessionInner>,
}
impl Default for Session {
fn default() -> Self {
Self::new()
}
}
impl Session {
pub fn new() -> Self {
Self {
inner: Arc::new(SessionInner {
outgoing: Mutex::new(OutgoingSlab::new(65535)),
incoming: Mutex::new(SmallVec::new()),
server_props: Mutex::new(ServerProperties::default()),
}),
}
}
pub fn with_max_inflight(max: u16) -> Self {
Self {
inner: Arc::new(SessionInner {
outgoing: Mutex::new(OutgoingSlab::new(max)),
incoming: Mutex::new(SmallVec::new()),
server_props: Mutex::new(ServerProperties::default()),
}),
}
}
pub fn on_connack(&self, connack: &ConnAck) -> Vec<Retransmit> {
let props = &connack.properties;
let mut server = self.inner.server_props.lock().unwrap();
server.receive_maximum = props.receive_maximum.unwrap_or(65535);
server.maximum_packet_size = props.maximum_packet_size.unwrap_or(0);
server.topic_alias_maximum = props.topic_alias_maximum.unwrap_or(0);
server.retain_available = props.retain_available.unwrap_or(1) != 0;
server.wildcard_sub_available = props.wildcard_subscription_available.unwrap_or(1) != 0;
server.sub_id_available = props.subscription_identifier_available.unwrap_or(1) != 0;
server.shared_sub_available = props.shared_subscription_available.unwrap_or(1) != 0;
server.server_keep_alive = props.server_keep_alive;
server.session_expiry_interval = props.session_expiry_interval;
server.assigned_client_id = props.assigned_client_identifier.clone();
server.response_information = props.response_information.clone();
server.server_reference = props.server_reference.clone();
server.maximum_qos = match props.maximum_qos {
Some(0) => QoS::AtMostOnce,
Some(1) => QoS::AtLeastOnce,
_ => QoS::ExactlyOnce,
};
let receive_max = server.receive_maximum;
drop(server);
self.inner.outgoing.lock().unwrap().set_max(receive_max);
if connack.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 server_properties(&self) -> ServerProperties {
self.inner.server_props.lock().unwrap().clone()
}
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, reason_code: ReasonCode, props: PubAckProperties) -> Result<(), SessionError> {
self.inner.outgoing.lock().unwrap().on_puback(pkid, reason_code, props)
}
pub fn on_pubrec(&self, pkid: u16, reason_code: ReasonCode) -> Result<bool, SessionError> {
self.inner.outgoing.lock().unwrap().on_pubrec(pkid, reason_code)
}
pub fn on_pubcomp(&self, pkid: u16, reason_code: ReasonCode, props: PubCompProperties) -> Result<(), SessionError> {
self.inner.outgoing.lock().unwrap().on_pubcomp(pkid, reason_code, props)
}
pub fn on_suback(&self, pkid: u16, codes: Vec<ReasonCode>, props: SubAckProperties) {
self.inner.outgoing.lock().unwrap().on_suback(pkid, codes, props);
}
pub fn on_unsuback(&self, pkid: u16, codes: Vec<ReasonCode>, props: UnsubAckProperties) {
self.inner.outgoing.lock().unwrap().on_unsuback(pkid, codes, props);
}
pub fn track_incoming(&self, pkid: u16) -> bool {
let mut incoming = self.inner.incoming.lock().unwrap();
if incoming.contains(&pkid) {
return true;
}
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))
}
}
pub fn on_connection_lost(&self) {}
pub fn on_disconnect(&self) {
self.inner.outgoing.lock().unwrap().wake_all(Error::Disconnected);
}
pub fn receive_maximum(&self) -> u16 {
self.inner.server_props.lock().unwrap().receive_maximum
}
}