Enum HttpTransportError 

#[non_exhaustive]
pub enum HttpTransportError {
    Timeout,
    Connect(String),
    Io(String),
    InvalidRequest(String),
    ResponseTooLarge {
        actual: usize,
        limit: usize,
    },
    Rejected(String),
}

Why an outbound request did not produce a response.

Transport-level only. A response with a discouraging status code is an Ok(HttpResponse), because only the caller knows what a given status means for its own protocol.

#[non_exhaustive] because a host may distinguish failures this crate has no vocabulary for yet; a caller matching exhaustively today should not break when one is added.

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.

Timeout

The request exceeded its deadline.

Distinct from Self::Connect and Self::Io because callers act on it differently. identity-jwt treats a timed-out JWKS fetch as soft-fail-at-boot rather than a configuration error, and a delegation timeout must map to “unknown” rather than “rejected”, since a token may still have been minted.

Connect(String)

The connection could not be established.

Io(String)

The connection was established but the exchange failed.

InvalidRequest(String)

The request could not be formed — an unparseable URL, an illegal header. Always a bug or a configuration error, never transient.

ResponseTooLarge

The response body exceeded the request’s ceiling. The body is discarded rather than truncated.

Fields

actual: usize

Bytes seen before the read was abandoned.

limit: usize

The ceiling that was exceeded.

Rejected(String)

The host declined to make the request at all.

Egress policy, an SSRF guard, admission control, or an open circuit. Deliberately distinct from Self::Connect: “we declined to try” and “we tried and failed” send an operator to different places, and collapsing them turns a blocked destination into a phantom network problem.

Implementations

impl HttpTransportError

pub fn may_have_reached_peer(&self) -> bool

Whether the peer may have received and acted on the request.

This is the question a caller actually needs, and it is not the same as “should I retry”. Retry safety is idempotency plus this; only the caller knows the first half. A JWKS GET is safe to repeat regardless. An RFC 8693 token exchange is not: repeat one that already landed and the IdP mints a second credential nobody is tracking.

true means unknown, not certain. A timeout cannot distinguish “never arrived” from “arrived, and the response was lost on the way back”, so it answers true and the caller must treat the outcome as indeterminate rather than failed.

This maps onto the effect-log triad a delegating plugin records: false is a clean rejected, true is unknown and wants reconciliation rather than an assumption.

Trait Implementations

impl Clone for HttpTransportError

fn clone(&self) -> HttpTransportError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HttpTransportError

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

Formats the value using the given formatter.

impl Display for HttpTransportError

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

Formats the value using the given formatter.

impl Eq for HttpTransportError

impl Error for HttpTransportError

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<HttpTransportError> for HttpRequestError

fn from(e: HttpTransportError) -> HttpRequestError

Converts to this type from the input type.

impl PartialEq for HttpTransportError

fn eq(&self, other: &HttpTransportError) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for HttpTransportError