use crate::error::{Error, ensure};
use serde::Serialize;
use std::{fmt, str::FromStr};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum FailureKind {
Decode,
Rejected,
RetryExhausted,
Encode,
PublishRejected,
}
impl FailureKind {
pub fn as_str(self) -> &'static str {
match self {
Self::Decode => "decode",
Self::Rejected => "rejected",
Self::RetryExhausted => "retry_exhausted",
Self::Encode => "encode",
Self::PublishRejected => "publish_rejected",
}
}
}
impl FromStr for FailureKind {
type Err = Error;
fn from_str(name: &str) -> Result<Self, Error> {
[
Self::Decode,
Self::Rejected,
Self::RetryExhausted,
Self::Encode,
Self::PublishRejected,
]
.into_iter()
.find(|kind| kind.as_str() == name)
.ok_or_else(|| Error::invalid_record(format!("unknown failure kind {name:?}")))
}
}
impl fmt::Display for FailureKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Decode => "decode failed",
Self::Rejected => "handler rejected input",
Self::RetryExhausted => "handler retry exhausted",
Self::Encode => "prepare output failed",
Self::PublishRejected => "sink rejected output",
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FailureAction {
Stop,
DeadLetter,
Discard,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ErrorPolicy {
pub decode: FailureAction,
pub rejected: FailureAction,
pub retry_exhausted: FailureAction,
pub encode: FailureAction,
pub publish_rejected: FailureAction,
}
impl Default for ErrorPolicy {
fn default() -> Self {
Self {
decode: FailureAction::Stop,
rejected: FailureAction::DeadLetter,
retry_exhausted: FailureAction::DeadLetter,
encode: FailureAction::Stop,
publish_rejected: FailureAction::DeadLetter,
}
}
}
impl ErrorPolicy {
pub fn dead_letter_all() -> Self {
Self {
decode: FailureAction::DeadLetter,
rejected: FailureAction::DeadLetter,
retry_exhausted: FailureAction::DeadLetter,
encode: FailureAction::DeadLetter,
publish_rejected: FailureAction::DeadLetter,
}
}
pub fn action(&self, kind: FailureKind) -> FailureAction {
match kind {
FailureKind::Decode => self.decode,
FailureKind::Rejected => self.rejected,
FailureKind::RetryExhausted => self.retry_exhausted,
FailureKind::Encode => self.encode,
FailureKind::PublishRejected => self.publish_rejected,
}
}
pub(crate) fn validate(&self, has_dead_letter_sink: bool) -> Result<(), Error> {
if has_dead_letter_sink {
return Ok(());
}
for kind in [FailureKind::Decode, FailureKind::Encode] {
ensure!(
self.action(kind) != FailureAction::DeadLetter,
Error::config,
"error policy dead-letters {kind:?} failures but no dead-letter sink is configured"
);
}
Ok(())
}
}