delta-stream 0.32.0

State-aware delta synchronization and recovery for realtime Rust applications
Documentation
use std::time::Duration;

use async_trait::async_trait;
use futures::stream::BoxStream;
use rumqttc::{AsyncClient, Event, Incoming, MqttOptions, QoS};
use tokio::sync::mpsc;
use tokio_stream::wrappers::ReceiverStream;

use crate::{
    error::DeltaError,
    transport::{RealtimeTransport, TransportMessage},
};

#[derive(Debug, Clone)]
pub struct MqttRealtimeTransport {
    host: String,
    port: u16,
    client_prefix: String,
}
impl MqttRealtimeTransport {
    pub fn new(host: impl Into<String>, port: u16) -> Self {
        Self {
            host: host.into(),
            port,
            client_prefix: "delta-stream".into(),
        }
    }
    pub fn from_env() -> Self {
        let host = std::env::var("MQTT_HOST").unwrap_or_else(|_| "127.0.0.1".into());
        let port = std::env::var("MQTT_PORT")
            .ok()
            .and_then(|v| v.parse().ok())
            .unwrap_or(1883);
        Self::new(host, port)
    }
    fn options(&self, suffix: &str) -> MqttOptions {
        let mut options = MqttOptions::new(
            format!("{}-{suffix}", self.client_prefix),
            self.host.clone(),
            self.port,
        );
        options.set_keep_alive(Duration::from_secs(10));
        options
    }
}

#[async_trait]
impl RealtimeTransport for MqttRealtimeTransport {
    async fn publish(&self, topic: &str, payload: Vec<u8>) -> Result<(), DeltaError> {
        let (client, mut eventloop) = AsyncClient::new(self.options("pub"), 16);
        client
            .publish(topic, QoS::AtLeastOnce, false, payload)
            .await
            .map_err(|e| DeltaError::Transport(e.to_string()))?;
        for _ in 0..8 {
            match tokio::time::timeout(Duration::from_secs(2), eventloop.poll()).await {
                Ok(Ok(Event::Incoming(Incoming::PubAck(_)))) => return Ok(()),
                Ok(Ok(_)) => {}
                Ok(Err(e)) => return Err(DeltaError::Transport(e.to_string())),
                Err(_) => break,
            }
        }
        Ok(())
    }

    async fn subscribe(
        &self,
        topics: Vec<String>,
    ) -> Result<BoxStream<'static, Result<TransportMessage, DeltaError>>, DeltaError> {
        let (client, mut eventloop) = AsyncClient::new(self.options("sub"), 64);
        for topic in &topics {
            client
                .subscribe(topic, QoS::AtLeastOnce)
                .await
                .map_err(|e| DeltaError::Transport(e.to_string()))?;
        }
        let (tx, rx) = mpsc::channel(1024);
        tokio::spawn(async move {
            loop {
                match eventloop.poll().await {
                    Ok(Event::Incoming(Incoming::Publish(p))) => {
                        if tx
                            .send(Ok(TransportMessage {
                                topic: p.topic,
                                payload: p.payload.to_vec(),
                            }))
                            .await
                            .is_err()
                        {
                            break;
                        }
                    }
                    Ok(_) => {}
                    Err(e) => {
                        let _ = tx.send(Err(DeltaError::Transport(e.to_string()))).await;
                        break;
                    }
                }
            }
        });
        Ok(Box::pin(ReceiverStream::new(rx)))
    }
}