use super::EventV3;
use crate::types::{Id, SubscriptionId};
use serde::de::Error as DeError;
use serde::de::{Deserialize, Deserializer, IgnoredAny, SeqAccess, Visitor};
use serde::ser::{Serialize, SerializeSeq, Serializer};
#[cfg(feature = "speedy")]
use speedy::{Readable, Writable};
use std::fmt;
#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "speedy", derive(Readable, Writable))]
pub enum RelayMessageV5 {
Auth(String),
Closed(SubscriptionId, String),
Eose(SubscriptionId),
Event(SubscriptionId, Box<EventV3>),
Notice(String),
Notify(String),
Ok(Id, bool, String),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum Why {
AuthRequired,
Blocked,
Duplicate,
Error,
Invalid,
Pow,
RateLimited,
Restricted,
}
impl RelayMessageV5 {
pub fn why(&self) -> Option<Why> {
let s = match *self {
RelayMessageV5::Closed(_, ref s) => s,
RelayMessageV5::Ok(_, _, ref s) => s,
_ => return None,
};
match s.split(':').next() {
Some("auth-required") => Some(Why::AuthRequired),
Some("blocked") => Some(Why::Blocked),
Some("duplicate") => Some(Why::Duplicate),
Some("error") => Some(Why::Error),
Some("invalid") => Some(Why::Invalid),
Some("pow") => Some(Why::Pow),
Some("rate-limited") => Some(Why::RateLimited),
Some("restricted") => Some(Why::Restricted),
_ => None,
}
}
#[allow(dead_code)]
pub(crate) fn mock() -> RelayMessageV5 {
RelayMessageV5::Event(SubscriptionId::mock(), Box::new(EventV3::mock()))
}
}
impl Serialize for RelayMessageV5 {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
RelayMessageV5::Auth(challenge) => {
let mut seq = serializer.serialize_seq(Some(2))?;
seq.serialize_element("AUTH")?;
seq.serialize_element(&challenge)?;
seq.end()
}
RelayMessageV5::Closed(id, message) => {
let mut seq = serializer.serialize_seq(Some(3))?;
seq.serialize_element("CLOSED")?;
seq.serialize_element(&id)?;
seq.serialize_element(&message)?;
seq.end()
}
RelayMessageV5::Eose(id) => {
let mut seq = serializer.serialize_seq(Some(2))?;
seq.serialize_element("EOSE")?;
seq.serialize_element(&id)?;
seq.end()
}
RelayMessageV5::Event(id, event) => {
let mut seq = serializer.serialize_seq(Some(3))?;
seq.serialize_element("EVENT")?;
seq.serialize_element(&id)?;
seq.serialize_element(&event)?;
seq.end()
}
RelayMessageV5::Notice(s) => {
let mut seq = serializer.serialize_seq(Some(2))?;
seq.serialize_element("NOTICE")?;
seq.serialize_element(&s)?;
seq.end()
}
RelayMessageV5::Notify(s) => {
let mut seq = serializer.serialize_seq(Some(2))?;
seq.serialize_element("NOTIFY")?;
seq.serialize_element(&s)?;
seq.end()
}
RelayMessageV5::Ok(id, ok, message) => {
let mut seq = serializer.serialize_seq(Some(4))?;
seq.serialize_element("OK")?;
seq.serialize_element(&id)?;
seq.serialize_element(&ok)?;
seq.serialize_element(&message)?;
seq.end()
}
}
}
}
impl<'de> Deserialize<'de> for RelayMessageV5 {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_seq(RelayMessageVisitor)
}
}
struct RelayMessageVisitor;
impl<'de> Visitor<'de> for RelayMessageVisitor {
type Value = RelayMessageV5;
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "a sequence of strings")
}
fn visit_seq<A>(self, mut seq: A) -> Result<RelayMessageV5, A::Error>
where
A: SeqAccess<'de>,
{
let word: &str = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing initial string field"))?;
let mut output: Option<RelayMessageV5> = None;
if word == "EVENT" {
let id: SubscriptionId = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing id field"))?;
let event: EventV3 = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing event field"))?;
output = Some(RelayMessageV5::Event(id, Box::new(event)));
} else if word == "NOTICE" {
let s: String = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing string field"))?;
output = Some(RelayMessageV5::Notice(s));
} else if word == "NOTIFY" {
let s: String = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing string field"))?;
output = Some(RelayMessageV5::Notify(s));
} else if word == "EOSE" {
let id: SubscriptionId = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing id field"))?;
output = Some(RelayMessageV5::Eose(id))
} else if word == "OK" {
let id: Id = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing id field"))?;
let ok: bool = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing ok field"))?;
let message: String = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing string field"))?;
output = Some(RelayMessageV5::Ok(id, ok, message));
} else if word == "AUTH" {
let challenge: String = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing challenge field"))?;
output = Some(RelayMessageV5::Auth(challenge));
} else if word == "CLOSED" {
let id: SubscriptionId = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message messing id field"))?;
let message: String = seq
.next_element()?
.ok_or_else(|| DeError::custom("Message missing string field"))?;
output = Some(RelayMessageV5::Closed(id, message));
}
while let Some(_ignored) = seq.next_element::<IgnoredAny>()? {}
match output {
Some(rm) => Ok(rm),
None => Err(DeError::custom(format!("Unknown Message: {word}"))),
}
}
}
#[cfg(test)]
mod test {
use super::*;
test_serde! {RelayMessageV5, test_relay_message_serde}
}