Struct WsError

Source

pub struct WsError { /* private fields */ }

Expand description

Extended WebSocket error with classification.

This struct wraps WebSocket errors with additional metadata including:

Error kind (transient or permanent)
Human-readable message
Optional source error for error chaining

§Example

use ccxt_core::ws_client::{WsError, WsErrorKind};

// Create a transient error
let err = WsError::transient("Connection reset by peer");
assert!(err.is_transient());
assert_eq!(err.kind(), WsErrorKind::Transient);

// Create a permanent error
let err = WsError::permanent("Authentication failed: invalid API key");
assert!(!err.is_transient());
assert_eq!(err.kind(), WsErrorKind::Permanent);

Implementations§

Source §

impl WsError

Source

pub fn new(kind: WsErrorKind, message: impl Into<String>) -> WsError

Creates a new WsError with the specified kind and message.

§Arguments

kind - The error classification (transient or permanent)
message - Human-readable error message

§Example

use ccxt_core::ws_client::{WsError, WsErrorKind};

let err = WsError::new(WsErrorKind::Transient, "Connection timeout");
assert!(err.is_transient());

Source

pub fn with_source<E>( kind: WsErrorKind, message: impl Into<String>, source: E, ) -> WsError
where E: Error + Send + Sync + 'static,

Creates a new WsError with a source error.

§Arguments

kind - The error classification (transient or permanent)
message - Human-readable error message
source - The underlying error that caused this error

§Example

use ccxt_core::ws_client::{WsError, WsErrorKind};
use std::io;

let io_err = io::Error::new(io::ErrorKind::ConnectionReset, "connection reset");
let err = WsError::with_source(
    WsErrorKind::Transient,
    "Connection lost",
    io_err
);
assert!(err.source().is_some());

Source

pub fn transient(message: impl Into<String>) -> WsError

Creates a transient error.

Transient errors are temporary and may recover with retry.

§Arguments

message - Human-readable error message

§Example

use ccxt_core::ws_client::WsError;

let err = WsError::transient("Network timeout");
assert!(err.is_transient());

Source

pub fn transient_with_source<E>( message: impl Into<String>, source: E, ) -> WsError
where E: Error + Send + Sync + 'static,

Creates a transient error with a source.

§Arguments

message - Human-readable error message
source - The underlying error that caused this error

Source

pub fn permanent(message: impl Into<String>) -> WsError

Creates a permanent error.

Permanent errors should not be retried as they indicate a fundamental issue that won’t resolve with retries.

§Arguments

message - Human-readable error message

§Example

use ccxt_core::ws_client::WsError;

let err = WsError::permanent("Invalid API key");
assert!(!err.is_transient());

Source

pub fn permanent_with_source<E>( message: impl Into<String>, source: E, ) -> WsError
where E: Error + Send + Sync + 'static,

Creates a permanent error with a source.

§Arguments

message - Human-readable error message
source - The underlying error that caused this error

Source

pub fn kind(&self) -> WsErrorKind

Returns the error kind.

§Example

use ccxt_core::ws_client::{WsError, WsErrorKind};

let err = WsError::transient("timeout");
assert_eq!(err.kind(), WsErrorKind::Transient);

Source

pub fn message(&self) -> &str

Returns the error message.

§Example

use ccxt_core::ws_client::WsError;

let err = WsError::transient("Connection timeout");
assert_eq!(err.message(), "Connection timeout");

Source

pub fn is_transient(&self) -> bool

Returns true if this is a transient error.

Transient errors may recover with retry.

§Example

use ccxt_core::ws_client::WsError;

let err = WsError::transient("timeout");
assert!(err.is_transient());

let err = WsError::permanent("auth failed");
assert!(!err.is_transient());

Source

pub fn is_permanent(&self) -> bool

Returns true if this is a permanent error.

Permanent errors should not be retried.

§Example

use ccxt_core::ws_client::WsError;

let err = WsError::permanent("auth failed");
assert!(err.is_permanent());

let err = WsError::transient("timeout");
assert!(!err.is_permanent());

Source

pub fn source(&self) -> Option<&(dyn Error + Sync + Send + 'static)>

Returns the source error, if any.

§Example

use ccxt_core::ws_client::WsError;
use std::io;

let io_err = io::Error::new(io::ErrorKind::ConnectionReset, "reset");
let err = WsError::transient_with_source("Connection lost", io_err);
assert!(err.source().is_some());

Source §

impl WsError

Source

pub fn from_tungstenite(err: &Error) -> WsError

Classifies a tungstenite WebSocket error.

This method analyzes the error type and classifies it as either transient (retryable) or permanent (non-retryable).

§Classification Rules

§Transient Errors (retryable)

IO errors (network issues, connection resets)
ConnectionClosed (server closed connection)
AlreadyClosed (connection was already closed)
Server errors (5xx HTTP status codes)

§Permanent Errors (non-retryable)

Protocol errors (WebSocket protocol violations)
UTF-8 encoding errors
Authentication errors (401/403 HTTP status codes)
Client errors (4xx HTTP status codes, except 5xx)

§Arguments

err - The tungstenite error to classify

§Example

use ccxt_core::ws_client::WsError;
use tokio_tungstenite::tungstenite::Error as TungError;

// IO errors are transient
let io_err = std::io::Error::new(std::io::ErrorKind::ConnectionReset, "reset");
let ws_err = WsError::from_tungstenite(&TungError::Io(io_err));
assert!(ws_err.is_transient());

Source

pub fn from_error(err: &Error) -> WsError

Classifies a generic error and wraps it in a WsError.

This is a convenience method for wrapping arbitrary errors. By default, unknown errors are classified as transient.

§Arguments

err - The error to classify

§Example

use ccxt_core::ws_client::WsError;
use ccxt_core::error::Error;

let err = Error::network("Connection failed");
let ws_err = WsError::from_error(&err);
assert!(ws_err.is_transient());