Struct WebSocketClient 

pub struct WebSocketClient { /* private fields */ }

WebSocket client with automatic reconnection (thin wrapper over ConnectionSupervisor)

Implementations

impl WebSocketClient

pub fn builder(uri: impl Into<String>) -> WebSocketClientBuilder

Create a new WebSocket client builder

pub fn new(uri: impl Into<String>) -> Self

Create a client with default configuration

pub fn subscribe(&self) -> Receiver<SharedMessage>

Subscribe to incoming messages

Returns a receiver for shared messages wrapped in Arc<Message> for zero-copy broadcasting. To work with the message:

• Read-only access: msg.as_ref() or dereference &*msg
• Need owned copy: Arc::try_unwrap(msg).unwrap_or_else(|arc| (*arc).clone())
• Clone specific data: msg.clone() clones the Arc (cheap), (*msg).clone() clones the Message

pub fn uri(&self) -> &str

Get target URI

pub fn subscribe_events(&self) -> Receiver<ConnectionEvent>

Subscribe to connection events

pub async fn sender(&self) -> Option<Sender>

Get a sender handle for sending messages

pub async fn send(&self, message: Message) -> Result<(), SendError>

Send a message (convenience method)

pub async fn send_async(&self, message: Message) -> Result<(), SendError>

Send a message (async, blocking on capacity)

pub async fn send_timeout( &self, message: Message, timeout: Duration, ) -> Result<(), SendError>

Send a message with timeout (async)

pub async fn state(&self) -> ConnectionSnapshot

Get current connection state snapshot

pub fn is_connected(&self) -> bool

Check if currently connected

pub async fn register_extension<E: Extension + 'static>( &self, extension: E, ) -> Result<(), ClientError>

Register an extension

pub async fn run(&self) -> Result<(), ClientError>

Run the client (blocking)

pub fn shutdown(&self)

Shutdown the client

pub async fn shutdown_graceful( &self, timeout: Duration, ) -> Result<(), ClientError>

Shutdown the client gracefully, waiting for the run loop to exit or timing out.

This method triggers shutdown() and then waits for the run loop to finish. If the client is not running, it returns immediately.

Note: This only waits for the run loop to exit (extensions receive disconnect/shutdown hooks). It does not guarantee that pending user messages make it to the peer; callers should coordinate with their own protocols if that guarantee is required.

Errors

Returns ClientError::ShutdownTimeout if the run loop does not exit within the specified timeout duration.

Trait Implementations

impl WebSocketClientExt for WebSocketClient

fn spawn(self: Arc<Self>) -> JoinHandle<Result<(), ClientError>>

Spawn the client as a background task