tangle


git clone https://radroots.dev/git/tangle.git
Log | Files | Refs | README | LICENSE

errors.rs (2910B)

      1 #![forbid(unsafe_code)]
      2 
      3 use core::fmt;
      4 use tangle_groups::GroupError;
      5 use tangle_protocol::{EventId, RelayMessage};
      6 
      7 #[derive(Debug, Clone, PartialEq, Eq)]
      8 pub struct BaseRelayError {
      9     prefix: &'static str,
     10     message: String,
     11 }
     12 
     13 impl BaseRelayError {
     14     pub fn invalid(message: impl Into<String>) -> Self {
     15         Self {
     16             prefix: "invalid",
     17             message: message.into(),
     18         }
     19     }
     20 
     21     pub fn auth_required(message: impl Into<String>) -> Self {
     22         Self {
     23             prefix: "auth-required",
     24             message: message.into(),
     25         }
     26     }
     27 
     28     pub fn rate_limited(message: impl Into<String>) -> Self {
     29         Self {
     30             prefix: "rate-limited",
     31             message: message.into(),
     32         }
     33     }
     34 
     35     pub fn restricted(message: impl Into<String>) -> Self {
     36         Self {
     37             prefix: "restricted",
     38             message: message.into(),
     39         }
     40     }
     41 
     42     pub fn error(message: impl Into<String>) -> Self {
     43         Self {
     44             prefix: "error",
     45             message: message.into(),
     46         }
     47     }
     48 
     49     pub fn prefixed_message(&self) -> String {
     50         format!("{}: {}", self.prefix, self.message)
     51     }
     52 
     53     pub fn message(&self) -> &str {
     54         &self.message
     55     }
     56 }
     57 
     58 impl fmt::Display for BaseRelayError {
     59     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
     60         formatter.write_str(&self.prefixed_message())
     61     }
     62 }
     63 
     64 impl std::error::Error for BaseRelayError {}
     65 
     66 impl From<tangle_store_pocket::PocketStoreError> for BaseRelayError {
     67     fn from(error: tangle_store_pocket::PocketStoreError) -> Self {
     68         Self::error(error.to_string())
     69     }
     70 }
     71 
     72 impl From<GroupError> for BaseRelayError {
     73     fn from(error: GroupError) -> Self {
     74         Self::error(error.prefixed_message())
     75     }
     76 }
     77 
     78 pub(crate) fn ok_accepted(event_id: EventId, message: String) -> RelayMessage {
     79     RelayMessage::Ok {
     80         event_id,
     81         accepted: true,
     82         message,
     83     }
     84 }
     85 
     86 pub(crate) fn ok_rejected(event_id: EventId, message: String) -> RelayMessage {
     87     RelayMessage::Ok {
     88         event_id,
     89         accepted: false,
     90         message,
     91     }
     92 }
     93 
     94 #[cfg(test)]
     95 mod tests {
     96     use super::BaseRelayError;
     97 
     98     #[test]
     99     fn relay_error_prefixes_are_stable() {
    100         assert_eq!(
    101             BaseRelayError::invalid("bad event").prefixed_message(),
    102             "invalid: bad event"
    103         );
    104         assert_eq!(
    105             BaseRelayError::auth_required("login").prefixed_message(),
    106             "auth-required: login"
    107         );
    108         assert_eq!(
    109             BaseRelayError::rate_limited("slow down").prefixed_message(),
    110             "rate-limited: slow down"
    111         );
    112         assert_eq!(
    113             BaseRelayError::restricted("nope").prefixed_message(),
    114             "restricted: nope"
    115         );
    116         assert_eq!(
    117             BaseRelayError::error("store").prefixed_message(),
    118             "error: store"
    119         );
    120     }
    121 }