use std::time::Duration;
use bytes::Bytes;
pub(crate) mod auth;
pub(crate) mod client;
pub(crate) mod error;
pub(crate) mod session;
pub(crate) mod token;
pub(crate) mod topic_alias;
pub use auth::{AuthHandler, NoOpAuthHandler};
pub use client::Client;
pub use error::Error;
pub use session::{AckResult, Retransmit, ServerProperties, Session, SessionError};
pub use symqtt_codec::QoS;
pub use symqtt_codec::v5::{Disconnect, Publish, ReasonCode, RetainHandling};
pub use token::{PublishAckDetail, Token};
pub trait InboundHandler: Send + Sync + 'static {
fn on_publish(&self, msg: &Publish);
fn on_disconnect(&self, _reason: &Error) {}
fn on_server_disconnect(&self, _disconnect: &Disconnect) {}
}
pub struct Will {
pub topic: String,
pub payload: Bytes,
pub qos: QoS,
pub retain: bool,
pub properties: WillProperties,
}
#[derive(Debug, Clone, Default)]
pub struct WillProperties {
pub will_delay_interval: Option<u32>,
pub payload_format_indicator: Option<u8>,
pub message_expiry_interval: Option<u32>,
pub content_type: Option<String>,
pub response_topic: Option<String>,
pub correlation_data: Option<Bytes>,
pub user_properties: Vec<(String, String)>,
}
pub struct ConnectOptions {
pub client_id: String,
pub clean_start: 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>,
pub session_expiry_interval: Option<Duration>,
pub receive_maximum: Option<u16>,
pub maximum_packet_size: Option<u32>,
pub topic_alias_maximum: Option<u16>,
pub request_response_info: bool,
pub request_problem_info: bool,
pub user_properties: Vec<(String, String)>,
pub auth_method: Option<String>,
pub auth_data: Option<Bytes>,
}
impl ConnectOptions {
pub fn ping_timeout(&self) -> Duration {
self.ping_timeout.unwrap_or(self.keep_alive)
}
}
impl Default for ConnectOptions {
fn default() -> Self {
Self {
client_id: String::new(),
clean_start: true,
keep_alive: Duration::from_secs(60),
will: None,
username: None,
password: None,
connect_timeout: None,
ping_timeout: None,
session_expiry_interval: None,
receive_maximum: None,
maximum_packet_size: None,
topic_alias_maximum: None,
request_response_info: false,
request_problem_info: true,
user_properties: Vec::new(),
auth_method: None,
auth_data: None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PayloadFormatIndicator {
Unspecified = 0,
Utf8 = 1,
}
impl PayloadFormatIndicator {
pub fn as_u8(self) -> u8 {
self as u8
}
}
pub struct PublishMessage<'a> {
pub topic: &'a str,
pub payload: Bytes,
pub qos: QoS,
pub retain: bool,
pub timeout: Option<Duration>,
pub payload_format_indicator: Option<PayloadFormatIndicator>,
pub message_expiry_interval: Option<Duration>,
pub response_topic: Option<String>,
pub correlation_data: Option<Bytes>,
pub user_properties: Vec<(String, String)>,
pub content_type: Option<String>,
}
impl<'a> PublishMessage<'a> {
pub fn new(topic: &'a str, payload: Bytes) -> Self {
Self {
topic,
payload,
qos: QoS::AtMostOnce,
retain: false,
timeout: None,
payload_format_indicator: None,
message_expiry_interval: None,
response_topic: None,
correlation_data: None,
user_properties: Vec::new(),
content_type: 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
}
pub fn payload_format_indicator(mut self, v: PayloadFormatIndicator) -> Self {
self.payload_format_indicator = Some(v);
self
}
pub fn message_expiry_interval(mut self, d: Duration) -> Self {
self.message_expiry_interval = Some(d);
self
}
pub fn response_topic(mut self, topic: String) -> Self {
self.response_topic = Some(topic);
self
}
pub fn correlation_data(mut self, data: Bytes) -> Self {
self.correlation_data = Some(data);
self
}
pub fn user_properties(mut self, props: impl IntoIterator<Item = (String, String)>) -> Self {
self.user_properties.extend(props);
self
}
pub fn content_type(mut self, ct: String) -> Self {
self.content_type = Some(ct);
self
}
}
#[derive(Debug)]
pub struct SubscribeFilter {
pub topic: String,
pub qos: QoS,
pub no_local: bool,
pub retain_as_published: bool,
pub retain_handling: RetainHandling,
}
impl SubscribeFilter {
pub fn new(topic: impl Into<String>, qos: QoS) -> Self {
Self {
topic: topic.into(),
qos,
no_local: false,
retain_as_published: false,
retain_handling: RetainHandling::SendAtSubscribe,
}
}
}
impl From<&ConnectOptions> for symqtt_codec::v5::Connect {
fn from(opts: &ConnectOptions) -> Self {
Self {
clean_start: opts.clean_start,
keep_alive: opts.keep_alive.as_secs() as u16,
client_id: opts.client_id.clone(),
username: opts.username.clone(),
password: opts.password.clone(),
will: opts.will.as_ref().map(|w| symqtt_codec::v5::Will {
qos: w.qos,
retain: w.retain,
topic: w.topic.clone(),
payload: w.payload.clone(),
properties: symqtt_codec::v5::WillProperties {
will_delay_interval: w.properties.will_delay_interval,
payload_format_indicator: w.properties.payload_format_indicator,
message_expiry_interval: w.properties.message_expiry_interval,
content_type: w.properties.content_type.clone(),
response_topic: w.properties.response_topic.clone(),
correlation_data: w.properties.correlation_data.clone(),
user_properties: w.properties.user_properties.clone(),
},
}),
properties: symqtt_codec::v5::ConnectProperties {
session_expiry_interval: opts.session_expiry_interval.map(|v| v.as_secs() as u32),
receive_maximum: opts.receive_maximum,
maximum_packet_size: opts.maximum_packet_size,
topic_alias_maximum: opts.topic_alias_maximum,
request_response_information: if opts.request_response_info { Some(1) } else { None },
request_problem_information: if opts.request_problem_info { Some(1) } else { None },
user_properties: opts.user_properties.clone(),
authentication_method: opts.auth_method.clone(),
authentication_data: opts.auth_data.clone(),
},
}
}
}
impl From<&PublishMessage<'_>> for Publish {
fn from(msg: &PublishMessage<'_>) -> Self {
Publish {
dup: false,
qos: msg.qos,
retain: msg.retain,
topic: msg.topic.to_owned(),
pkid: None,
properties: symqtt_codec::v5::PublishProperties {
payload_format_indicator: msg.payload_format_indicator.map(|v| v.as_u8()),
message_expiry_interval: msg
.message_expiry_interval
.map(|d| d.as_secs().min(u32::MAX as u64) as u32),
topic_alias: None, response_topic: msg.response_topic.clone(),
correlation_data: msg.correlation_data.clone(),
subscription_identifiers: Vec::new(),
user_properties: msg.user_properties.clone(),
content_type: msg.content_type.clone(),
},
payload: msg.payload.clone(),
}
}
}
impl From<&SubscribeFilter> for symqtt_codec::v5::SubscribeFilter {
fn from(f: &SubscribeFilter) -> Self {
Self {
topic: f.topic.clone(),
qos: f.qos,
no_local: f.no_local,
retain_as_published: f.retain_as_published,
retain_handling: f.retain_handling,
}
}
}