kafka_client_engine/transaction/initialization/
send_outcome.rs1use std::sync::Arc;
4
5use kafka_client_core::{ProducerBatchSuccess, TransactionEpoch, TransactionSendId};
6
7use crate::transaction::send::TransactionSendTerminal as InternalTerminal;
8
9use super::send_failure_mapping::public_failure;
10
11#[derive(Clone, Copy, Debug, Eq, PartialEq)]
13pub enum TransactionSendDeliveryStatus {
14 NotSent,
16 PossiblySent,
18}
19
20#[derive(Clone, Copy, Debug, Eq, PartialEq)]
22pub enum TransactionSendConsequence {
23 FailedHealthy,
25 AbortRequired,
27 Fatal,
29}
30
31#[derive(Clone, Copy, Debug, Eq, PartialEq)]
33pub enum TransactionSendFailureKind {
34 Busy,
36 StaleTransaction,
38 OwnerUnavailable,
40 InvalidTarget,
42 Backpressure,
44 DeadlineElapsed,
46 DriverRejected,
48 Transport,
50 Compatibility,
52 InvalidResponse,
54 DriverClosed,
56 Broker,
58 Materialization,
60 Routing,
62 NameResolution,
64 ConnectionUnavailable,
66 Permanent,
68 Correlation,
70}
71
72#[derive(Clone, Copy, Debug, Eq, PartialEq)]
74pub struct TransactionSendFailure {
75 pub(super) kind: TransactionSendFailureKind,
76 pub(super) delivery: TransactionSendDeliveryStatus,
77 pub(super) broker_code: Option<i16>,
78 pub(super) consequence: TransactionSendConsequence,
79}
80
81impl TransactionSendFailure {
82 pub const fn kind(self) -> TransactionSendFailureKind {
84 self.kind
85 }
86
87 pub const fn delivery(self) -> TransactionSendDeliveryStatus {
89 self.delivery
90 }
91
92 pub const fn broker_code(self) -> Option<i16> {
94 self.broker_code
95 }
96
97 pub const fn consequence(self) -> TransactionSendConsequence {
99 self.consequence
100 }
101}
102
103#[derive(Clone, Debug, Eq, PartialEq)]
105pub struct TransactionSendMetadata {
106 topic: Arc<str>,
107 partition: i32,
108 offset: i64,
109 timestamp: Option<i64>,
110 leader_epoch: Option<i32>,
111}
112
113impl TransactionSendMetadata {
114 pub fn topic(&self) -> &str {
116 &self.topic
117 }
118
119 pub const fn partition(&self) -> i32 {
121 self.partition
122 }
123
124 pub const fn offset(&self) -> i64 {
126 self.offset
127 }
128
129 pub const fn timestamp(&self) -> Option<i64> {
131 self.timestamp
132 }
133
134 pub const fn leader_epoch(&self) -> Option<i32> {
136 self.leader_epoch
137 }
138}
139
140#[derive(Clone, Debug, Eq, PartialEq)]
142pub enum TransactionSendOutcome {
143 Succeeded(TransactionSendMetadata),
145 Failed(TransactionSendFailure),
147}
148
149pub(super) fn translate_send_terminal(
150 terminal: InternalTerminal,
151 epoch: TransactionEpoch,
152 send_id: TransactionSendId,
153 topic: Arc<str>,
154 partition: Option<i32>,
155) -> Option<TransactionSendOutcome> {
156 match terminal {
157 InternalTerminal::Succeeded {
158 epoch: actual_epoch,
159 send_id: actual_send_id,
160 partition: actual_partition,
161 success,
162 } if actual_epoch == epoch
163 && actual_send_id == send_id
164 && partition.is_none_or(|partition| {
165 u32::try_from(partition).ok() == Some(actual_partition.get())
166 }) =>
167 {
168 let partition = i32::try_from(actual_partition.get()).ok()?;
169 Some(TransactionSendOutcome::Succeeded(success_metadata(
170 success, topic, partition,
171 )))
172 }
173 InternalTerminal::FailedHealthy {
174 epoch: actual_epoch,
175 send_id: actual_send_id,
176 failure,
177 } if actual_epoch == epoch && actual_send_id == send_id => Some(public_failure(
178 failure,
179 TransactionSendConsequence::FailedHealthy,
180 )),
181 InternalTerminal::AbortRequired {
182 epoch: actual_epoch,
183 send_id: actual_send_id,
184 failure,
185 } if actual_epoch == epoch && actual_send_id == send_id => Some(public_failure(
186 failure,
187 TransactionSendConsequence::AbortRequired,
188 )),
189 InternalTerminal::Fatal {
190 epoch: actual_epoch,
191 send_id: actual_send_id,
192 failure,
193 } if actual_epoch == epoch && actual_send_id == send_id => {
194 Some(public_failure(failure, TransactionSendConsequence::Fatal))
195 }
196 _ => None,
197 }
198}
199
200fn success_metadata(
201 success: ProducerBatchSuccess,
202 topic: Arc<str>,
203 partition: i32,
204) -> TransactionSendMetadata {
205 TransactionSendMetadata {
206 topic,
207 partition,
208 offset: success.base_offset(),
209 timestamp: success.append_timestamp(),
210 leader_epoch: success.leader_epoch(),
211 }
212}