Enum BrainError 

pub enum BrainError {
    Io(Error),
    Frame(FrameError),
    Cbor(CborError),
    Protocol(String),
    Server {
        code: ErrorCodeWire,
        category: ErrorCategoryWire,
        message: String,
        retry_after_ms: Option<u32>,
        response: Box<ErrorResponse>,
    },
    VersionMismatch {
        chosen: u8,
        supported: Vec<u8>,
    },
    Closed,
    Timeout(Duration),
}

A failure from any client operation.

Variants

Io(Error)

Local socket I/O failed.

Frame(FrameError)

A frame off the wire failed to decode (bad magic / CRC / reserved bits / oversize). A frame error desynchronizes the byte stream, so the connection is no longer usable.

Cbor(CborError)

A frame’s CBOR payload failed to encode or decode.

Protocol(String)

The peer broke the protocol sequence — e.g. an unexpected opcode where the handshake expects WELCOME, or a response on an unknown stream.

Server

The server returned a structured ERROR frame in response to a request. The full payload is preserved for code/category branching.

Fields

code: ErrorCodeWire

Specific error code; branch on this for programmatic handling.

category: ErrorCategoryWire

Coarse class of the failure, for deciding whether to retry at all.

message: String

Human-readable detail from the server.

retry_after_ms: Option<u32>

Server-supplied backoff hint, when it sent one.

response: Box<ErrorResponse>

The full decoded ERROR payload, kept so no field is lost to this projection.

VersionMismatch

The server chose a wire version the client does not support. Versions are u8 on the wire (HELLO supported_versions / WELCOME chosen_version).

Fields

chosen: u8

The version the server picked in WELCOME.

supported: Vec<u8>

The versions this client offered in HELLO.

Closed

The peer closed the connection (read returned zero bytes).

Timeout(Duration)

An operation did not complete within its deadline.

Implementations

impl BrainError

pub fn from_server(response: ErrorResponse) -> Self

Build a BrainError::Server from a decoded ERROR payload.

pub fn is_retryable(&self) -> bool

Whether retrying the operation could plausibly succeed. A transient transport drop or a resource-exhaustion / unavailable server verdict is retryable; a malformed-input or auth verdict is not. Consumed by crate::retry::with_retry.

pub fn retry_after(&self) -> Option<Duration>

The server-requested cool-off before retrying, when the ERROR carried a retry_after_ms. The retry combinator prefers this over its own backoff schedule.

Trait Implementations

impl Debug for BrainError

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

Formats the value using the given formatter.

impl Display for BrainError

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

Formats the value using the given formatter.

impl Error for BrainError

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

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<CborError> for BrainError

fn from(source: CborError) -> Self

Converts to this type from the input type.

impl From<Error> for BrainError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FrameError> for BrainError

fn from(source: FrameError) -> Self

Converts to this type from the input type.