Skip to main content

kafka_client_engine/admin/abort_partition_transaction/
outcome.rs

1//! Stable generated-free terminals for one partition transaction abort.
2
3use core::fmt;
4
5use kafka_client_core::{
6    AbortPartitionTransactionFailureKind as CoreFailureKind,
7    AbortPartitionTransactionTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
8};
9
10/// Stable delivery certainty independent of core and driver types.
11#[derive(Clone, Copy, Debug, Eq, PartialEq)]
12pub enum AbortPartitionTransactionDeliveryStatus {
13    /// The destructive call definitely did not reach Kafka transport ownership.
14    NotSent,
15    /// Kafka may have received the destructive call.
16    PossiblySent,
17}
18
19/// Exact signed Kafka rejection for the requested partition.
20#[derive(Clone, Copy, Debug, Eq, PartialEq)]
21pub struct AbortPartitionTransactionBrokerError {
22    code: i16,
23}
24
25impl AbortPartitionTransactionBrokerError {
26    /// Returns Kafka's exact signed nonzero error code.
27    pub const fn code(self) -> i16 {
28        self.code
29    }
30}
31
32/// Stable whole-operation failure category.
33#[derive(Clone, Copy, Debug, Eq, PartialEq)]
34pub enum AbortPartitionTransactionFailureKind {
35    /// The original public absolute deadline elapsed.
36    DeadlineElapsed,
37    /// Driver admission rejected the prepared request.
38    DriverRejected,
39    /// Driver-owned transport execution failed.
40    Transport,
41    /// A valid response exceeded admitted retained capacity.
42    ResponseTooLarge,
43    /// The selected API version cannot represent the abort.
44    Compatibility,
45    /// A response was malformed or contradicted the request identity.
46    InvalidResponse,
47}
48
49/// Whole-operation failure with authoritative delivery certainty.
50#[derive(Clone, Copy, Debug, Eq, PartialEq)]
51pub struct AbortPartitionTransactionFailure {
52    kind: AbortPartitionTransactionFailureKind,
53    delivery: AbortPartitionTransactionDeliveryStatus,
54}
55
56impl AbortPartitionTransactionFailure {
57    /// Returns the stable failure category.
58    pub const fn kind(self) -> AbortPartitionTransactionFailureKind {
59        self.kind
60    }
61
62    /// Returns authoritative delivery certainty.
63    pub const fn delivery(self) -> AbortPartitionTransactionDeliveryStatus {
64        self.delivery
65    }
66}
67
68/// Exactly one engine-owned terminal decision.
69#[derive(Clone, Debug, Eq, PartialEq)]
70pub enum AbortPartitionTransactionOutcome {
71    /// Kafka accepted the abort marker.
72    Aborted,
73    /// Kafka rejected the requested partition with an exact signed code.
74    BrokerRejected(AbortPartitionTransactionBrokerError),
75    /// Execution failed outside an exact Kafka partition rejection.
76    Failed(AbortPartitionTransactionFailure),
77}
78
79/// Failure to observe one named completion.
80#[derive(Clone, Copy, Debug, Eq, PartialEq)]
81pub enum AbortPartitionTransactionObserverError {
82    /// This linear observer already consumed its terminal.
83    AlreadyObserved,
84    /// The observer generation is no longer live.
85    Stale,
86}
87
88impl fmt::Display for AbortPartitionTransactionObserverError {
89    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
90        formatter.write_str(match self {
91            Self::AlreadyObserved => "partition transaction-abort result was already observed",
92            Self::Stale => "partition transaction-abort observer is stale",
93        })
94    }
95}
96
97impl std::error::Error for AbortPartitionTransactionObserverError {}
98
99pub(crate) fn translate_terminal(terminal: CoreTerminal) -> AbortPartitionTransactionOutcome {
100    match terminal {
101        CoreTerminal::Aborted => AbortPartitionTransactionOutcome::Aborted,
102        CoreTerminal::BrokerRejected(error) => {
103            AbortPartitionTransactionOutcome::BrokerRejected(AbortPartitionTransactionBrokerError {
104                code: error.code(),
105            })
106        }
107        CoreTerminal::Failed(failure) => {
108            AbortPartitionTransactionOutcome::Failed(AbortPartitionTransactionFailure {
109                kind: failure_kind(failure.kind()),
110                delivery: delivery(failure.delivery()),
111            })
112        }
113    }
114}
115
116const fn failure_kind(kind: CoreFailureKind) -> AbortPartitionTransactionFailureKind {
117    match kind {
118        CoreFailureKind::DeadlineElapsed => AbortPartitionTransactionFailureKind::DeadlineElapsed,
119        CoreFailureKind::DriverRejected => AbortPartitionTransactionFailureKind::DriverRejected,
120        CoreFailureKind::Transport => AbortPartitionTransactionFailureKind::Transport,
121        CoreFailureKind::ResponseTooLarge => AbortPartitionTransactionFailureKind::ResponseTooLarge,
122        CoreFailureKind::Compatibility => AbortPartitionTransactionFailureKind::Compatibility,
123        CoreFailureKind::InvalidResponse => AbortPartitionTransactionFailureKind::InvalidResponse,
124    }
125}
126
127const fn delivery(status: CoreDeliveryStatus) -> AbortPartitionTransactionDeliveryStatus {
128    match status {
129        CoreDeliveryStatus::NotSent => AbortPartitionTransactionDeliveryStatus::NotSent,
130        CoreDeliveryStatus::PossiblySent => AbortPartitionTransactionDeliveryStatus::PossiblySent,
131    }
132}