use std::time::Duration;
use bytes::Bytes;
pub(crate) mod client;
pub(crate) mod error;
pub(crate) mod session;
pub(crate) mod token;
pub use client::Client;
pub use error::Error;
pub use session::{AckResult, Retransmit, Session, SessionError};
pub use symqtt_codec::QoS;
pub use symqtt_codec::v3::{Publish, SubscribeReturnCode};
pub use token::Token;
pub trait InboundHandler: Send + Sync + 'static {
fn on_publish(&self, msg: &Publish);
fn on_disconnect(&self, _reason: &Error) {}
}
pub struct Will {
pub topic: String,
pub message: Bytes,
pub qos: QoS,
pub retain: bool,
}
pub struct ConnectOptions {
pub client_id: String,
pub clean_session: bool,
pub keep_alive: Duration,
pub will: Option<Will>,
pub username: Option<String>,
pub password: Option<Bytes>,
pub connect_timeout: Option<Duration>,
pub ping_timeout: Option<Duration>,
}
impl ConnectOptions {
pub fn ping_timeout(&self) -> Duration {
self.ping_timeout.unwrap_or(self.keep_alive)
}
}
pub struct PublishMessage<'a> {
pub(crate) topic: &'a str,
pub(crate) payload: Bytes,
pub(crate) qos: QoS,
pub(crate) retain: bool,
pub(crate) timeout: Option<Duration>,
}
impl<'a> PublishMessage<'a> {
pub fn new(topic: &'a str, payload: Bytes) -> Self {
Self {
topic,
payload,
qos: QoS::AtMostOnce,
retain: false,
timeout: None,
}
}
pub fn qos(mut self, qos: QoS) -> Self {
self.qos = qos;
self
}
pub fn retain(mut self, retain: bool) -> Self {
self.retain = retain;
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
}
impl From<&PublishMessage<'_>> for symqtt_codec::v3::Publish {
fn from(msg: &PublishMessage<'_>) -> Self {
symqtt_codec::v3::Publish {
dup: false,
pkid: None,
qos: msg.qos,
retain: msg.retain,
topic: msg.topic.to_owned(),
payload: msg.payload.clone(),
}
}
}
impl From<&ConnectOptions> for symqtt_codec::v3::Connect {
fn from(opts: &ConnectOptions) -> Self {
Self {
will: opts.will.as_ref().map(symqtt_codec::v3::Will::from),
keep_alive: opts.keep_alive.as_secs() as u16,
client_id: opts.client_id.clone(),
username: opts.username.clone(),
password: opts.password.clone(),
clean_session: opts.clean_session,
}
}
}
impl From<&Will> for symqtt_codec::v3::Will {
fn from(w: &Will) -> Self {
Self {
qos: w.qos,
retain: w.retain,
topic: w.topic.to_owned(),
message: w.message.clone(),
}
}
}