Struct WebSocketClientInner 

pub struct WebSocketClientInner { /* private fields */ }

WebSocketClient connects to a websocket server to read and send messages.

The client is opinionated about how messages are read and written. It assumes that data can only have one reader but multiple writers.

The client splits the connection into read and write halves. It moves the read half into a tokio task which keeps receiving messages from the server and calls a handler - a Python function that takes the data as its parameter. It stores the write half in the struct wrapped with an Arc Mutex. This way the client struct can be used to write data to the server from multiple scopes/tasks.

The client also maintains a heartbeat if given a duration in seconds. It’s preferable to set the duration slightly lower - heartbeat more frequently - than the required amount.

Implementations

impl WebSocketClientInner

pub async fn new_with_writer( config: WebSocketConfig, writer: SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>, ) -> Result<Self, Error>

Create an inner websocket client with an existing writer.

Errors

Returns an error if the exponential backoff configuration is invalid.

pub async fn connect_url(config: WebSocketConfig) -> Result<Self, Error>

Create 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)>, ) -> Result<(SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>, MessageReader), Error>

Connects with the server creating a tokio-tungstenite websocket stream. Turmoil version that uses the lower-level client_async API with injected stream.

Errors

Returns an error if:

• The URL cannot be parsed into a valid client request.
• The URL is missing a hostname.
• Header values are invalid.
• The TCP connection fails.
• TLS setup fails (for wss:// URLs).
• The WebSocket handshake fails.

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

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 connect_stream), 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.

Errors

Returns an error if:

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

pub fn is_alive(&self) -> bool

Check if the client is still connected.

The client is connected if the read task has not finished. It is expected that in case of any failure client or server side. The read task will be shutdown or will receive a Close frame which will finish it. There might be some delay between the connection being closed and the client detecting.

Trait Implementations

impl CleanDrop for WebSocketClientInner

Cleanup on drop: aborts background tasks and clears handlers to break reference cycles.

fn clean_drop(&mut self)

Perform custom cleanup, releasing external resources and breaking strong reference cycles.

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.