Enum TransportError 

#[non_exhaustive]
pub enum TransportError {
    Problem {
        problem: Box<Problem>,
        retry_after: Option<Duration>,
    },
    HttpStatus {
        status: u16,
        body: String,
        retry_after: Option<Duration>,
    },
    Grpc {
        code: Code,
        message: String,
    },
    Network(Box<dyn Error + Sync + Send>),
    Timeout(Duration),
    Serialization(Box<dyn Error + Sync + Send>),
    Sse(Box<dyn Error + Sync + Send>),
    UrlBuild(String),
    Unresolved {
        gear: String,
    },
}

Errors produced by the generated REST client transport layer.

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.

Problem

The server returned a structured RFC 9457 Problem payload.

Fields

problem: Box<Problem>

The structured RFC 9457 problem payload. Boxed: Problem itself is large enough (several String/Value fields) that an unboxed copy here would make TransportError — and therefore every Result<_, TransportError> return type across the crate — bloat past clippy’s result_large_err threshold.

retry_after: Option<Duration>

Server-advised minimum wait before retry, parsed from the Retry-After response header (delta-seconds), when present. Carried alongside the Problem so in-mesh peers that speak canonical errors still get their advised backoff honored by the retry loop.

HttpStatus

The server returned a non-success status with a non-Problem body.

Fields

status: u16

Numeric HTTP status code.

body: String

Body excerpt suitable for diagnostics. Truncated at the call site.

retry_after: Option<Duration>

Server-advised minimum wait before retry, parsed from the Retry-After response header (delta-seconds), when present. The retry loop honors this in preference to computed backoff.

Grpc

The gRPC server returned a non-OK status. Preserves the original tonic::Code so callers can map it back to canonical categories without losing information through an HTTP-status detour.

Fields

code: Code

The raw gRPC status code as returned by the server.

message: String

Human-readable detail copied from tonic::Status::message.

Network(Box<dyn Error + Sync + Send>)

Low-level network failure (DNS, connect, TLS, mid-flight reset).

Timeout(Duration)

The total deadline elapsed before the response was complete.

Serialization(Box<dyn Error + Sync + Send>)

Request or response (de)serialization failure.

Sse(Box<dyn Error + Sync + Send>)

Server-Sent Events stream error (frame parse, malformed event, etc.).

UrlBuild(String)

URL construction error (missing path parameter, invalid template).

Unresolved

The providing gear could not be resolved to a live endpoint via the service directory: it has not registered yet, or every instance was evicted (e.g., the provider pod went away). Treated as transient — the directory-resolving client re-resolves on the next call and recovers once a live instance reappears.

Fields

gear: String

Logical gear name that could not be resolved to an endpoint.

Implementations

impl TransportError

pub fn network<E>(err: E) -> TransportError

where E: Into<Box<dyn Error + Sync + Send>>,

Convenience constructor for TransportError::Network from any boxable error. Preserves the source via Error::source().

pub fn serialization<E>(err: E) -> TransportError

where E: Into<Box<dyn Error + Sync + Send>>,

Convenience constructor for TransportError::Serialization from any boxable error. Preserves the source via Error::source().

pub fn sse<E>(err: E) -> TransportError

where E: Into<Box<dyn Error + Sync + Send>>,

Convenience constructor for TransportError::Sse from any boxable error. Preserves the source via Error::source().

pub fn unresolved(gear: impl Into<String>) -> TransportError

Convenience constructor for TransportError::Unresolved.

pub fn problem(problem: Problem) -> TransportError

Convenience constructor for TransportError::Problem with no server-advised Retry-After.

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

Server-advised retry delay (Retry-After), when the error carries one.

Carried by both TransportError::HttpStatus (non-Problem peers) and TransportError::Problem (canonical-error peers), parsed from the response header. Returns None for all other error classes.

pub fn is_transient(&self) -> bool

Whether this error class is generally safe to retry without a higher-level idempotency strategy. Used by crate::runtime::retry when a method is declared #[retryable].

Trait Implementations

impl Debug for TransportError

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

Formats the value using the given formatter.

impl Display for TransportError

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

Formats the value using the given formatter.

impl Error for TransportError

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<TransportError> for CanonicalError

fn from(err: TransportError) -> CanonicalError

Converts to this type from the input type.