Enum tor_circmgr::Error

#[non_exhaustive]
pub enum Error {
    GuardNotUsable,
    PendingCanceled,
    PendingFailed(Box<Error>),
    LostUsabilityRace(RestrictionFailed),
    CircCanceled,
    UsageMismatched(RestrictionFailed),
    CircTimeout,
    RequestTimeout,
    NoPath {
        role: &'static str,
        can_share: FilterCount,
        correct_usage: FilterCount,
    },
    NoExit {
        can_share: FilterCount,
        correct_ports: FilterCount,
        correct_country: FilterCount,
    },
    GuardMgr(GuardMgrError),
    Guard(PickGuardError),
    RequestFailed(RetryError<Box<Error>>),
    Channel {
        peer: LoggedChanTarget,
        cause: Error,
    },
    Protocol {
        action: &'static str,
        peer: Option<LoggedChanTarget>,
        error: Error,
    },
    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

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 circuits, 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

A circuit build took too long to finish.

RequestTimeout

A request spent too long waiting for a circuit

NoPath

Fields

role: &'static str

The role that we were trying to choose a relay for.

can_share: FilterCount

Relays accepted and rejected based on relay family policies.

correct_usage: FilterCount

Relays accepted and rejected based on our usage requirements.

No suitable relays for a request

NoExit

Fields

can_share: FilterCount

Exit relays accepted and rejected based on relay family policies.

correct_ports: FilterCount

Exit relays accepted and rejected base on the ports that we need.

correct_country: FilterCount

Exit relays accepted and rejected based on exit country code.

No suitable exit relay for a request.

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

Fields

peer: LoggedChanTarget

Which relay we were trying to connect to

cause: Error

What went wrong

Problem with channel

Protocol

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.

Protocol issue while building a circuit.

Spawn

Fields

spawning: &'static str

What we were trying to spawn

cause: Arc<SpawnError>

What happened when we tried to spawn it.

Unable to spawn task

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.

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 copy 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)>

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 From<TimeoutError> for Error

fn from(_: TimeoutError) -> Error

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.