kafka_client_engine/transaction/initialization/
outcome.rs1use kafka_client_core::{
4 DeliveryStatus, TransactionInitializationBrokerCategory,
5 TransactionInitializationFailureKind as CoreFailureKind, TransactionInitializationTerminal,
6};
7
8use super::{
9 RetainedTransactionInitializationOutcome, TransactionInitializationHostError,
10 TransactionInitializationObserver, TransactionalOwnerHandle,
11};
12
13#[derive(Clone, Copy, Debug, Eq, PartialEq)]
15pub enum TransactionInitializationAcceptedFaultKind {
16 Wake,
18 HostInvariant,
20}
21
22#[derive(Debug)]
24#[must_use = "accepted initialization retains its sole terminal observer"]
25pub struct TransactionInitializationAccepted {
26 pub(super) observer: TransactionInitializationObserver,
27 pub(super) fault: Option<TransactionInitializationAcceptedFaultKind>,
28}
29
30impl TransactionInitializationAccepted {
31 pub const fn fault(&self) -> Option<TransactionInitializationAcceptedFaultKind> {
33 self.fault
34 }
35
36 pub fn into_observer(self) -> TransactionInitializationObserver {
38 self.observer
39 }
40}
41
42#[derive(Clone, Copy, Debug, Eq, PartialEq)]
44pub enum TransactionInitializationDeliveryStatus {
45 NotSent,
47 PossiblySent,
49}
50
51#[derive(Clone, Copy, Debug, Eq, PartialEq)]
53pub enum TransactionInitializationFailureKind {
54 DeadlineElapsed,
56 DriverRejected,
58 Transport,
60 Broker {
62 code: i16,
64 fenced: bool,
66 },
67 InvalidResponse,
69 ExecutionUnavailable,
71}
72
73#[derive(Clone, Copy, Debug, Eq, PartialEq)]
75pub struct TransactionInitializationFailure {
76 pub(crate) kind: TransactionInitializationFailureKind,
77 pub(crate) delivery: TransactionInitializationDeliveryStatus,
78}
79
80impl TransactionInitializationFailure {
81 pub const fn kind(self) -> TransactionInitializationFailureKind {
83 self.kind
84 }
85
86 pub const fn delivery(self) -> TransactionInitializationDeliveryStatus {
88 self.delivery
89 }
90}
91
92#[derive(Debug)]
94pub enum TransactionInitializationOutcome {
95 Initialized(TransactionalOwnerHandle),
97 Failed(TransactionInitializationFailure),
99}
100
101#[derive(Clone, Copy, Debug, Eq, PartialEq)]
103pub enum TransactionInitializationObserverError {
104 AlreadyObserved,
106 Stale,
108}
109
110impl std::fmt::Display for TransactionInitializationObserverError {
111 fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
112 formatter.write_str(match self {
113 Self::AlreadyObserved => "transaction initialization was already observed",
114 Self::Stale => "transaction initialization observer is stale",
115 })
116 }
117}
118
119impl std::error::Error for TransactionInitializationObserverError {}
120
121pub(super) fn failed_retained_outcome(
122 terminal: TransactionInitializationTerminal,
123) -> Option<RetainedTransactionInitializationOutcome> {
124 let TransactionInitializationTerminal::Failed(failure) = terminal else {
125 return None;
126 };
127 let kind = match failure.kind() {
128 CoreFailureKind::DeadlineElapsed => {
129 self::TransactionInitializationFailureKind::DeadlineElapsed
130 }
131 CoreFailureKind::DriverRejected => {
132 self::TransactionInitializationFailureKind::DriverRejected
133 }
134 CoreFailureKind::Transport => self::TransactionInitializationFailureKind::Transport,
135 CoreFailureKind::Broker(broker) => self::TransactionInitializationFailureKind::Broker {
136 code: broker.code(),
137 fenced: broker.category() == TransactionInitializationBrokerCategory::Fenced,
138 },
139 CoreFailureKind::InvalidResponse => {
140 self::TransactionInitializationFailureKind::InvalidResponse
141 }
142 };
143 Some(RetainedTransactionInitializationOutcome::Failed(
144 TransactionInitializationFailure {
145 kind,
146 delivery: delivery(failure.delivery()),
147 },
148 ))
149}
150
151pub(super) const fn accepted_fault(
152 error: TransactionInitializationHostError,
153) -> TransactionInitializationAcceptedFaultKind {
154 match error {
155 TransactionInitializationHostError::Wake => {
156 TransactionInitializationAcceptedFaultKind::Wake
157 }
158 _ => TransactionInitializationAcceptedFaultKind::HostInvariant,
159 }
160}
161
162pub(super) const fn execution_unavailable_retained_outcome()
163-> RetainedTransactionInitializationOutcome {
164 RetainedTransactionInitializationOutcome::Failed(TransactionInitializationFailure {
165 kind: TransactionInitializationFailureKind::ExecutionUnavailable,
166 delivery: TransactionInitializationDeliveryStatus::PossiblySent,
167 })
168}
169
170const fn delivery(status: DeliveryStatus) -> TransactionInitializationDeliveryStatus {
171 match status {
172 DeliveryStatus::NotSent => TransactionInitializationDeliveryStatus::NotSent,
173 DeliveryStatus::PossiblySent => TransactionInitializationDeliveryStatus::PossiblySent,
174 }
175}