use std::{error::Error, fmt};
use kafka_client_core::ProducerCancellationOutcome as CoreCancellationOutcome;
use crate::producer::ingress::{
ProducerPortCancelAccepted, ProducerPortCancelError, ProducerPortCancelFault,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ProducerCancellationOutcome {
CancelledNotSent,
TooLate,
AlreadyTerminal,
}
#[derive(Debug)]
#[must_use = "a committed cancellation outcome must be observed"]
pub struct ProducerCancelAccepted {
outcome: ProducerCancellationOutcome,
fault: Option<ProducerCancelFault>,
}
impl ProducerCancelAccepted {
pub const fn outcome(&self) -> ProducerCancellationOutcome {
self.outcome
}
pub const fn fault(&self) -> Option<&ProducerCancelFault> {
self.fault.as_ref()
}
pub(crate) fn from_port(accepted: ProducerPortCancelAccepted) -> Self {
let outcome = translate_outcome(accepted.outcome());
let fault = accepted.into_fault().map(ProducerCancelFault::from_port);
Self { outcome, fault }
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ProducerCancelFaultKind {
Wake,
}
#[derive(Debug)]
pub struct ProducerCancelFault {
kind: ProducerCancelFaultKind,
detail: String,
}
impl ProducerCancelFault {
pub const fn kind(&self) -> ProducerCancelFaultKind {
self.kind
}
fn from_port(fault: ProducerPortCancelFault) -> Self {
match fault {
ProducerPortCancelFault::Wake(error) => Self {
kind: ProducerCancelFaultKind::Wake,
detail: error.to_string(),
},
}
}
}
impl fmt::Display for ProducerCancelFault {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(&self.detail)
}
}
impl Error for ProducerCancelFault {}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ProducerCancelErrorKind {
Contended,
HostUnavailable,
ExecutionGenerationExhausted,
InternalInvariant,
}
#[derive(Debug)]
pub struct ProducerCancelError {
kind: ProducerCancelErrorKind,
detail: String,
}
impl ProducerCancelError {
pub const fn kind(&self) -> ProducerCancelErrorKind {
self.kind
}
pub(crate) fn from_port(error: ProducerPortCancelError) -> Self {
match error {
ProducerPortCancelError::Contended => Self::new(
ProducerCancelErrorKind::Contended,
"producer cancellation would block",
),
ProducerPortCancelError::HostUnavailable => Self::new(
ProducerCancelErrorKind::HostUnavailable,
"producer cancellation host is unavailable",
),
ProducerPortCancelError::ExecutionGenerationExhausted => Self::new(
ProducerCancelErrorKind::ExecutionGenerationExhausted,
"producer execution generation is exhausted",
),
ProducerPortCancelError::InternalInvariant(error) => Self {
kind: ProducerCancelErrorKind::InternalInvariant,
detail: error.to_string(),
},
}
}
pub(crate) fn host_unavailable() -> Self {
Self::new(
ProducerCancelErrorKind::HostUnavailable,
"producer cancellation capability is unavailable",
)
}
fn new(kind: ProducerCancelErrorKind, detail: &str) -> Self {
Self {
kind,
detail: detail.to_owned(),
}
}
}
impl fmt::Display for ProducerCancelError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(&self.detail)
}
}
impl Error for ProducerCancelError {}
const fn translate_outcome(outcome: CoreCancellationOutcome) -> ProducerCancellationOutcome {
match outcome {
CoreCancellationOutcome::CancelledNotSent => ProducerCancellationOutcome::CancelledNotSent,
CoreCancellationOutcome::TooLate => ProducerCancellationOutcome::TooLate,
CoreCancellationOutcome::AlreadyTerminal => ProducerCancellationOutcome::AlreadyTerminal,
}
}