Struct WebsocketApi

pub struct WebsocketApi {
    pub common: Arc<WebsocketCommon>,
    /* private fields */
}

Fields

common: Arc<WebsocketCommon>

Implementations

impl WebsocketApi

pub fn new( configuration: ConfigurationWebsocketApi, connection_pool: Vec<Arc<WebsocketConnection>>, ) -> Arc<Self>

Creates a new WebSocket API instance with the given configuration and connection pool.

Arguments

• configuration - Configuration settings for the WebSocket API
• connection_pool - A vector of WebSocket connections to be used

Returns

An Arc-wrapped WebsocketApi instance ready for use

Panics

This function will panic if the configuration is not valid.

Examples

let api = WebsocketApi::new(config, connection_pool);

pub async fn connect(self: Arc<Self>) -> Result<(), WebsocketError>

Connects to a WebSocket server with a configurable timeout and connection handling.

This method attempts to establish a WebSocket connection if not already connected. It prevents multiple simultaneous connection attempts and supports a connection pool.

Errors

Returns a WebsocketError if:

• Connection fails
• Connection times out after 10 seconds

Behavior

• Checks if already connected and returns early if so
• Prevents multiple concurrent connection attempts
• Sets a WebSocket handler for the connection pool
• Attempts to connect with a 10-second timeout

Returns

Ok(()) if connection is successful, otherwise a WebsocketError

pub async fn disconnect(&self) -> Result<(), WebsocketError>

Disconnects the WebSocket connection.

Returns

Ok(()) if disconnection is successful, otherwise a WebsocketError

Errors

Returns a WebsocketError if:

• Disconnection fails
• Connection is not established

pub async fn is_connected(&self) -> bool

Checks if the WebSocket connection is currently established.

Returns

true if the connection is active, false otherwise.

pub async fn ping_server(&self)

Sends a ping to the WebSocket server to maintain the connection.

This method calls the underlying connection’s ping mechanism to check and keep the WebSocket connection alive.

pub async fn send_message<R>( &self, method: &str, payload: BTreeMap<String, Value>, options: WebsocketMessageSendOptions, ) -> Result<WebsocketApiResponse<R>, WebsocketError>

where R: DeserializeOwned + Send + Sync + 'static,

Sends a WebSocket message with the specified method and payload.

This method prepares and sends a WebSocket request with optional API key and signature. It handles connection status, generates a unique request ID, and processes the response.

Arguments

• method - The WebSocket API method to be called
• payload - A map of parameters to be sent with the request
• options - Configuration options for message sending (API key, signing)

Returns

A deserialized response of type R or a WebsocketError if the request fails

Panics

Panics if:

• The WebSocket is not connected
• The request cannot be processed
• No response is received within the timeout

Errors

Returns WebsocketError if:

• The WebSocket is not connected
• The request cannot be processed
• No response is received within the timeout

Trait Implementations

impl WebsocketHandler for WebsocketApi

fn on_open<'life0, 'async_trait>( &'life0 self, _url: String, _connection: Arc<WebsocketConnection>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Callback method invoked when a WebSocket connection is successfully opened.

This method is called after a WebSocket connection is established. Currently, it does not perform any actions and serves as a placeholder for potential connection initialization or logging.

Arguments

• _url - The URL of the WebSocket connection that was opened
• _connection - An Arc-wrapped WebSocket connection context

Remarks

This method can be overridden by implementations to add custom logic when a WebSocket connection is first opened.

fn on_message<'life0, 'async_trait>( &'life0 self, data: String, connection: Arc<WebsocketConnection>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles incoming WebSocket messages by parsing the JSON payload and processing pending requests.

This method is responsible for:

• Parsing the received WebSocket message as JSON
• Matching the message to a pending request by its ID
• Sending the response back to the original request’s completion channel
• Handling both successful and error responses

Arguments

• data - The raw WebSocket message as a string
• connection - The WebSocket connection context associated with the message

Behavior

• If message parsing fails, logs an error and returns
• For known request IDs, sends the response to the corresponding completion channel
• Warns about responses for unknown or timed-out requests
• Differentiates between successful (status < 400) and error responses

fn get_reconnect_url<'life0, 'async_trait>( &'life0 self, default_url: String, _connection: Arc<WebsocketConnection>, ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Generates the URL to use for reconnecting to a WebSocket connection.

Arguments

• default_url - The original URL to potentially modify for reconnection
• _connection - The WebSocket connection context (currently unused)

Returns

A String representing the URL to use for reconnecting