Enum Error 

#[non_exhaustive]
pub enum Error {
    GuardNotUsable(UniqId),
    PendingCanceled,
    PendingFailed(Box<Error>),
    LostUsabilityRace(RestrictionFailed),
    CircCanceled,
    UsageMismatched(RestrictionFailed),
    CircTimeout(Option<UniqId>),
    RequestTimeout,
    NoRelay {
        path_kind: &'static str,
        role: &'static str,
        problem: String,
    },
    GuardMgr(GuardMgrError),
    Guard(PickGuardError),
    RequestFailed(RetryError<Box<Error>>),
    Channel {
        peer: LoggedChanTarget,
        cause: Error,
    },
    Protocol {
        action: &'static str,
        peer: Option<LoggedChanTarget>,
        error: Error,
        unique_id: Option<UniqId>,
    },
    Spawn {
        spawning: &'static str,
        cause: Arc<SpawnError>,
    },
    State(Error),
    Bug(Bug),
}

An error returned while looking up or building a circuit

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.

GuardNotUsable(UniqId)

We started building a circuit on a guard, but later decided not to use that guard.

PendingCanceled

We were waiting on a pending circuit, but it failed to report

PendingFailed(Box<Error>)

We were waiting on a pending circuit, but it failed.

LostUsabilityRace(RestrictionFailed)

We were told that we could use a given circuit, but before we got a chance to try it, its usage changed so that we had no longer find it suitable.

This is a version of UsageMismatched for when a race is the likeliest explanation for the mismatch.

CircCanceled

A circuit succeeded, but was cancelled before it could be used.

Circuits can be cancelled either by a call to retire_all_circuits(), or by a configuration change that makes old paths unusable.

UsageMismatched(RestrictionFailed)

We were told that we could use a circuit, but when we tried, we found that its usage did not support what we wanted.

This can happen due to a race when a number of tasks all decide that they can use the same pending circuit at once: one of them will restrict the circuit, and the others will get this error.

See LostUsabilityRace.

CircTimeout(Option<UniqId>)

A circuit build took too long to finish.

RequestTimeout

A request spent too long waiting for a circuit

NoRelay

Unable to find a relay in order to build a given path type.

Fields

path_kind: &'static str

The kind of path we were trying to build

role: &'static str

The kind of relay we were trying to pick

problem: String

The problem we encountered

GuardMgr(GuardMgrError)

Problem creating or updating a guard manager.

Guard(PickGuardError)

Problem selecting a guard relay.

RequestFailed(RetryError<Box<Error>>)

Unable to get or build a circuit, despite retrying.

Channel

Problem with channel

Fields

peer: LoggedChanTarget

Which relay we were trying to connect to

cause: Error

What went wrong

Protocol

Protocol issue while building a circuit.

Fields

action: &'static str

The action that we were trying to take.

peer: Option<LoggedChanTarget>

The peer that created the protocol error.

This is set to None if we can’t blame a single party.

error: Error

The underlying error.

unique_id: Option<UniqId>

The UniqId of the circuit.

Spawn

Unable to spawn task

Fields

spawning: &'static str

What we were trying to spawn

cause: Arc<SpawnError>

What happened when we tried to spawn it.

State(Error)

Problem loading or storing persistent state.

Bug(Bug)

An error caused by a programming issue . or a failure in another library that we can’t work around.

Implementations

impl Error

pub fn peers(&self) -> Vec<&OwnedChanTarget>

Return a list of the peers to “blame” for this error, if there are any.

pub fn summarized_error_kind<'a, I>(errs: I) -> ErrorKind

where I: Iterator<Item = &'a Error>,

Given an iterator of errors that have occurred while attempting a single failed operation, return the ErrorKind for the entire attempt.

Trait Implementations

impl AsRef<dyn Error> for Box<Error>

fn as_ref(&self) -> &(dyn Error + 'static)

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<dyn Error> for Error

fn as_ref(&self) -> &(dyn Error + 'static)

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Error

fn clone(&self) -> Error

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<Bug> for Error

fn from(source: Bug) -> Self

Converts to this type from the input type.

impl From<Canceled> for Error

fn from(_: Canceled) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<GuardMgrError> for Error

fn from(err: GuardMgrError) -> Error

Converts to this type from the input type.

impl From<PickGuardError> for Error

fn from(source: PickGuardError) -> Self

Converts to this type from the input type.

impl HasKind for Error

fn kind(&self) -> ErrorKind

Return the kind of this error.

impl HasRetryTime for Error

fn retry_time(&self) -> RetryTime

Return the time when the operation that gave this error can be retried.

fn abs_retry_time<F>(&self, now: Instant, choose_delay: F) -> AbsRetryTime

where F: FnOnce() -> Duration,

Return an absolute retry when the operation that gave this error can be retried.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 144 bytes

Size for each variant:

• GuardNotUsable: 16 bytes
• PendingCanceled: 0 bytes
• PendingFailed: 8 bytes
• LostUsabilityRace: 0 bytes
• CircCanceled: 0 bytes
• UsageMismatched: 0 bytes
• CircTimeout: 24 bytes
• RequestTimeout: 0 bytes
• NoRelay: 56 bytes
• GuardMgr: 136 bytes
• Guard: 80 bytes
• RequestFailed: 56 bytes
• Channel: 104 bytes
• Protocol: 112 bytes
• Spawn: 24 bytes
• State: 136 bytes
• Bug: 8 bytes