use std::time::Duration;
use rumqttc::{MqttOptions, QoS};
use crate::mqtt::{MqttError, MqttResult};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MqttQoS {
AtMostOnce,
AtLeastOnce,
ExactlyOnce,
}
impl From<MqttQoS> for QoS {
fn from(value: MqttQoS) -> Self {
match value {
MqttQoS::AtMostOnce => QoS::AtMostOnce,
MqttQoS::AtLeastOnce => QoS::AtLeastOnce,
MqttQoS::ExactlyOnce => QoS::ExactlyOnce,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MqttSubscription {
pub topic: String,
pub qos: MqttQoS,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MqttReconnectConfig {
pub initial_delay: Duration,
pub max_delay: Duration,
}
impl Default for MqttReconnectConfig {
fn default() -> Self {
Self {
initial_delay: Duration::from_millis(200),
max_delay: Duration::from_secs(5),
}
}
}
impl MqttReconnectConfig {
pub fn delay_for_attempt(&self, attempt: u32) -> Duration {
let multiplier = 1u32.checked_shl(attempt).unwrap_or(u32::MAX);
let delay = self.initial_delay.saturating_mul(multiplier);
delay.min(self.max_delay)
}
}
#[derive(Debug, Clone)]
pub struct MqttConfig {
pub client_id: String,
pub host: String,
pub port: u16,
pub username: Option<String>,
pub password: Option<String>,
pub keep_alive: Duration,
pub clean_session: bool,
pub inflight: usize,
pub subscriptions: Vec<MqttSubscription>,
pub reconnect: MqttReconnectConfig,
pub handler_timeout: Option<Duration>,
#[cfg(feature = "observability")]
pub metrics_registry: Option<crate::observability::MetricsRegistry>,
}
impl Default for MqttConfig {
fn default() -> Self {
Self {
client_id: "rs-zero-mqtt".to_string(),
host: "127.0.0.1".to_string(),
port: 1883,
username: None,
password: None,
keep_alive: Duration::from_secs(30),
clean_session: true,
inflight: 10,
subscriptions: Vec::new(),
reconnect: MqttReconnectConfig::default(),
handler_timeout: Some(Duration::from_secs(5)),
#[cfg(feature = "observability")]
metrics_registry: None,
}
}
}
impl MqttConfig {
pub fn validate(&self) -> MqttResult<()> {
if self.client_id.trim().is_empty() {
return Err(MqttError::InvalidConfig(
"client_id cannot be empty".to_string(),
));
}
if self.host.trim().is_empty() {
return Err(MqttError::InvalidConfig("host cannot be empty".to_string()));
}
if self.inflight == 0 {
return Err(MqttError::InvalidConfig(
"inflight must be greater than zero".to_string(),
));
}
if self.inflight > u16::MAX as usize {
return Err(MqttError::InvalidConfig(
"inflight cannot exceed u16::MAX".to_string(),
));
}
if self.reconnect.initial_delay > self.reconnect.max_delay {
return Err(MqttError::InvalidConfig(
"reconnect initial_delay cannot exceed max_delay".to_string(),
));
}
for subscription in &self.subscriptions {
if subscription.topic.trim().is_empty() {
return Err(MqttError::InvalidConfig(
"subscription topic cannot be empty".to_string(),
));
}
}
Ok(())
}
pub fn to_mqtt_options(&self) -> MqttResult<MqttOptions> {
self.validate()?;
let mut options = MqttOptions::new(&self.client_id, &self.host, self.port);
options.set_keep_alive(self.keep_alive);
options.set_clean_session(self.clean_session);
options.set_inflight(self.inflight as u16);
if let (Some(username), Some(password)) = (&self.username, &self.password) {
options.set_credentials(username, password);
}
Ok(options)
}
}