use core::fmt;
use crate::{
producer::{
ProducerSendCaptureError, ProducerSendCaptureErrorKind, PublicProducerRecord,
TransactionRecordViewError,
},
transaction::{
TransactionExecutionSendAdmissionErrorKind, send::TransactionSendAdmissionFailureKind,
},
};
use super::{
TransactionControlErrorKind, TransactionLifecycleControlError, TransactionSendControlError,
TransactionSendControlErrorKind, control_error_mapping::control_error_kind,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionSendAdmissionErrorKind {
InvalidDeadline,
TimestampUnavailable,
EmptyTopic,
NegativeExplicitPartition,
RetainedSizeOverflow,
Contended,
Closed,
StaleOwner,
RetainedRecordBytes {
actual: usize,
limit: usize,
},
RetainedTopicCapacity {
actual: usize,
limit: usize,
},
RetainedTopicBytes {
actual: usize,
limit: usize,
},
RetainedTopicBytesOverflow,
TopicIdentityExhausted,
Allocation,
Busy,
SendIdentityExhausted,
InvalidPartition,
Transaction(TransactionControlErrorKind),
}
#[must_use = "transactional send rejection retains the original producer record"]
pub struct TransactionSendAdmissionError {
kind: TransactionSendAdmissionErrorKind,
record: PublicProducerRecord,
}
impl TransactionSendAdmissionError {
pub(super) const fn new(
kind: TransactionSendAdmissionErrorKind,
record: PublicProducerRecord,
) -> Self {
Self { kind, record }
}
pub const fn kind(&self) -> TransactionSendAdmissionErrorKind {
self.kind
}
pub const fn record(&self) -> &PublicProducerRecord {
&self.record
}
pub fn into_record(self) -> PublicProducerRecord {
self.record
}
}
impl fmt::Debug for TransactionSendAdmissionError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("TransactionSendAdmissionError")
.field("kind", &self.kind)
.field("record", &self.record)
.finish()
}
}
impl fmt::Display for TransactionSendAdmissionError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "transactional send rejected: {:?}", self.kind)
}
}
impl std::error::Error for TransactionSendAdmissionError {}
pub(super) const fn capture_error_kind(
error: ProducerSendCaptureError,
) -> TransactionSendAdmissionErrorKind {
match error.kind() {
ProducerSendCaptureErrorKind::DeadlineUnrepresentable => {
TransactionSendAdmissionErrorKind::InvalidDeadline
}
ProducerSendCaptureErrorKind::TimestampUnrepresentable => {
TransactionSendAdmissionErrorKind::TimestampUnavailable
}
}
}
pub(super) const fn record_error_kind(
error: TransactionRecordViewError,
) -> TransactionSendAdmissionErrorKind {
match error {
TransactionRecordViewError::EmptyTopic => TransactionSendAdmissionErrorKind::EmptyTopic,
TransactionRecordViewError::NegativeExplicitPartition => {
TransactionSendAdmissionErrorKind::NegativeExplicitPartition
}
TransactionRecordViewError::RetainedSizeOverflow => {
TransactionSendAdmissionErrorKind::RetainedSizeOverflow
}
}
}
pub(super) const fn control_send_error_kind(
error: &TransactionSendControlError,
) -> TransactionSendAdmissionErrorKind {
match error.kind() {
TransactionSendControlErrorKind::Contended => TransactionSendAdmissionErrorKind::Contended,
TransactionSendControlErrorKind::Closed => TransactionSendAdmissionErrorKind::Closed,
TransactionSendControlErrorKind::Admission(kind) => execution_error_kind(kind),
}
}
const fn execution_error_kind(
error: TransactionExecutionSendAdmissionErrorKind,
) -> TransactionSendAdmissionErrorKind {
match error {
TransactionExecutionSendAdmissionErrorKind::StaleOwner => {
TransactionSendAdmissionErrorKind::StaleOwner
}
TransactionExecutionSendAdmissionErrorKind::RetainedRecordBytes { actual, limit } => {
TransactionSendAdmissionErrorKind::RetainedRecordBytes { actual, limit }
}
TransactionExecutionSendAdmissionErrorKind::RetainedTopicCapacity { actual, limit } => {
TransactionSendAdmissionErrorKind::RetainedTopicCapacity { actual, limit }
}
TransactionExecutionSendAdmissionErrorKind::RetainedTopicBytes { actual, limit } => {
TransactionSendAdmissionErrorKind::RetainedTopicBytes { actual, limit }
}
TransactionExecutionSendAdmissionErrorKind::RetainedTopicBytesOverflow => {
TransactionSendAdmissionErrorKind::RetainedTopicBytesOverflow
}
TransactionExecutionSendAdmissionErrorKind::TopicIdentityExhausted => {
TransactionSendAdmissionErrorKind::TopicIdentityExhausted
}
TransactionExecutionSendAdmissionErrorKind::Allocation => {
TransactionSendAdmissionErrorKind::Allocation
}
TransactionExecutionSendAdmissionErrorKind::Send(kind) => send_error_kind(kind),
}
}
const fn send_error_kind(
error: TransactionSendAdmissionFailureKind,
) -> TransactionSendAdmissionErrorKind {
match error {
TransactionSendAdmissionFailureKind::Busy => TransactionSendAdmissionErrorKind::Busy,
TransactionSendAdmissionFailureKind::SendIdentityExhausted => {
TransactionSendAdmissionErrorKind::SendIdentityExhausted
}
TransactionSendAdmissionFailureKind::InvalidPartition => {
TransactionSendAdmissionErrorKind::InvalidPartition
}
TransactionSendAdmissionFailureKind::Lifecycle(error) => {
TransactionSendAdmissionErrorKind::Transaction(control_error_kind(
TransactionLifecycleControlError::Host(error),
))
}
}
}