delta-stream 0.32.0

State-aware delta synchronization and recovery for realtime Rust applications
Documentation
use futures::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use tokio::{net::TcpListener, sync::broadcast};
use tokio_tungstenite::{accept_async, tungstenite::Message};

use crate::error::DeltaError;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "op", rename_all = "snake_case")]
enum RelayFrame {
    Publish { topic: String, payload_hex: String },
    Subscribe { topics: Vec<String> },
    Message { topic: String, payload_hex: String },
}

pub async fn run(addr: &str) -> Result<(), DeltaError> {
    let listener = TcpListener::bind(addr).await?;
    let (bus, _) = broadcast::channel::<(String, String)>(2048);
    println!("DeltaStream WebSocket relay listening on ws://{addr}");

    loop {
        let (stream, _) = listener.accept().await?;
        let bus = bus.clone();
        tokio::spawn(async move {
            let mut ws = match accept_async(stream).await {
                Ok(ws) => ws,
                Err(e) => {
                    eprintln!("websocket accept failed: {e}");
                    return;
                }
            };
            let Some(Ok(Message::Text(text))) = ws.next().await else {
                return;
            };
            let frame = match serde_json::from_str::<RelayFrame>(&text) {
                Ok(frame) => frame,
                Err(e) => {
                    eprintln!("invalid relay frame: {e}");
                    return;
                }
            };
            match frame {
                RelayFrame::Publish { topic, payload_hex } => {
                    let _ = bus.send((topic, payload_hex));
                }
                RelayFrame::Subscribe { topics } => {
                    let mut rx = bus.subscribe();
                    loop {
                        match rx.recv().await {
                            Ok((topic, payload_hex)) if topics.iter().any(|t| t == &topic) => {
                                let frame = RelayFrame::Message { topic, payload_hex };
                                let text = match serde_json::to_string(&frame) {
                                    Ok(v) => v,
                                    Err(_) => break,
                                };
                                if ws.send(Message::Text(text)).await.is_err() {
                                    break;
                                }
                            }
                            Ok(_) => {}
                            Err(broadcast::error::RecvError::Lagged(_)) => continue,
                            Err(_) => break,
                        }
                    }
                }
                RelayFrame::Message { .. } => {}
            }
        });
    }
}