Enum OwnershipError 

pub enum OwnershipError {
    SessionNotFound {
        session_id: SessionId,
    },
    AlreadyClaimed {
        session_id: SessionId,
        current_owner_id: FragmentOwnerId,
    },
    Unclaimed {
        session_id: SessionId,
    },
    StaleCapability {
        session_id: SessionId,
        owner_id: FragmentOwnerId,
        expected_generation: OwnershipEpoch,
        actual_generation: OwnershipEpoch,
    },
    ScopeViolation {
        session_id: SessionId,
        owner_id: FragmentOwnerId,
        required: OwnershipScope,
        actual: OwnershipScope,
    },
    TransferPending {
        session_id: SessionId,
        claim_id: OwnershipClaimId,
    },
    TransferNotPending {
        session_id: SessionId,
    },
    ReceiptMismatch {
        session_id: SessionId,
        claim_id: OwnershipClaimId,
    },
    InvalidWitness {
        session_id: SessionId,
        witness_id: AuthorityWitnessId,
        reason: String,
    },
    WitnessConsumed {
        session_id: SessionId,
        witness_id: AuthorityWitnessId,
    },
    Terminal {
        session_id: SessionId,
        reason: OwnershipTerminalReason,
    },
}

Errors surfaced by the runtime ownership contract.

Variants

SessionNotFound

Session was not found.

Fields

session_id: SessionId

Session that was not found.

AlreadyClaimed

Session already has a current owner.

Fields

session_id: SessionId

Session that was already claimed.

current_owner_id: FragmentOwnerId

Owner that already holds the claim.

Unclaimed

Session does not currently have an owner.

Fields

session_id: SessionId

Session that does not currently have an owner.

StaleCapability

Capability generation or owner no longer matches live state.

Fields

session_id: SessionId

Session whose live ownership state rejected the capability.

owner_id: FragmentOwnerId

Owner label carried by the stale capability.

expected_generation: OwnershipEpoch

Generation expected by the caller.

actual_generation: OwnershipEpoch

Generation currently live in the session store.

ScopeViolation

Capability scope is too weak for the attempted operation.

Fields

session_id: SessionId

Session whose scope check failed.

owner_id: FragmentOwnerId

Owner label that attempted the operation.

required: OwnershipScope

Minimum scope required for the operation.

actual: OwnershipScope

Actual live scope carried by the capability.

TransferPending

Another staged ownership transfer already exists.

Fields

session_id: SessionId

Session with an existing staged transfer.

claim_id: OwnershipClaimId

Identifier of the staged transfer.

TransferNotPending

No staged ownership transfer exists.

Fields

session_id: SessionId

Session with no staged transfer.

ReceiptMismatch

Transfer receipt does not match live staged state.

Fields

session_id: SessionId

Session whose staged transfer did not match the receipt.

claim_id: OwnershipClaimId

Identifier carried by the mismatched receipt.

InvalidWitness

Witness does not match current live authority state.

Fields

session_id: SessionId

Session whose witness validation failed.

witness_id: AuthorityWitnessId

Witness that failed validation.

reason: String

Human-readable mismatch reason.

WitnessConsumed

Witness was already consumed.

Fields

session_id: SessionId

Session whose witness was already consumed.

witness_id: AuthorityWitnessId

Witness id that cannot be reused.

Terminal

Ownership already terminated for this session.

Fields

session_id: SessionId

Session whose ownership contract is terminal.

reason: OwnershipTerminalReason

Recorded terminal ownership reason.

Trait Implementations

impl Clone for OwnershipError

fn clone(&self) -> OwnershipError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OwnershipError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OwnershipError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OwnershipError

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OwnershipError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for OwnershipError

impl StructuralPartialEq for OwnershipError