Enum PeerError

#[non_exhaustive]
pub enum PeerError {
    ResponseDeserialization(Error),
    InvalidPeerId {
        peer_id: PeerId,
    },
    InvalidEndpoint(Error),
    Connection(Error),
    Transport(Error),
    InvalidRpcId(Error),
    InvalidRequest(Error),
    InvalidResponse(Error),
    ServerError(Error),
    ConditionFailed(Error),
    InternalClientError(Error),
}

An API request error when calling a single federation peer

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ResponseDeserialization(Error)

The response payload was returned successfully but failed to be deserialized

InvalidPeerId

The request was addressed to an invalid peer_id

Fields

peer_id: PeerId

InvalidEndpoint(Error)

The endpoint specification for the peer is invalid (e.g. wrong url)

Connection(Error)

Could not connect

Transport(Error)

Underlying transport failed, in some typical way

InvalidRpcId(Error)

The rpc id (e.g. jsonrpc method name) was not recognized by the peer

This one is important and sometimes used to detect backward compatibility capabilities, so transports should properly support it.

InvalidRequest(Error)

Something about the request we’ve sent was wrong, should not typically happen

InvalidResponse(Error)

Something about the response was wrong, should not typically happen

ServerError(Error)

Server returned an internal error, suggesting something is wrong with it

ConditionFailed(Error)

Some condition on the response this not match

Typically expected, and often used in FilterMap query strategy to reject responses that don’t match some criteria.

InternalClientError(Error)

An internal client error

Things that shouldn’t happen (better than panicking), logical errors, malfunctions caused by internal issues.

Implementations

impl PeerError

pub fn is_unusual(&self) -> bool

pub fn report_if_unusual(&self, peer_id: PeerId, context: &str)

Report errors that are worth reporting

The goal here is to avoid spamming logs with errors that happen commonly for all sorts of expected reasons, while printing ones that suggest there’s a problem.

Trait Implementations

impl Debug for PeerError

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

Formats the value using the given formatter.

impl Display for PeerError

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

Formats the value using the given formatter.

impl Error for PeerError

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.