Enum StorageFailure 

pub enum StorageFailure {
    ProviderUnavailable,
    AccessNotRegistered {
        required: OAuthAccess,
    },
    AccessNotGranted {
        required: OAuthAccess,
    },
    DropboxAppFolderNotShareable,
    CatchUpRequired,
    Network,
    Corrupted,
    Authentication,
    PermissionDenied,
    NotFound,
    AlreadyExists,
    Conflict,
    ContainerNotFound,
    RegionMismatch,
    StoreExists,
    ClockSkew,
    OwnLocationRequired,
    QuotaExceeded,
    RateLimited,
    InvalidConfiguration,
    Refused,
    Protocol,
    InvalidPath,
    InvalidRange,
    NotStoreOwner,
    InviteeIsStoreOwner,
    SharingRefused(SharingRefusal),
    AccountIdUnavailable,
    InvitationMismatch,
    SessionMismatch,
    SessionExpired,
    SessionIdentityUnknown,
    InvalidPart,
    SingleRequestTooLarge {
        size: u64,
        limit: u64,
    },
    CopyTooLarge {
        size: u64,
        limit: u64,
    },
    Encoding,
    File,
    MemberKeysMissing,
    Bug,
}

Failures the app can distinguish and act on (Appendix F.5).

Variants

ProviderUnavailable

The platform or OS version cannot use this built-in provider.

AccessNotRegistered

The app did not register the access required by this operation.

Fields

required: OAuthAccess

Access the app must register before this operation is available.

AccessNotGranted

The authorization did not grant the required access.

Fields

required: OAuthAccess

Access the account must authorize.

DropboxAppFolderNotShareable

An App-folder store cannot be shared without relocating it.

CatchUpRequired

The installation must complete membership and key-copy catch-up before sending.

Network

No route to the provider, a timeout, an interrupted response, or a server failure the provider answered with (§6.7).

Corrupted

Two complete reads of one immutable object returned different bytes: a fault on the way to the device changed one of them (§19.1).

Authentication

Credentials were refused or must be refreshed.

PermissionDenied

The account is signed in but cannot perform this operation.

NotFound

The requested object is absent.

AlreadyExists

A create-once path is occupied.

Conflict

A concurrent storage mutation defeated a conditional request.

ContainerNotFound

The bucket, folder or zone is absent.

RegionMismatch

The S3 endpoint or signing region is wrong.

StoreExists

Setting up a store that never had storage found another installation’s creation slot: another installation of the store claimed this location first (§10.3). Restore or join it instead.

ClockSkew

S3 rejected the device clock after one retry with the offset its response stated (§20.7).

OwnLocationRequired

Every member reaches the whole location (a Dropbox shared folder, a OneDrive folder, or an S3 bucket), so a store there needs it to itself, and it holds something besides this store (§20.3). At first setup: an object or folder outside the store’s own, or a location marker that doesn’t name it. At a reconnect, restore or join: a marker that is missing, malformed or names another store.

QuotaExceeded

The provider has no space left.

RateLimited

The provider requests a later retry.

InvalidConfiguration

The request’s configuration is invalid.

Refused

The provider refused the request for another reason.

Protocol

The response or recorded session is malformed.

InvalidPath

An object path is outside the store’s layout.

InvalidRange

A range is empty, reversed or beyond the object’s end.

NotStoreOwner

Coven changes sharing only from the account holding the store. That is coven’s rule, not every provider’s limit (§13.2).

InviteeIsStoreOwner

The invited account is the one holding the store (§13.2).

SharingRefused(SharingRefusal)

The provider refused to share the store for a reason only a person can fix, the invited address’s or the inviting account’s, so no retry changes the answer (§13.2).

AccountIdUnavailable

Dropbox cannot upgrade a pending viewer without the recipient’s account id.

InvitationMismatch

The invite belongs to another provider location.

SessionMismatch

The session belongs to another provider or location.

SessionExpired

The recorded upload expired or a publication conflict invalidated it.

SessionIdentityUnknown

The native id of an unresolved S3 initiation cannot be proven to belong to this session.

InvalidPart

A part disagrees with the session’s offset, size or alignment.

SingleRequestTooLarge

A buffered floor replacement exceeds this provider’s single-request limit. Recorded replacements use Storage::begin_replace instead.

Fields

size: u64

Encrypted body length in bytes.

limit: u64

The adapter’s single-request limit in bytes.

CopyTooLarge

An S3 object published by CopyObject exceeds its single-copy limit, so this profile refuses it (§20.6 says why).

Fields

size: u64

Encrypted body length in bytes.

limit: u64

The single-copy limit in bytes.

Encoding

Parsing recorded provider data failed.

File

Local file access or persisting provider settings or upload progress failed.

MemberKeysMissing

This installation has no member keys in custody.

Bug

Coven’s work for the request panicked: a bug, which the caller reports (E15). StorageError::Bug carries it.

Implementations

impl StorageFailure

pub fn with_source( self, source: impl Into<Box<dyn Error + Send + Sync>>, ) -> StorageError

Retain the diagnostic or native cause alongside this classification.

Trait Implementations

impl Clone for StorageFailure

fn clone(&self) -> StorageFailure

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StorageFailure

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StorageFailure

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<StorageFailure> for StorageError

fn from(failure: StorageFailure) -> Self

Converts to this type from the input type.

impl PartialEq for StorageFailure

fn eq(&self, other: &StorageFailure) -> 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 StorageFailure

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for StorageFailure

impl Eq for StorageFailure

impl StructuralPartialEq for StorageFailure