lib

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

error.rs (11762B)


      1 //! Normalized transport contract errors.
      2 
      3 use core::fmt;
      4 
      5 /// Transport contract failure.
      6 #[derive(Clone, Debug, PartialEq, Eq)]
      7 pub enum Error {
      8     TransportClosed,
      9     TransportUnavailable,
     10     UnsupportedOperation,
     11     EmptyTransportKind,
     12     InvalidTransportKind,
     13     EmptyTargetUri,
     14     InvalidTargetUri,
     15     EmptyTargetScope,
     16     InvalidTargetScope,
     17     EmptyTargetLabel,
     18     InvalidTargetLabel,
     19     EmptyTargetSet,
     20     TargetSetTooLarge,
     21     DuplicateTargetFingerprint,
     22     InvalidTargetFingerprint,
     23     EmptyFetchRequestId,
     24     InvalidFetchRequestId,
     25     InvalidFetchLimit,
     26     InvalidFetchDeadline,
     27     FetchSelectorTooLarge,
     28     DuplicateFetchKind,
     29     DuplicateFetchAuthor,
     30     InvalidFetchTagKey,
     31     InvalidFetchTagValue,
     32     DuplicateFetchTagValue,
     33     InvalidFetchTimeRange,
     34     EmptyFetchCursor,
     35     InvalidFetchCursor,
     36     InvalidObservedAt,
     37     UnexpectedFetchEvent,
     38     UnexpectedFetchProvenance,
     39     UnexpectedFetchTargetOutcome,
     40     DuplicateFetchTargetOutcome,
     41     FetchPageLimitExceeded,
     42     FetchPageRequestMismatch,
     43     EmptySubscriptionRequestId,
     44     InvalidSubscriptionRequestId,
     45     InvalidSubscriptionLimit,
     46     InvalidSubscriptionDeadline,
     47     SubscriptionCheckpointSetTooLarge,
     48     UnexpectedSubscriptionCheckpoint,
     49     DuplicateSubscriptionCheckpoint,
     50     UnexpectedSubscriptionEvent,
     51     SubscriptionEventCheckpointMismatch,
     52     SubscriptionEndLimitExceeded,
     53     InvalidSubscriptionEnd,
     54     SubscriptionEndRequestMismatch,
     55     SubscriptionUnavailable,
     56     InvalidSatisfactionPolicy,
     57     EmptyRequiredTargetSet,
     58     DuplicateRequiredTargetFingerprint,
     59     RequiredTargetNotRequested,
     60     EmptyDeliveryRequestId,
     61     InvalidDeliveryRequestId,
     62     InvalidDeliveryTimestamp,
     63     InvalidDeliveryDeadline,
     64     InvalidDeliveryTargetSelection,
     65     InvalidDeliveryOutcome,
     66     UnexpectedDeliveryTargetReceipt,
     67     DuplicateDeliveryTargetReceipt,
     68     MissingDeliveryTargetReceipt,
     69     DeliveryTargetReceiptStatusMismatch,
     70     DeliveryTargetReceiptAttemptMismatch,
     71     TransportOutcomeStatusMismatch,
     72     DeliveryReceiptRequestIdMismatch,
     73     DeliveryReceiptPayloadMismatch,
     74     DeliveryReceiptTargetSetMismatch,
     75     EmptyPayloadId,
     76     InvalidPayloadId,
     77     EmptyPayloadLabel,
     78     InvalidPayloadLabel,
     79     EmptyPayloadBytes,
     80     InvalidPayloadBytes,
     81     InvalidPayloadDigest,
     82     PayloadDigestMismatch,
     83 }
     84 
     85 impl fmt::Display for Error {
     86     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     87         match self {
     88             Self::TransportClosed => f.write_str("transport admission is closed"),
     89             Self::TransportUnavailable => f.write_str("transport is temporarily unavailable"),
     90             Self::UnsupportedOperation => f.write_str("transport operation is unsupported"),
     91             Self::EmptyTransportKind => f.write_str("transport kind is empty"),
     92             Self::InvalidTransportKind => f.write_str("transport kind is invalid"),
     93             Self::EmptyTargetUri => f.write_str("transport target URI is empty"),
     94             Self::InvalidTargetUri => f.write_str("transport target URI is invalid"),
     95             Self::EmptyTargetScope => f.write_str("transport target scope is empty"),
     96             Self::InvalidTargetScope => f.write_str("transport target scope is invalid"),
     97             Self::EmptyTargetLabel => f.write_str("transport target label is empty"),
     98             Self::InvalidTargetLabel => f.write_str("transport target label is invalid"),
     99             Self::EmptyTargetSet => f.write_str("transport target set is empty"),
    100             Self::TargetSetTooLarge => f.write_str("transport target set exceeds its item limit"),
    101             Self::DuplicateTargetFingerprint => {
    102                 f.write_str("transport target set contains duplicate fingerprints")
    103             }
    104             Self::InvalidTargetFingerprint => {
    105                 f.write_str("transport target fingerprint is invalid")
    106             }
    107             Self::EmptyFetchRequestId => f.write_str("transport fetch request id is empty"),
    108             Self::InvalidFetchRequestId => f.write_str("transport fetch request id is invalid"),
    109             Self::InvalidFetchLimit => f.write_str("transport fetch limit is invalid"),
    110             Self::InvalidFetchDeadline => f.write_str("transport fetch deadline is invalid"),
    111             Self::FetchSelectorTooLarge => {
    112                 f.write_str("transport fetch selector exceeds its item limit")
    113             }
    114             Self::DuplicateFetchKind => {
    115                 f.write_str("transport fetch selector contains a duplicate event kind")
    116             }
    117             Self::DuplicateFetchAuthor => {
    118                 f.write_str("transport fetch selector contains a duplicate author")
    119             }
    120             Self::InvalidFetchTagKey => f.write_str("transport fetch selector tag key is invalid"),
    121             Self::InvalidFetchTagValue => {
    122                 f.write_str("transport fetch selector tag value is invalid")
    123             }
    124             Self::DuplicateFetchTagValue => {
    125                 f.write_str("transport fetch selector contains a duplicate tag value")
    126             }
    127             Self::InvalidFetchTimeRange => {
    128                 f.write_str("transport fetch selector time range is invalid")
    129             }
    130             Self::EmptyFetchCursor => f.write_str("transport fetch cursor is empty"),
    131             Self::InvalidFetchCursor => f.write_str("transport fetch cursor is invalid"),
    132             Self::InvalidObservedAt => f.write_str("transport event observation time is invalid"),
    133             Self::UnexpectedFetchEvent => {
    134                 f.write_str("transport fetch page contains an event outside its selector")
    135             }
    136             Self::UnexpectedFetchProvenance => {
    137                 f.write_str("transport fetch page contains unexpected event provenance")
    138             }
    139             Self::UnexpectedFetchTargetOutcome => {
    140                 f.write_str("transport fetch page contains an unexpected target outcome")
    141             }
    142             Self::DuplicateFetchTargetOutcome => {
    143                 f.write_str("transport fetch page contains a duplicate target outcome")
    144             }
    145             Self::FetchPageLimitExceeded => {
    146                 f.write_str("transport fetch page exceeds its requested event limit")
    147             }
    148             Self::FetchPageRequestMismatch => {
    149                 f.write_str("transport fetch page does not match its request")
    150             }
    151             Self::EmptySubscriptionRequestId => {
    152                 f.write_str("transport subscription request id is empty")
    153             }
    154             Self::InvalidSubscriptionRequestId => {
    155                 f.write_str("transport subscription request id is invalid")
    156             }
    157             Self::InvalidSubscriptionLimit => {
    158                 f.write_str("transport subscription event limit is invalid")
    159             }
    160             Self::InvalidSubscriptionDeadline => {
    161                 f.write_str("transport subscription deadline is invalid")
    162             }
    163             Self::SubscriptionCheckpointSetTooLarge => {
    164                 f.write_str("transport subscription checkpoint set exceeds its target limit")
    165             }
    166             Self::UnexpectedSubscriptionCheckpoint => {
    167                 f.write_str("transport subscription contains an unexpected checkpoint")
    168             }
    169             Self::DuplicateSubscriptionCheckpoint => {
    170                 f.write_str("transport subscription contains a duplicate checkpoint")
    171             }
    172             Self::UnexpectedSubscriptionEvent => {
    173                 f.write_str("transport subscription contains an unexpected event")
    174             }
    175             Self::SubscriptionEventCheckpointMismatch => {
    176                 f.write_str("transport subscription event checkpoint does not match provenance")
    177             }
    178             Self::SubscriptionEndLimitExceeded => {
    179                 f.write_str("transport subscription exceeded its requested event limit")
    180             }
    181             Self::InvalidSubscriptionEnd => {
    182                 f.write_str("transport subscription terminal result is invalid")
    183             }
    184             Self::SubscriptionEndRequestMismatch => {
    185                 f.write_str("transport subscription result does not match its request")
    186             }
    187             Self::SubscriptionUnavailable => f.write_str("transport subscription is unavailable"),
    188             Self::InvalidSatisfactionPolicy => {
    189                 f.write_str("transport satisfaction policy is invalid")
    190             }
    191             Self::EmptyRequiredTargetSet => f.write_str("transport required target set is empty"),
    192             Self::DuplicateRequiredTargetFingerprint => {
    193                 f.write_str("transport required target set contains duplicate fingerprints")
    194             }
    195             Self::RequiredTargetNotRequested => {
    196                 f.write_str("transport required target was not requested")
    197             }
    198             Self::EmptyDeliveryRequestId => f.write_str("transport delivery request id is empty"),
    199             Self::InvalidDeliveryRequestId => {
    200                 f.write_str("transport delivery request id is invalid")
    201             }
    202             Self::InvalidDeliveryTimestamp => {
    203                 f.write_str("transport delivery timestamp is invalid")
    204             }
    205             Self::InvalidDeliveryDeadline => f.write_str("transport delivery deadline is invalid"),
    206             Self::InvalidDeliveryTargetSelection => {
    207                 f.write_str("transport delivery target selection is not an exact subset")
    208             }
    209             Self::InvalidDeliveryOutcome => f.write_str("transport delivery outcome is invalid"),
    210             Self::UnexpectedDeliveryTargetReceipt => {
    211                 f.write_str("transport delivery receipt contains an unexpected target")
    212             }
    213             Self::DuplicateDeliveryTargetReceipt => {
    214                 f.write_str("transport delivery receipt contains a duplicate target")
    215             }
    216             Self::MissingDeliveryTargetReceipt => {
    217                 f.write_str("transport delivery receipt is missing a requested target")
    218             }
    219             Self::DeliveryTargetReceiptStatusMismatch => {
    220                 f.write_str("transport delivery target receipt status does not match its outcome")
    221             }
    222             Self::DeliveryTargetReceiptAttemptMismatch => {
    223                 f.write_str("transport delivery target receipt attempt evidence is incoherent")
    224             }
    225             Self::TransportOutcomeStatusMismatch => {
    226                 f.write_str("transport outcome status does not match its outcome kind")
    227             }
    228             Self::DeliveryReceiptRequestIdMismatch => {
    229                 f.write_str("transport delivery receipt request id does not match its request")
    230             }
    231             Self::DeliveryReceiptPayloadMismatch => {
    232                 f.write_str("transport delivery receipt exact payload does not match its request")
    233             }
    234             Self::DeliveryReceiptTargetSetMismatch => {
    235                 f.write_str("transport delivery receipt target set does not match its request")
    236             }
    237             Self::EmptyPayloadId => f.write_str("transport payload id is empty"),
    238             Self::InvalidPayloadId => f.write_str("transport payload id is invalid"),
    239             Self::EmptyPayloadLabel => f.write_str("transport payload label is empty"),
    240             Self::InvalidPayloadLabel => f.write_str("transport payload label is invalid"),
    241             Self::EmptyPayloadBytes => f.write_str("transport payload bytes are empty"),
    242             Self::InvalidPayloadBytes => f.write_str("transport payload bytes are invalid"),
    243             Self::InvalidPayloadDigest => f.write_str("transport payload digest is invalid"),
    244             Self::PayloadDigestMismatch => {
    245                 f.write_str("transport payload digest does not match payload bytes")
    246             }
    247         }
    248     }
    249 }