use std::io::{Read, Write};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use bytes::BytesMut;
use symqtt_codec::v3 as codec;
use crate::pinger::Pinger;
use crate::transport::{Transport, WriteTimeout, Writer};
use crate::v3::error::Error;
use crate::v3::session::Session;
use crate::v3::token::Token;
use crate::v3::{ConnectOptions, InboundHandler, PublishMessage, QoS, SubscribeReturnCode};
pub struct Client<H: InboundHandler, T: Transport> {
inner: Arc<ClientInner<H, T::Write>>,
}
struct ClientInner<H, W> {
handler: H,
pinger: Pinger,
session: Session,
alive: AtomicBool,
opts: ConnectOptions,
writer: Mutex<Option<Writer<W>>>,
stop_tx: Mutex<Option<mpsc::SyncSender<()>>>,
read_done_rx: Mutex<Option<mpsc::Receiver<()>>>,
keepalive_done_rx: Mutex<Option<mpsc::Receiver<()>>>,
}
impl<H: InboundHandler, T: Transport> Client<H, T> {
pub fn connect(opts: ConnectOptions, handler: H, session: Session, transport: T) -> Result<Self, Error> {
log::debug!("connecting to broker as client_id={:?}", opts.client_id);
let pinger = Pinger::new(opts.keep_alive, opts.ping_timeout());
let (reader, writer_half) = transport.split();
let (read_down_tx, read_down_rx) = mpsc::sync_channel::<()>(1);
let (connack_tx, connack_rx) = mpsc::sync_channel::<codec::ConnAck>(1);
let inner = Arc::new(ClientInner {
opts,
pinger,
handler,
session,
writer: Mutex::new(Some(Writer {
stream: writer_half,
buf: BytesMut::with_capacity(4096),
})),
alive: AtomicBool::new(false),
stop_tx: Mutex::new(None),
read_done_rx: Mutex::new(Some(read_down_rx)),
keepalive_done_rx: Mutex::new(None),
});
let inner_ = inner.clone();
std::thread::Builder::new()
.name(format!("mqtt-{}-read-loop", inner.opts.client_id))
.spawn(move || {
let _guard = read_down_tx;
inner_.read(reader, connack_tx);
})?;
if let Err(e) = inner.handshake(connack_rx) {
log::warn!("handshake unsuccessful: {e}");
inner.alive.store(false, Ordering::SeqCst);
if let Some(w) = inner.writer.lock().unwrap().take() {
let _ = w.shutdown();
}
return Err(e);
}
if inner.opts.keep_alive.as_secs() > 0 {
let (stop_tx, stop_rx) = mpsc::sync_channel::<()>(1);
let (keepalive_down_tx, keepalive_down_rx) = mpsc::sync_channel::<()>(1);
*inner.stop_tx.lock().unwrap() = Some(stop_tx);
*inner.keepalive_done_rx.lock().unwrap() = Some(keepalive_down_rx);
let inner_ = inner.clone();
std::thread::Builder::new()
.name(format!("mqtt-{}-keepalive-loop", inner_.opts.client_id))
.spawn(move || {
let _guard = keepalive_down_tx;
inner_.keepalive(stop_rx);
})?;
}
log::debug!("connected successfully as client_id={:?}", inner.opts.client_id);
Ok(Self { inner })
}
pub fn is_connected(&self) -> bool {
self.inner.alive.load(Ordering::Relaxed)
}
pub fn disconnect(&self, timeout: Option<Duration>) {
log::debug!("disconnecting gracefully");
let deadline = timeout.map(|t| Instant::now() + t);
self.inner.graceful_close(timeout, true);
wait_thread(self.inner.read_done_rx.lock().unwrap().take(), deadline);
wait_thread(self.inner.keepalive_done_rx.lock().unwrap().take(), deadline);
}
pub fn publish(&self, msg: &PublishMessage<'_>) -> Result<Option<Token<()>>, Error> {
log::debug!(
"publishing to topic={:?} qos={:?} retain={} payload_len={}",
msg.topic,
msg.qos,
msg.retain,
msg.payload.len()
);
let mut publish = codec::Publish::from(msg);
if matches!(msg.qos, QoS::AtMostOnce) {
self.inner.send_packet(&codec::Packet::Publish(publish), msg.timeout)?;
return Ok(None);
}
let pkid = self.inner.session.alloc_pkid().ok_or(Error::WindowFull)?;
publish.pkid = Some(pkid);
let rx = self.inner.session.track_publish(pkid, publish.clone());
if let Err(e) = self.inner.send_packet(&codec::Packet::Publish(publish), msg.timeout) {
log::warn!("failed to send publish for pkid={pkid}: {e}");
self.inner.session.release_pkid(pkid);
return Err(e);
}
log::debug!(
"publish sent, pkid={pkid} topic={:?} qos={:?} payload_len={}",
msg.topic,
msg.qos,
msg.payload.len()
);
Ok(Some(Token::new(rx)))
}
pub fn subscribe(
&self,
topics: &[(&str, QoS)],
timeout: Option<Duration>,
) -> Result<Token<Vec<SubscribeReturnCode>>, Error> {
let pkid = self.inner.session.alloc_pkid().ok_or(Error::WindowFull)?;
let pkt = codec::Packet::Subscribe(codec::Subscribe {
pkid,
filters: topics.iter().copied().map(codec::SubscribeFilter::from).collect(),
});
let rx = self.inner.session.track_sub(pkid);
if let Err(e) = self.inner.send_packet(&pkt, timeout) {
log::warn!("failed to send subscribe for pkid={pkid}: {e}");
self.inner.session.release_pkid(pkid);
return Err(e);
}
log::debug!("subscribe sent, pkid={pkid} filters={topics:?}");
Ok(Token::new(rx))
}
pub fn unsubscribe(&self, topics: &[&str], timeout: Option<Duration>) -> Result<Token<()>, Error> {
let pkid = self.inner.session.alloc_pkid().ok_or(Error::WindowFull)?;
let pkt = codec::Packet::Unsubscribe(codec::Unsubscribe {
pkid,
topics: topics.iter().map(ToString::to_string).collect(),
});
let rx = self.inner.session.track_sub(pkid);
if let Err(e) = self.inner.send_packet(&pkt, timeout) {
log::warn!("failed to send unsubscribe for pkid={pkid}: {e}");
self.inner.session.release_pkid(pkid);
return Err(e);
}
log::debug!("unsubscribe sent, pkid={pkid} topics={topics:?}");
Ok(Token::new(rx))
}
}
impl<H: InboundHandler, T: Transport> Drop for Client<H, T> {
fn drop(&mut self) {
if !self.inner.alive.load(Ordering::Relaxed) {
return;
}
log::debug!("client dropped, sending DISCONNECT");
self.inner.graceful_close(Some(Duration::from_secs(1)), false);
}
}
impl<H: InboundHandler, W: Write + WriteTimeout + Send> ClientInner<H, W> {
fn handshake(&self, connack_rx: mpsc::Receiver<codec::ConnAck>) -> Result<(), Error> {
let deadline = self.opts.connect_timeout.map(|v| Instant::now() + v);
let connect = codec::Connect::from(&self.opts);
self.send_packet(&codec::Packet::Connect(connect), self.opts.connect_timeout)?;
self.alive.store(true, Ordering::SeqCst);
let connack = match deadline {
Some(ddl) => connack_rx
.recv_timeout(ddl.saturating_duration_since(Instant::now()))
.map_err(|_| Error::Timeout)?,
None => connack_rx.recv().map_err(|_| Error::Disconnected)?,
};
if connack.return_code != codec::ConnectReturnCode::Accepted {
return Err(Error::ConnectRefused(connack.return_code));
}
log::debug!("connack received: session_present={}", connack.session_present);
let retransmits = self.session.on_connect(connack.session_present);
log::debug!("retransmitting {} inflight messages", retransmits.len());
for item in retransmits {
let pkt = codec::Packet::from(item);
if let Err(e) = self.send_packet(&pkt, None) {
log::warn!("failed to retransmit packet: {e}");
}
}
Ok(())
}
fn graceful_close(&self, timeout: Option<Duration>, notify: bool) {
let pkt = codec::Packet::Disconnect(codec::Disconnect);
let _ = self.send_packet(&pkt, timeout);
self.terminate(Error::Disconnected, true, notify);
}
fn terminate(&self, error: Error, graceful: bool, notify: bool) {
if !self.alive.swap(false, Ordering::SeqCst) {
return;
}
log::debug!("terminating connection: graceful={graceful} reason={error}");
if let Some(w) = self.writer.lock().unwrap().take() {
let _ = w.shutdown();
}
self.stop_tx.lock().unwrap().take();
if graceful {
self.session.on_disconnect();
} else {
self.session.on_connection_lost();
}
if notify {
self.handler.on_disconnect(&error);
}
}
fn read(&self, mut reader: impl Read, connack_tx: mpsc::SyncSender<codec::ConnAck>) {
let mut tmp = [0u8; 4096];
let mut buf = BytesMut::with_capacity(8192);
loop {
if let Err(e) = self.drain_decoded_packets(&mut buf, &connack_tx) {
self.terminate(e, false, true);
return;
}
let n = match reader.read(&mut tmp) {
Ok(0) => break,
Ok(n) => n,
Err(ref e) => {
if (e.kind() == std::io::ErrorKind::TimedOut || e.kind() == std::io::ErrorKind::WouldBlock)
&& !self.alive.load(Ordering::SeqCst)
{
return;
} else {
break;
}
}
};
buf.extend_from_slice(&tmp[..n]);
}
self.terminate(Error::Disconnected, false, true);
}
fn keepalive(&self, stop_rx: mpsc::Receiver<()>) {
let ping_timeout = self.opts.ping_timeout.or(Some(Duration::from_secs(3)));
loop {
match self.pinger.poll() {
crate::pinger::PingerAction::Sleep(dur) => match stop_rx.recv_timeout(dur) {
Ok(()) | Err(mpsc::RecvTimeoutError::Disconnected) => return,
Err(mpsc::RecvTimeoutError::Timeout) => {}
},
crate::pinger::PingerAction::SendPing => {
if let Err(e) = self.send_packet(&codec::Packet::PingReq(codec::PingReq), ping_timeout) {
log::warn!("failed to send PingReq, terminating connection: {e}");
self.terminate(e, false, true);
return;
}
self.pinger.record_ping_sent();
}
crate::pinger::PingerAction::TimedOut => {
log::warn!("ping response timed out, terminating connection");
self.terminate(Error::PingTimeout, false, true);
return;
}
}
}
}
fn drain_decoded_packets(
&self,
buf: &mut BytesMut,
connack_tx: &mpsc::SyncSender<codec::ConnAck>,
) -> Result<(), Error> {
loop {
match codec::Packet::decode(buf) {
Ok(Some(pkt)) => {
self.pinger.record_received();
if let codec::Packet::ConnAck(connack) = pkt {
let _ = connack_tx.try_send(connack);
continue;
}
self.dispatch_packet(pkt)?;
}
Ok(None) => return Ok(()),
Err(e) => {
log::warn!("packet decode error: {e}");
return Err(Error::Decode(e));
}
}
}
}
fn dispatch_packet(&self, pkt: codec::Packet) -> Result<(), Error> {
match pkt {
codec::Packet::PubAck(codec::PubAck { pkid }) => {
log::debug!("received PubAck pkid={pkid}");
let _ = self.session.on_puback(pkid);
}
codec::Packet::PubRec(codec::PubRec { pkid }) => {
log::debug!("received PubRec pkid={pkid}, sending PubRel");
let _ = self.session.on_pubrec(pkid);
self.send_packet(&codec::Packet::PubRel(codec::PubRel { pkid }), None)?;
}
codec::Packet::PubComp(codec::PubComp { pkid }) => {
log::debug!("received PubComp pkid={pkid}");
let _ = self.session.on_pubcomp(pkid);
}
codec::Packet::Publish(publish) => {
log::debug!(
"received Publish topic={:?} qos={:?} pkid={:?} payload_len={}",
publish.topic,
publish.qos,
publish.pkid,
publish.payload.len()
);
self.handle_inbound_publish(&publish)?;
}
codec::Packet::SubAck(codec::SubAck { pkid, return_codes }) => {
log::debug!("received SubAck pkid={pkid} codes={return_codes:?}");
self.session.on_suback(pkid, return_codes);
}
codec::Packet::UnsubAck(codec::UnsubAck { pkid }) => {
log::debug!("received UnsubAck pkid={pkid}");
self.session.on_unsuback(pkid);
}
codec::Packet::PingResp(_) => {
log::debug!("received PingResp");
self.pinger.record_ping_response();
}
codec::Packet::PubRel(codec::PubRel { pkid }) => {
log::debug!("received PubRel pkid={pkid}, sending PubComp");
let _ = self.session.release_incoming(pkid);
self.send_packet(&codec::Packet::PubComp(codec::PubComp { pkid }), None)?;
}
_ => {}
}
Ok(())
}
fn send_packet(&self, pkt: &codec::Packet, timeout: Option<Duration>) -> Result<(), Error> {
if !self.alive.load(Ordering::Relaxed) && !matches!(pkt, codec::Packet::Connect(_)) {
return Err(Error::Disconnected);
}
{
let mut guard = self.writer.lock().unwrap();
let Writer { stream, buf } = guard.as_mut().ok_or(Error::Disconnected)?;
buf.clear();
pkt.encode(buf)?;
log::trace!("sending {} ({} bytes)", packet_name(pkt), buf.len());
stream.set_write_timeout(timeout)?;
stream.write_all(buf)?;
stream.flush()?;
}
self.pinger.record_sent();
Ok(())
}
fn handle_inbound_publish(&self, publish: &codec::Publish) -> Result<(), Error> {
match publish.qos {
QoS::AtMostOnce => {
self.handler.on_publish(publish);
}
QoS::AtLeastOnce => {
self.handler.on_publish(publish);
if let Some(pkid) = publish.pkid {
log::debug!("sending PubAck pkid={pkid}");
self.send_packet(&codec::Packet::PubAck(codec::PubAck { pkid }), None)?;
}
}
QoS::ExactlyOnce => {
if let Some(pkid) = publish.pkid {
let is_dup = self.session.track_incoming(pkid);
if !is_dup {
self.handler.on_publish(publish);
}
log::debug!("sending PubRec pkid={pkid} dup={is_dup}");
self.send_packet(&codec::Packet::PubRec(codec::PubRec { pkid }), None)?;
}
}
}
Ok(())
}
}
fn wait_thread(rx: Option<mpsc::Receiver<()>>, deadline: Option<Instant>) {
if let Some(rx) = rx {
match deadline {
Some(dl) => {
let _ = rx.recv_timeout(dl.saturating_duration_since(Instant::now()));
}
None => {
let _ = rx.recv();
}
}
}
}
fn packet_name(pkt: &codec::Packet) -> &'static str {
match pkt {
codec::Packet::Connect(_) => "CONNECT",
codec::Packet::ConnAck(_) => "CONNACK",
codec::Packet::Publish(_) => "PUBLISH",
codec::Packet::PubAck(_) => "PUBACK",
codec::Packet::PubRec(_) => "PUBREC",
codec::Packet::PubRel(_) => "PUBREL",
codec::Packet::PubComp(_) => "PUBCOMP",
codec::Packet::Subscribe(_) => "SUBSCRIBE",
codec::Packet::SubAck(_) => "SUBACK",
codec::Packet::Unsubscribe(_) => "UNSUBSCRIBE",
codec::Packet::UnsubAck(_) => "UNSUBACK",
codec::Packet::PingReq(_) => "PINGREQ",
codec::Packet::PingResp(_) => "PINGRESP",
codec::Packet::Disconnect(_) => "DISCONNECT",
}
}