use kafka_client_core::{DeliveryStatus, TransactionOffsetCommitStage};
use crate::transaction::offset_commit::{
TransactionOffsetCommitFailure as InternalFailure,
TransactionOffsetCommitFailureKind as InternalKind,
TransactionOffsetCommitOutcome as InternalOutcome,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionOffsetsStage {
AddOffsets,
CommitOffsets,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionOffsetsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionOffsetsConsequence {
FailedHealthy,
AbortRequired,
Fatal,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionOffsetsFailureKind {
DeadlineElapsed,
DriverRejected,
Backpressure,
Compatibility,
InvalidResponse,
Transport,
Broker,
Correlation,
DriverClosed,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct TransactionOffsetsFailure {
stage: TransactionOffsetsStage,
kind: TransactionOffsetsFailureKind,
delivery: TransactionOffsetsDeliveryStatus,
broker_code: Option<i16>,
consequence: TransactionOffsetsConsequence,
}
impl TransactionOffsetsFailure {
pub const fn stage(self) -> TransactionOffsetsStage {
self.stage
}
pub const fn kind(self) -> TransactionOffsetsFailureKind {
self.kind
}
pub const fn delivery(self) -> TransactionOffsetsDeliveryStatus {
self.delivery
}
pub const fn broker_code(self) -> Option<i16> {
self.broker_code
}
pub const fn consequence(self) -> TransactionOffsetsConsequence {
self.consequence
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionOffsetsOutcome {
Succeeded,
Failed(TransactionOffsetsFailure),
}
pub(super) fn translate_offset_outcome(outcome: InternalOutcome) -> TransactionOffsetsOutcome {
match outcome {
InternalOutcome::Succeeded => TransactionOffsetsOutcome::Succeeded,
InternalOutcome::RejectedNotSent { stage, failure } => {
failed(stage, failure, TransactionOffsetsConsequence::FailedHealthy)
}
InternalOutcome::AbortRequired { stage, failure } => {
failed(stage, failure, TransactionOffsetsConsequence::AbortRequired)
}
InternalOutcome::Fatal { stage, failure } => {
failed(stage, failure, TransactionOffsetsConsequence::Fatal)
}
}
}
fn failed(
stage: TransactionOffsetCommitStage,
failure: InternalFailure,
consequence: TransactionOffsetsConsequence,
) -> TransactionOffsetsOutcome {
let (kind, broker_code) = match failure.kind() {
InternalKind::DeadlineElapsed => (TransactionOffsetsFailureKind::DeadlineElapsed, None),
InternalKind::DriverRejected => (TransactionOffsetsFailureKind::DriverRejected, None),
InternalKind::Allocation => (TransactionOffsetsFailureKind::Backpressure, None),
InternalKind::Compatibility => (TransactionOffsetsFailureKind::Compatibility, None),
InternalKind::InvalidResponse => (TransactionOffsetsFailureKind::InvalidResponse, None),
InternalKind::Transport => (TransactionOffsetsFailureKind::Transport, None),
InternalKind::Broker { code, .. } => (TransactionOffsetsFailureKind::Broker, Some(code)),
InternalKind::Correlation => (TransactionOffsetsFailureKind::Correlation, None),
InternalKind::DriverShutdown => (TransactionOffsetsFailureKind::DriverClosed, None),
};
TransactionOffsetsOutcome::Failed(TransactionOffsetsFailure {
stage: match stage {
TransactionOffsetCommitStage::AddOffsets => TransactionOffsetsStage::AddOffsets,
TransactionOffsetCommitStage::TxnOffsetCommit => TransactionOffsetsStage::CommitOffsets,
},
kind,
delivery: match failure.delivery() {
DeliveryStatus::NotSent => TransactionOffsetsDeliveryStatus::NotSent,
DeliveryStatus::PossiblySent => TransactionOffsetsDeliveryStatus::PossiblySent,
},
broker_code,
consequence,
})
}