Struct WebSocketClientInner 

pub struct WebSocketClientInner { /* private fields */ }

Owns the transport tasks and reconnect state used by WebSocketClient.

Connection ownership

The client uses one reader and supports concurrent senders. In handler mode, a reader task dispatches incoming messages while a writer task serializes sends received over a channel. The controller owns the connection lifecycle and replaces both transport halves during reconnects.

Stream mode returns the reader to the caller. The client cannot replace that reader, so stream mode disables automatic reconnection.

Heartbeats

When configured, a dedicated task sends heartbeat messages at the requested interval. Configure the interval below the server’s heartbeat deadline. Handler mode can also opt into a heartbeat timeout that reconnects when no frame arrives within a venue-specific duration. The timeout starts with each connection and resets on every inbound frame, including Ping and Pong.

Reconnection

The writer task owns queued sends across reconnects. A successful reconnect installs the replacement writer and starts a reader for the new connection epoch. Depending on the configured authentication gate, buffered sends drain immediately or wait for the new session to authenticate. Failed authentication discards messages that remain buffered.

Implementations

impl WebSocketClientInner

pub async fn new_with_writer( config: WebSocketConfig, writer: SplitSink<BoxedWsTransport, Message>, ) -> Result<Self, TransportError>

Creates an inner WebSocket client with an existing writer.

This is used for stream mode where the reader is owned by the caller.

Errors

Returns an error if the exponential backoff configuration is invalid.

pub async fn connect_url( config: WebSocketConfig, message_handler: Option<MessageHandler>, ping_handler: Option<PingHandler>, ) -> Result<Self, TransportError>

Creates an inner WebSocket client.

Errors

Returns an error if:

• The connection to the server fails.
• The exponential backoff configuration is invalid.

pub async fn connect_with_server( url: &str, headers: Vec<(String, String)>, backend: TransportBackend, proxy_url: Option<&str>, ) -> Result<(SplitSink<BoxedWsTransport, Message>, MessageReader), TransportError>

Connects to the server and returns the split halves of the active transport.

Dispatches on backend to the matching transport implementation. The TransportBackend::Tungstenite backend is always available; the TransportBackend::Sockudo backend requires the transport-sockudo Cargo feature (enabled by default) and uses a custom HTTP/1.1 handshake path for upgrade headers.

When proxy_url is Some, both backends establish an HTTP CONNECT tunnel through the proxy before performing the WebSocket handshake, and each keeps its own handshake path over the resulting stream.

Errors

Returns a TransportError if the URL is invalid, headers fail to parse, the TCP / TLS layer cannot be established, the proxy refuses the tunnel, or the WebSocket handshake is rejected by the peer. When the Sockudo backend is selected without the transport-sockudo feature, returns TransportError::Other.

impl WebSocketClientInner

pub async fn reconnect(&mut self) -> Result<(), TransportError>

Reconnect with server.

Make a new connection with server. Use the new read and write halves to update self writer and read and heartbeat tasks.

For stream-based clients (created via WebSocketClient::stream_builder), reconnection is disabled because the reader is owned by the caller and cannot be replaced. Stream users should handle disconnections by creating a new connection.

The reconnect timeout bounds only connection establishment. Once the new writer is handed to the writer task the swap runs to completion, so buffered messages can never drain into a connection that lost its reader to a timeout; the post-connect steps are individually bounded by the writer task’s graceful-shutdown timeout.

Errors

Returns an error if:

• The reconnection attempt times out.
• The connection to the server fails.

pub fn is_alive(&self) -> bool

Returns whether the client’s transport tasks are still running.

Returns true if both the read and write tasks are still running. There may be some delay between the connection closing and the client detecting it.

Trait Implementations

impl Debug for WebSocketClientInner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for WebSocketClientInner

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.