Struct WsProxy 

pub struct WsProxy { /* private fields */ }

WebSocket reverse proxy with round-robin load balancing.

Accepts HTTP/1.1 WebSocket upgrade requests and tunnels traffic to one of the configured backends.

Backend URL schemes:

• "host:port" — plain TCP (no scheme)
• "ws://host:port" — plain TCP (port defaults to 80)
• "wss://host:port" — TLS (port defaults to 443); requires the http-client or http2 Cargo feature

Call WsProxy::bind to start. It blocks the calling thread indefinitely.

Implementations

impl WsProxy

pub fn new<I, S>(backends: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Create a proxy that distributes connections across backends in round-robin order. Every backend is treated as always live — no health check is attached; use the config-driven proxy’s [ws_proxy.health_check] for that.

Each entry may be "host:port", "ws://host:port", or "wss://host:port". wss:// requires the http-client or http2 Cargo feature.

pub fn with_live_backends( all_backends: Vec<String>, live: Arc<RwLock<Vec<String>>>, ) -> Self

Build a proxy whose live-backend list is externally managed — live is shared with (and expected to be updated by) a health checker you run yourself, on whatever schedule and probe logic you choose. all_backends is the full configured list, used only for bind()’s empty-configuration check; round-robin only ever picks from live.

This is what the config-driven proxy’s [ws_proxy.health_check] uses internally (see proxy_config::health::start_health_checker), exposed directly for library users who want WS backend health checking without the config file — e.g. a custom probe that performs a real WebSocket handshake rather than a plain HTTP GET.

use std::sync::{Arc, RwLock};
use rust_web_server::ws_proxy::WsProxy;

let all = vec!["ws://chat-a:9000".to_string(), "ws://chat-b:9000".to_string()];
let live = Arc::new(RwLock::new(all.clone()));

// Run your own probe loop on another thread, writing into `live`:
let checker_live = Arc::clone(&live);
std::thread::spawn(move || loop {
    std::thread::sleep(std::time::Duration::from_secs(10));
    // *checker_live.write().unwrap() = probe_and_filter(&all);
    let _ = &checker_live;
});

WsProxy::with_live_backends(all, live)
    .bind("0.0.0.0:8080")
    .expect("WS proxy failed");

pub fn connect_timeout_ms(self, ms: u64) -> Self

Override the TCP connect timeout to each backend (default: 5 s).

pub fn read_timeout_ms(self, ms: u64) -> Self

Override the idle read timeout on client connections (default: 30 s).

For wss:// backends this controls the outer idle timeout on the client side; the internal polling interval is fixed at 5 ms.

pub fn bind(self, addr: &str) -> Result<(), String>

Bind on addr and start proxying WebSocket connections. Blocks indefinitely.