lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

error.rs (21774B)


      1 //! Stable, secret-safe storage failures.
      2 
      3 use core::fmt;
      4 
      5 /// Backend-neutral storage failure.
      6 #[non_exhaustive]
      7 #[derive(Clone, Debug, Eq, PartialEq)]
      8 pub enum Error {
      9     InvalidAuthoredOperation,
     10     InvalidAuthoredArtifact,
     11     InvalidAuthoredTransition,
     12     InvalidAuthoredDeliveryPlan,
     13     InvalidAuthoredDraft,
     14     DraftRevisionConflict,
     15     DraftNotFound,
     16     CorruptAuthoredDraft,
     17     DeliveryPlanClaimConflict,
     18     DeliveryAttemptOverflow,
     19     InvalidWorkClaim,
     20     InvalidWorkFailure,
     21     InvalidRetrySchedule,
     22     InvalidSourceGeneration,
     23     InvalidEventSequence,
     24     InvalidEventQueryLimit,
     25     InvalidVisibilityIndexBounds,
     26     EmptyEventQueryIds,
     27     TooManyEventQueryIds,
     28     DuplicateEventQueryId,
     29     AdmissionEventMismatch,
     30     AdmissionRegression,
     31     EventConflict,
     32     /// The canonical semantic epoch cannot advance; the mutation is rolled back.
     33     EventMutationOverflow,
     34     EventPageLimitExceeded,
     35     CursorGenerationMismatch,
     36     SourceGenerationChanged,
     37     /// The requested semantic fence no longer matches canonical truth.
     38     SourceEpochChanged,
     39     /// Canonical visibility requires explicit bounded maintenance.
     40     VisibilityRebuilding,
     41     EventNotFound,
     42     CorruptStoredEvent,
     43     BackendUnavailable,
     44     /// Capacity is exhausted; reconcile prior effects before retrying the same operation.
     45     SpaceInsufficient,
     46     InvalidOperationInstanceId,
     47     InvalidIdempotencyKey,
     48     InvalidOperationTimestamp,
     49     InvalidJournalRevision,
     50     InvalidRecoveryAttempt,
     51     InvalidRecoveryDeadline,
     52     InvalidJournalQueryLimit,
     53     IdempotencyConflict,
     54     OperationNotFound,
     55     OperationIdentityMismatch,
     56     JournalRevisionConflict,
     57     InvalidJournalTransition,
     58     JournalOperationCommitted,
     59     CorruptJournalRecord,
     60     InvalidOutboxItemId,
     61     InvalidOutboxRevision,
     62     InvalidOutboxTimestamp,
     63     InvalidOutboxLease,
     64     InvalidOutboxLeaseOwner,
     65     InvalidOutboxClaimLimit,
     66     InvalidDeliveryAttempt,
     67     InvalidDeliveryEvidence,
     68     OutboxItemNotFound,
     69     OutboxItemNotReady,
     70     OutboxItemTerminal,
     71     OutboxPlanConflict,
     72     OutboxLeaseConflict,
     73     OutboxLeaseExpired,
     74     OutboxRevisionConflict,
     75     CorruptOutboxRecord,
     76     InvalidProjectionId,
     77     InvalidProjectionGeneration,
     78     InvalidProjectionRevision,
     79     InvalidProjectionTimestamp,
     80     InvalidProjectionInvalidation,
     81     ProjectionCheckpointMismatch,
     82     ProjectionCheckpointRegression,
     83     ProjectionRevisionConflict,
     84     InvalidRebuildTicketId,
     85     InvalidRebuildTransition,
     86     RebuildTicketTerminal,
     87     InvalidEventIndexShardId,
     88     InvalidEventIndexRange,
     89     InvalidEventIndexArtifactPath,
     90     InvalidEventIndexShardCount,
     91     InvalidEventIndexTimestamp,
     92     InvalidEventIndexManifest,
     93     InvalidEventIndexCursor,
     94     InvalidEventIndexCheckpoint,
     95     DuplicateEventIndexShard,
     96     CorruptProjectionRecord,
     97     InvalidProjectionCacheLimits,
     98     InvalidProjectionDocument,
     99     InvalidProjectionSnapshot,
    100     CorruptProjectionDocument,
    101     InvalidPrivateArtifactId,
    102     InvalidPrivateArtifactKind,
    103     InvalidPrivateArtifactSchema,
    104     InvalidPrivateArtifactSecretReference,
    105     InvalidPrivateArtifactRetention,
    106     InvalidPrivateArtifactRevision,
    107     InvalidPrivateArtifactResealId,
    108     InvalidPrivateArtifactResealRequest,
    109     InvalidPrivateArtifactTimestamp,
    110     InvalidPrivateArtifactMetadata,
    111     PrivateArtifactNotFound,
    112     PrivateArtifactConflict,
    113     PrivateArtifactRevisionConflict,
    114     PrivateArtifactResealConflict,
    115     PrivateArtifactPersistenceIndeterminate,
    116     PrivateArtifactRetentionActive,
    117     PrivateArtifactNotExpired,
    118     PrivateArtifactTombstoned,
    119     InvalidExpiredArtifactQueryLimit,
    120     CorruptPrivateArtifactMetadata,
    121     InvalidBackupId,
    122     InvalidBackupVersion,
    123     InvalidBackupTimestamp,
    124     InvalidBackupMemberPath,
    125     InvalidBackupMemberLength,
    126     InvalidBackupManifest,
    127     DuplicateBackupMember,
    128     BackupSecretPolicyViolation,
    129     BackupManifestPlanMismatch,
    130     InvalidBackupTransition,
    131     InvalidRestoreTimestamp,
    132     InvalidRestoreTransition,
    133     RestoreMemberVerificationFailed,
    134     InvalidReliabilityRevision,
    135     ReliabilityRevisionConflict,
    136     ReliabilityOperationTerminal,
    137     CorruptReliabilityOperation,
    138     InvalidIntegrityStatus,
    139     InvalidStorageStatus,
    140     InvalidAtomicCommitId,
    141     InvalidAtomicCommitTimestamp,
    142     AtomicCommitConflict,
    143     AtomicWorkflowMismatch,
    144     AtomicCommitFailed,
    145 }
    146 
    147 impl fmt::Display for Error {
    148     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    149         formatter.write_str(match self {
    150             Self::InvalidAuthoredOperation => "storage authored operation is invalid",
    151             Self::InvalidAuthoredArtifact => "storage authored artifact is invalid",
    152             Self::InvalidAuthoredTransition => "storage authored transition is invalid",
    153             Self::InvalidAuthoredDeliveryPlan => "storage authored delivery plan is invalid",
    154             Self::InvalidAuthoredDraft => "storage authored draft is invalid",
    155             Self::DraftRevisionConflict => "storage authored draft revision conflicts",
    156             Self::DraftNotFound => "storage authored draft was not found",
    157             Self::CorruptAuthoredDraft => "storage authored draft is corrupt",
    158             Self::DeliveryPlanClaimConflict => "storage delivery plan claim conflicts",
    159             Self::DeliveryAttemptOverflow => "storage delivery attempt counter overflowed",
    160             Self::InvalidWorkClaim => "storage authored work claim is invalid",
    161             Self::InvalidWorkFailure => "storage authored work failure is invalid",
    162             Self::InvalidRetrySchedule => "storage authored retry schedule is invalid",
    163             Self::InvalidSourceGeneration => "storage source generation is invalid",
    164             Self::InvalidEventSequence => "storage event sequence is invalid",
    165             Self::EventMutationOverflow => "storage event mutation epoch overflowed",
    166             Self::InvalidEventQueryLimit => "storage event query limit is invalid",
    167             Self::InvalidVisibilityIndexBounds => "storage visibility index bounds are invalid",
    168             Self::EmptyEventQueryIds => "storage event id query is empty",
    169             Self::TooManyEventQueryIds => "storage event id query exceeds its limit",
    170             Self::DuplicateEventQueryId => "storage event id query contains a duplicate",
    171             Self::AdmissionEventMismatch => "storage admission event identities do not match",
    172             Self::AdmissionRegression => "storage admission cannot regress event state",
    173             Self::EventConflict => "storage contains conflicting data for the event id",
    174             Self::EventPageLimitExceeded => "storage event page exceeds its requested limit",
    175             Self::CursorGenerationMismatch => "storage cursor belongs to another source generation",
    176             Self::SourceGenerationChanged => "storage source generation changed",
    177             Self::SourceEpochChanged => "storage source epoch changed",
    178             Self::VisibilityRebuilding => "storage visibility is rebuilding",
    179             Self::EventNotFound => "storage event was not found",
    180             Self::CorruptStoredEvent => "storage event data is corrupt",
    181             Self::BackendUnavailable => "storage backend is unavailable",
    182             Self::SpaceInsufficient => "storage space is insufficient",
    183             Self::InvalidOperationInstanceId => "storage operation instance id is invalid",
    184             Self::InvalidIdempotencyKey => "storage idempotency key is invalid",
    185             Self::InvalidOperationTimestamp => "storage operation timestamp is invalid",
    186             Self::InvalidJournalRevision => "storage journal revision is invalid",
    187             Self::InvalidRecoveryAttempt => "storage recovery attempt is invalid",
    188             Self::InvalidRecoveryDeadline => "storage recovery deadline is invalid",
    189             Self::InvalidJournalQueryLimit => "storage journal query limit is invalid",
    190             Self::IdempotencyConflict => "storage idempotency key conflicts with prior input",
    191             Self::OperationNotFound => "storage journal operation was not found",
    192             Self::OperationIdentityMismatch => "storage journal operation identity does not match",
    193             Self::JournalRevisionConflict => {
    194                 "storage journal revision conflicts with durable state"
    195             }
    196             Self::InvalidJournalTransition => "storage journal transition is invalid",
    197             Self::JournalOperationCommitted => "storage journal operation is already committed",
    198             Self::CorruptJournalRecord => "storage journal record is corrupt",
    199             Self::InvalidOutboxItemId => "storage outbox item id is invalid",
    200             Self::InvalidOutboxRevision => "storage outbox revision is invalid",
    201             Self::InvalidOutboxTimestamp => "storage outbox timestamp is invalid",
    202             Self::InvalidOutboxLease => "storage outbox lease is invalid",
    203             Self::InvalidOutboxLeaseOwner => "storage outbox lease owner is invalid",
    204             Self::InvalidOutboxClaimLimit => "storage outbox claim limit is invalid",
    205             Self::InvalidDeliveryAttempt => "storage delivery attempt is invalid",
    206             Self::InvalidDeliveryEvidence => "storage delivery evidence is invalid",
    207             Self::OutboxItemNotFound => "storage outbox item was not found",
    208             Self::OutboxItemNotReady => "storage outbox item is not ready",
    209             Self::OutboxItemTerminal => "storage outbox item is terminal",
    210             Self::OutboxPlanConflict => "storage outbox plan conflicts with durable state",
    211             Self::OutboxLeaseConflict => "storage outbox lease conflicts with durable state",
    212             Self::OutboxLeaseExpired => "storage outbox lease expired",
    213             Self::OutboxRevisionConflict => "storage outbox revision conflicts with durable state",
    214             Self::CorruptOutboxRecord => "storage outbox record is corrupt",
    215             Self::InvalidProjectionId => "storage projection id is invalid",
    216             Self::InvalidProjectionGeneration => "storage projection generation is invalid",
    217             Self::InvalidProjectionRevision => "storage projection revision is invalid",
    218             Self::InvalidProjectionTimestamp => "storage projection timestamp is invalid",
    219             Self::InvalidProjectionInvalidation => "storage projection invalidation is invalid",
    220             Self::ProjectionCheckpointMismatch => {
    221                 "storage projection checkpoint identity does not match"
    222             }
    223             Self::ProjectionCheckpointRegression => "storage projection checkpoint regressed",
    224             Self::ProjectionRevisionConflict => {
    225                 "storage projection revision conflicts with durable state"
    226             }
    227             Self::InvalidRebuildTicketId => "storage projection rebuild ticket id is invalid",
    228             Self::InvalidRebuildTransition => "storage projection rebuild transition is invalid",
    229             Self::RebuildTicketTerminal => "storage projection rebuild ticket is terminal",
    230             Self::InvalidEventIndexShardId => "storage event-index shard id is invalid",
    231             Self::InvalidEventIndexRange => "storage event-index id range is invalid",
    232             Self::InvalidEventIndexArtifactPath => "storage event-index artifact path is invalid",
    233             Self::InvalidEventIndexShardCount => "storage event-index shard count is invalid",
    234             Self::InvalidEventIndexTimestamp => "storage event-index timestamp is invalid",
    235             Self::InvalidEventIndexManifest => "storage event-index manifest is invalid",
    236             Self::InvalidEventIndexCursor => "storage event-index cursor is invalid",
    237             Self::InvalidEventIndexCheckpoint => "storage event-index checkpoint is invalid",
    238             Self::DuplicateEventIndexShard => "storage event-index shard is duplicated",
    239             Self::CorruptProjectionRecord => "storage projection record is corrupt",
    240             Self::InvalidProjectionCacheLimits => "storage projection cache limits are invalid",
    241             Self::InvalidProjectionDocument => "storage projection document is invalid",
    242             Self::InvalidProjectionSnapshot => "storage projection snapshot is invalid",
    243             Self::CorruptProjectionDocument => "storage projection document is corrupt",
    244             Self::InvalidPrivateArtifactId => "storage private-artifact id is invalid",
    245             Self::InvalidPrivateArtifactKind => "storage private-artifact kind is invalid",
    246             Self::InvalidPrivateArtifactSchema => "storage private-artifact schema is invalid",
    247             Self::InvalidPrivateArtifactSecretReference => {
    248                 "storage private-artifact secret reference is invalid"
    249             }
    250             Self::InvalidPrivateArtifactRetention => {
    251                 "storage private-artifact retention is invalid"
    252             }
    253             Self::InvalidPrivateArtifactRevision => "storage private-artifact revision is invalid",
    254             Self::InvalidPrivateArtifactResealId => "storage private-artifact reseal id is invalid",
    255             Self::InvalidPrivateArtifactResealRequest => {
    256                 "storage private-artifact reseal request is invalid"
    257             }
    258             Self::InvalidPrivateArtifactTimestamp => {
    259                 "storage private-artifact timestamp is invalid"
    260             }
    261             Self::InvalidPrivateArtifactMetadata => "storage private-artifact metadata is invalid",
    262             Self::PrivateArtifactNotFound => "storage private artifact was not found",
    263             Self::PrivateArtifactConflict => {
    264                 "storage private-artifact metadata conflicts with durable state"
    265             }
    266             Self::PrivateArtifactRevisionConflict => {
    267                 "storage private-artifact revision conflicts with durable state"
    268             }
    269             Self::PrivateArtifactResealConflict => {
    270                 "storage private-artifact reseal conflicts with durable state"
    271             }
    272             Self::PrivateArtifactPersistenceIndeterminate => {
    273                 "storage private-artifact persistence outcome is indeterminate"
    274             }
    275             Self::PrivateArtifactRetentionActive => "storage private-artifact retention is active",
    276             Self::PrivateArtifactNotExpired => "storage private artifact has not expired",
    277             Self::PrivateArtifactTombstoned => "storage private artifact is tombstoned",
    278             Self::InvalidExpiredArtifactQueryLimit => {
    279                 "storage expired-artifact query limit is invalid"
    280             }
    281             Self::CorruptPrivateArtifactMetadata => "storage private-artifact metadata is corrupt",
    282             Self::InvalidBackupId => "storage backup id is invalid",
    283             Self::InvalidBackupVersion => "storage backup version is invalid",
    284             Self::InvalidBackupTimestamp => "storage backup timestamp is invalid",
    285             Self::InvalidBackupMemberPath => "storage backup member path is invalid",
    286             Self::InvalidBackupMemberLength => "storage backup member length is invalid",
    287             Self::InvalidBackupManifest => "storage backup manifest is invalid",
    288             Self::DuplicateBackupMember => "storage backup member is duplicated",
    289             Self::BackupSecretPolicyViolation => "storage backup secret policy was violated",
    290             Self::BackupManifestPlanMismatch => "storage backup manifest does not match its plan",
    291             Self::InvalidBackupTransition => "storage backup transition is invalid",
    292             Self::InvalidRestoreTimestamp => "storage restore timestamp is invalid",
    293             Self::InvalidRestoreTransition => "storage restore transition is invalid",
    294             Self::RestoreMemberVerificationFailed => "storage restore member verification failed",
    295             Self::InvalidReliabilityRevision => "storage reliability revision is invalid",
    296             Self::ReliabilityRevisionConflict => {
    297                 "storage reliability revision conflicts with durable state"
    298             }
    299             Self::ReliabilityOperationTerminal => "storage reliability operation is terminal",
    300             Self::CorruptReliabilityOperation => "storage reliability operation is corrupt",
    301             Self::InvalidIntegrityStatus => "storage integrity status is invalid",
    302             Self::InvalidStorageStatus => "storage status is invalid",
    303             Self::InvalidAtomicCommitId => "storage atomic commit id is invalid",
    304             Self::InvalidAtomicCommitTimestamp => "storage atomic commit timestamp is invalid",
    305             Self::AtomicCommitConflict => "storage atomic commit conflicts with durable state",
    306             Self::AtomicWorkflowMismatch => "storage atomic workflow components do not match",
    307             Self::AtomicCommitFailed => "storage atomic workflow did not commit",
    308         })
    309     }
    310 }
    311 
    312 impl std::error::Error for Error {}
    313 
    314 #[cfg(test)]
    315 mod tests {
    316     use super::Error::*;
    317 
    318     #[test]
    319     fn every_storage_error_has_a_stable_nonempty_message() {
    320         let errors = [
    321             InvalidAuthoredOperation,
    322             InvalidAuthoredArtifact,
    323             InvalidAuthoredTransition,
    324             InvalidAuthoredDeliveryPlan,
    325             DeliveryPlanClaimConflict,
    326             DeliveryAttemptOverflow,
    327             InvalidWorkClaim,
    328             InvalidWorkFailure,
    329             InvalidRetrySchedule,
    330             InvalidSourceGeneration,
    331             InvalidEventSequence,
    332             InvalidEventQueryLimit,
    333             EmptyEventQueryIds,
    334             TooManyEventQueryIds,
    335             DuplicateEventQueryId,
    336             AdmissionEventMismatch,
    337             AdmissionRegression,
    338             EventConflict,
    339             EventPageLimitExceeded,
    340             CursorGenerationMismatch,
    341             SourceGenerationChanged,
    342             SourceEpochChanged,
    343             VisibilityRebuilding,
    344             EventNotFound,
    345             CorruptStoredEvent,
    346             BackendUnavailable,
    347             SpaceInsufficient,
    348             InvalidOperationInstanceId,
    349             InvalidIdempotencyKey,
    350             InvalidOperationTimestamp,
    351             InvalidJournalRevision,
    352             InvalidRecoveryAttempt,
    353             InvalidRecoveryDeadline,
    354             InvalidJournalQueryLimit,
    355             IdempotencyConflict,
    356             OperationNotFound,
    357             OperationIdentityMismatch,
    358             JournalRevisionConflict,
    359             InvalidJournalTransition,
    360             JournalOperationCommitted,
    361             CorruptJournalRecord,
    362             InvalidOutboxItemId,
    363             InvalidOutboxRevision,
    364             InvalidOutboxTimestamp,
    365             InvalidOutboxLease,
    366             InvalidOutboxLeaseOwner,
    367             InvalidOutboxClaimLimit,
    368             InvalidDeliveryAttempt,
    369             InvalidDeliveryEvidence,
    370             OutboxItemNotFound,
    371             OutboxItemNotReady,
    372             OutboxItemTerminal,
    373             OutboxPlanConflict,
    374             OutboxLeaseConflict,
    375             OutboxLeaseExpired,
    376             OutboxRevisionConflict,
    377             CorruptOutboxRecord,
    378             InvalidProjectionId,
    379             InvalidProjectionGeneration,
    380             InvalidProjectionRevision,
    381             InvalidProjectionTimestamp,
    382             InvalidProjectionInvalidation,
    383             ProjectionCheckpointMismatch,
    384             ProjectionCheckpointRegression,
    385             ProjectionRevisionConflict,
    386             InvalidRebuildTicketId,
    387             InvalidRebuildTransition,
    388             RebuildTicketTerminal,
    389             InvalidEventIndexShardId,
    390             InvalidEventIndexRange,
    391             InvalidEventIndexArtifactPath,
    392             InvalidEventIndexShardCount,
    393             InvalidEventIndexTimestamp,
    394             InvalidEventIndexManifest,
    395             InvalidEventIndexCursor,
    396             InvalidEventIndexCheckpoint,
    397             DuplicateEventIndexShard,
    398             CorruptProjectionRecord,
    399             InvalidProjectionCacheLimits,
    400             InvalidProjectionDocument,
    401             InvalidProjectionSnapshot,
    402             CorruptProjectionDocument,
    403             InvalidPrivateArtifactId,
    404             InvalidPrivateArtifactKind,
    405             InvalidPrivateArtifactSchema,
    406             InvalidPrivateArtifactSecretReference,
    407             InvalidPrivateArtifactRetention,
    408             InvalidPrivateArtifactRevision,
    409             InvalidPrivateArtifactResealId,
    410             InvalidPrivateArtifactResealRequest,
    411             InvalidPrivateArtifactTimestamp,
    412             InvalidPrivateArtifactMetadata,
    413             PrivateArtifactNotFound,
    414             PrivateArtifactConflict,
    415             PrivateArtifactRevisionConflict,
    416             PrivateArtifactResealConflict,
    417             PrivateArtifactPersistenceIndeterminate,
    418             PrivateArtifactRetentionActive,
    419             PrivateArtifactNotExpired,
    420             PrivateArtifactTombstoned,
    421             InvalidExpiredArtifactQueryLimit,
    422             CorruptPrivateArtifactMetadata,
    423             InvalidBackupId,
    424             InvalidBackupVersion,
    425             InvalidBackupTimestamp,
    426             InvalidBackupMemberPath,
    427             InvalidBackupMemberLength,
    428             InvalidBackupManifest,
    429             DuplicateBackupMember,
    430             BackupSecretPolicyViolation,
    431             BackupManifestPlanMismatch,
    432             InvalidBackupTransition,
    433             InvalidRestoreTimestamp,
    434             InvalidRestoreTransition,
    435             RestoreMemberVerificationFailed,
    436             InvalidReliabilityRevision,
    437             ReliabilityRevisionConflict,
    438             ReliabilityOperationTerminal,
    439             CorruptReliabilityOperation,
    440             InvalidIntegrityStatus,
    441             InvalidStorageStatus,
    442             InvalidAtomicCommitId,
    443             InvalidAtomicCommitTimestamp,
    444             AtomicCommitConflict,
    445             AtomicWorkflowMismatch,
    446             AtomicCommitFailed,
    447         ];
    448         for error in errors {
    449             assert!(!error.to_string().is_empty());
    450         }
    451     }
    452 }