kafka_client_engine/transaction/initialization/
offset_outcome.rs1use kafka_client_core::{DeliveryStatus, TransactionOffsetCommitStage};
4
5use crate::transaction::offset_commit::{
6 TransactionOffsetCommitFailure as InternalFailure,
7 TransactionOffsetCommitFailureKind as InternalKind,
8 TransactionOffsetCommitOutcome as InternalOutcome,
9};
10
11#[derive(Clone, Copy, Debug, Eq, PartialEq)]
13pub enum TransactionOffsetsStage {
14 AddOffsets,
16 CommitOffsets,
18}
19
20#[derive(Clone, Copy, Debug, Eq, PartialEq)]
22pub enum TransactionOffsetsDeliveryStatus {
23 NotSent,
25 PossiblySent,
27}
28
29#[derive(Clone, Copy, Debug, Eq, PartialEq)]
31pub enum TransactionOffsetsConsequence {
32 FailedHealthy,
34 AbortRequired,
36 Fatal,
38}
39
40#[derive(Clone, Copy, Debug, Eq, PartialEq)]
42pub enum TransactionOffsetsFailureKind {
43 DeadlineElapsed,
45 DriverRejected,
47 Backpressure,
49 Compatibility,
51 InvalidResponse,
53 Transport,
55 Broker,
57 Correlation,
59 DriverClosed,
61}
62
63#[derive(Clone, Copy, Debug, Eq, PartialEq)]
65pub struct TransactionOffsetsFailure {
66 stage: TransactionOffsetsStage,
67 kind: TransactionOffsetsFailureKind,
68 delivery: TransactionOffsetsDeliveryStatus,
69 broker_code: Option<i16>,
70 consequence: TransactionOffsetsConsequence,
71}
72
73impl TransactionOffsetsFailure {
74 pub const fn stage(self) -> TransactionOffsetsStage {
76 self.stage
77 }
78 pub const fn kind(self) -> TransactionOffsetsFailureKind {
80 self.kind
81 }
82 pub const fn delivery(self) -> TransactionOffsetsDeliveryStatus {
84 self.delivery
85 }
86 pub const fn broker_code(self) -> Option<i16> {
88 self.broker_code
89 }
90 pub const fn consequence(self) -> TransactionOffsetsConsequence {
92 self.consequence
93 }
94}
95
96#[derive(Clone, Copy, Debug, Eq, PartialEq)]
98pub enum TransactionOffsetsOutcome {
99 Succeeded,
101 Failed(TransactionOffsetsFailure),
103}
104
105pub(super) fn translate_offset_outcome(outcome: InternalOutcome) -> TransactionOffsetsOutcome {
106 match outcome {
107 InternalOutcome::Succeeded => TransactionOffsetsOutcome::Succeeded,
108 InternalOutcome::RejectedNotSent { stage, failure } => {
109 failed(stage, failure, TransactionOffsetsConsequence::FailedHealthy)
110 }
111 InternalOutcome::AbortRequired { stage, failure } => {
112 failed(stage, failure, TransactionOffsetsConsequence::AbortRequired)
113 }
114 InternalOutcome::Fatal { stage, failure } => {
115 failed(stage, failure, TransactionOffsetsConsequence::Fatal)
116 }
117 }
118}
119
120fn failed(
121 stage: TransactionOffsetCommitStage,
122 failure: InternalFailure,
123 consequence: TransactionOffsetsConsequence,
124) -> TransactionOffsetsOutcome {
125 let (kind, broker_code) = match failure.kind() {
126 InternalKind::DeadlineElapsed => (TransactionOffsetsFailureKind::DeadlineElapsed, None),
127 InternalKind::DriverRejected => (TransactionOffsetsFailureKind::DriverRejected, None),
128 InternalKind::Allocation => (TransactionOffsetsFailureKind::Backpressure, None),
129 InternalKind::Compatibility => (TransactionOffsetsFailureKind::Compatibility, None),
130 InternalKind::InvalidResponse => (TransactionOffsetsFailureKind::InvalidResponse, None),
131 InternalKind::Transport => (TransactionOffsetsFailureKind::Transport, None),
132 InternalKind::Broker { code, .. } => (TransactionOffsetsFailureKind::Broker, Some(code)),
133 InternalKind::Correlation => (TransactionOffsetsFailureKind::Correlation, None),
134 InternalKind::DriverShutdown => (TransactionOffsetsFailureKind::DriverClosed, None),
135 };
136 TransactionOffsetsOutcome::Failed(TransactionOffsetsFailure {
137 stage: match stage {
138 TransactionOffsetCommitStage::AddOffsets => TransactionOffsetsStage::AddOffsets,
139 TransactionOffsetCommitStage::TxnOffsetCommit => TransactionOffsetsStage::CommitOffsets,
140 },
141 kind,
142 delivery: match failure.delivery() {
143 DeliveryStatus::NotSent => TransactionOffsetsDeliveryStatus::NotSent,
144 DeliveryStatus::PossiblySent => TransactionOffsetsDeliveryStatus::PossiblySent,
145 },
146 broker_code,
147 consequence,
148 })
149}