rs-zero 0.2.12

Rust-first microservice framework inspired by go-zero engineering practices
Documentation
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)
    }
}