delta-stream 0.32.0

State-aware delta synchronization and recovery for realtime Rust applications
Documentation
use std::{
    io::{Read, Write},
    net::{TcpListener, TcpStream},
    sync::{Arc, Mutex},
};

use serde::Serialize;

use crate::{
    error::DeltaError,
    metrics::Metrics,
    state::AgentState,
    sync::{ApplyResult, Decoder, Encoder},
};

const DASHBOARD: &str = include_str!("../demo/index.html");

#[derive(Debug)]
struct DemoState {
    current: AgentState,
    encoder: Encoder,
    decoder: Decoder,
    metrics: Metrics,
    drop_next: bool,
}

#[derive(Serialize)]
struct TickResponse {
    state: AgentState,
    metrics: Metrics,
    full_bytes: usize,
    delta_bytes: usize,
    dropped: bool,
    desync_detected: bool,
    resynced: bool,
    sequence: u64,
}

pub fn serve(addr: &str) -> Result<(), DeltaError> {
    let listener = TcpListener::bind(addr)?;
    let shared = Arc::new(Mutex::new(fresh_demo()));

    println!("DeltaStream dashboard: http://{addr}");
    println!("Press Ctrl+C to stop.");

    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                let shared = Arc::clone(&shared);
                std::thread::spawn(move || {
                    if let Err(err) = handle(stream, shared) {
                        eprintln!("request error: {err}");
                    }
                });
            }
            Err(err) => eprintln!("connection error: {err}"),
        }
    }
    Ok(())
}

fn fresh_demo() -> DemoState {
    DemoState {
        current: AgentState::demo(),
        encoder: Encoder::default(),
        decoder: Decoder::default(),
        metrics: Metrics::default(),
        drop_next: false,
    }
}

fn handle(mut stream: TcpStream, shared: Arc<Mutex<DemoState>>) -> Result<(), DeltaError> {
    let mut buf = [0u8; 4096];
    let n = stream.read(&mut buf)?;
    if n == 0 {
        return Ok(());
    }
    let req = String::from_utf8_lossy(&buf[..n]);
    let first = req.lines().next().unwrap_or("");
    let mut parts = first.split_whitespace();
    let method = parts.next().unwrap_or("");
    let path = parts.next().unwrap_or("/");

    match (method, path) {
        ("GET", "/") => respond(
            &mut stream,
            "200 OK",
            "text/html; charset=utf-8",
            DASHBOARD.as_bytes(),
        )?,
        ("GET", "/api/tick") => {
            let mut s = shared
                .lock()
                .map_err(|_| DeltaError::InvalidState("demo mutex poisoned"))?;
            let next = s.current.advance();
            let full_bytes = serde_json::to_vec(&next)?.len();
            let packet = s.encoder.encode(&next)?;
            let packet_bytes = packet.encode()?.len();
            let dropped = std::mem::take(&mut s.drop_next);
            let mut desync_detected = false;
            let mut resynced = false;
            let mut wire_bytes = packet_bytes;
            let mut sequence = packet.sequence;

            s.metrics.updates += 1;
            s.metrics.full_json_bytes += full_bytes as u64;
            s.metrics.wire_bytes += packet_bytes as u64;
            if packet.kind == crate::packet::PacketKind::Delta {
                s.metrics.delta_packets += 1;
            } else {
                s.metrics.snapshot_packets += 1;
            }
            if packet.is_compressed() {
                s.metrics.compressed_packets += 1;
            }

            if !dropped {
                match s.decoder.apply_packet(packet)? {
                    ApplyResult::Applied { .. } => {}
                    ApplyResult::Duplicate { .. } => {
                        s.metrics.duplicates += 1;
                    }
                    ApplyResult::NeedSnapshot { .. } => {
                        desync_detected = true;
                        s.metrics.resyncs += 1;
                        let snapshot = s.encoder.recovery_snapshot(&next)?;
                        let snapshot_bytes = snapshot.encode()?.len();
                        wire_bytes += snapshot_bytes;
                        s.metrics.wire_bytes += snapshot_bytes as u64;
                        sequence = snapshot.sequence;
                        match s.decoder.apply_packet(snapshot)? {
                            ApplyResult::Applied { .. } => resynced = true,
                            ApplyResult::Duplicate { .. } => resynced = true,
                            ApplyResult::NeedSnapshot { .. } => {
                                return Err(DeltaError::InvalidState(
                                    "snapshot failed to resync decoder",
                                ));
                            }
                        }
                    }
                }
            }

            s.current = next.clone();
            let payload = serde_json::to_vec(&TickResponse {
                state: next,
                metrics: s.metrics.clone(),
                full_bytes,
                delta_bytes: wire_bytes,
                dropped,
                desync_detected,
                resynced,
                sequence,
            })?;
            respond(&mut stream, "200 OK", "application/json", &payload)?;
        }
        ("POST", "/api/drop") => {
            shared
                .lock()
                .map_err(|_| DeltaError::InvalidState("demo mutex poisoned"))?
                .drop_next = true;
            respond(&mut stream, "204 No Content", "text/plain", b"")?;
        }
        ("POST", "/api/reset") => {
            let mut s = shared
                .lock()
                .map_err(|_| DeltaError::InvalidState("demo mutex poisoned"))?;
            *s = fresh_demo();
            respond(&mut stream, "204 No Content", "text/plain", b"")?;
        }
        _ => respond(&mut stream, "404 Not Found", "text/plain", b"not found")?,
    }
    Ok(())
}

fn respond(
    stream: &mut TcpStream,
    status: &str,
    content_type: &str,
    body: &[u8],
) -> Result<(), DeltaError> {
    write!(
        stream,
        "HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nCache-Control: no-store\r\nConnection: close\r\n\r\n",
        body.len()
    )?;
    stream.write_all(body)?;
    Ok(())
}