Enum AuthorityError 

#[non_exhaustive]
pub enum AuthorityError {
    Unknown(AuthorityId),
    Exhausted {
        authority: AuthorityId,
        asked: Spend,
        remaining: Spend,
    },
    DrawsSpent {
        authority: AuthorityId,
        allowed: u32,
    },
    Revoked {
        authority: AuthorityId,
        reason: String,
    },
    Expired {
        authority: AuthorityId,
        expired_at: Timestamp,
    },
    NotHolder {
        authority: AuthorityId,
        holder: Holder,
        drawer: String,
    },
    Malformed(&'static str),
    AlreadyIssued(AuthorityId),
    Unavailable(String),
}

Why a draw was refused.

Each variant is a different instruction to the caller, which is the whole reason they are not one error with a message: exhausted and revoked look identical in prose and mean opposite things about whether to try again.

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.

Unknown(AuthorityId)

No such authority for this tenant.

Exhausted

The draw would exceed what was authorized.

Reports the whole arithmetic rather than a bare refusal: an operator reconciling this needs to know what was asked against what was left.

Fields

authority: AuthorityId

asked: Spend

remaining: Spend

DrawsSpent

It permitted a number of draws and they are used up.

Fields

authority: AuthorityId

allowed: u32

Revoked

Somebody withdrew it.

Not retryable, ever. Distinct from Exhausted because that one could in principle be followed by a larger authority, while this one is a decision that has been taken back.

Fields

authority: AuthorityId

reason: String

Expired

It ran out of time rather than out of ceiling.

Fields

authority: AuthorityId

expired_at: Timestamp

NotHolder

The run drawing is not the one the authority was issued to.

Not retryable, and distinct from Unknown because the fix is different: the id is right and the caller is wrong.

Fields

authority: AuthorityId

holder: Holder

drawer: String

Whom the drawing run acts for, or nobody for a served caller that presented no chain.

Malformed(&'static str)

The declaration itself is not well formed.

AlreadyIssued(AuthorityId)

Re-issuing an id under a different declaration.

Refused rather than overwritten: an id that can be redefined makes every draw already recorded against it refer to terms nobody can reconstruct. Re-issuing the identical declaration succeeds, because a retried deployment is not an attack.

Unavailable(String)

The store could not be reached.

Trait Implementations

impl Clone for AuthorityError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AuthorityError

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

Formats the value using the given formatter.

impl Display for AuthorityError

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

Formats the value using the given formatter.

impl Eq for AuthorityError

impl Error for AuthorityError

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<StoreError> for AuthorityError

fn from(e: StoreError) -> Self

Converts to this type from the input type.

impl PartialEq for AuthorityError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AuthorityError