Skip to main content

kafka_client_engine/admin/list_transactions/
outcome.rs

1//! Stable engine terminal values for Admin `ListTransactions`.
2
3use core::fmt;
4
5mod translate;
6
7pub(crate) use translate::translate_terminal;
8
9/// Stable delivery certainty independent of core and driver types.
10#[derive(Clone, Copy, Debug, Eq, PartialEq)]
11pub enum AdminListTransactionsDeliveryStatus {
12    /// No discovery or broker request reached the driver.
13    NotSent,
14    /// At least one request may have reached Kafka.
15    PossiblySent,
16}
17
18/// One transaction reported by its current coordinator.
19#[derive(Clone, Debug, Eq, PartialEq)]
20pub struct AdminListedTransaction {
21    transactional_id: String,
22    producer_id: i64,
23    transaction_state: String,
24}
25
26impl AdminListedTransaction {
27    /// Consumes this listing into stable scalar parts.
28    pub fn into_parts(self) -> (String, i64, String) {
29        (
30            self.transactional_id,
31            self.producer_id,
32            self.transaction_state,
33        )
34    }
35}
36
37/// Exact top-level API-key 66 error from one broker.
38#[derive(Clone, Copy, Debug, Eq, PartialEq)]
39pub struct AdminListTransactionsBrokerError {
40    broker_id: i32,
41    code: i16,
42}
43
44impl AdminListTransactionsBrokerError {
45    /// Consumes this error into exact broker and signed-code parts.
46    pub const fn into_parts(self) -> (i32, i16) {
47        (self.broker_id, self.code)
48    }
49}
50
51/// Exact top-level discovery error with bounded diagnostics.
52#[derive(Clone, Debug, Eq, PartialEq)]
53pub struct AdminListTransactionsDiscoveryError {
54    code: i16,
55    message: Option<String>,
56    message_truncated: bool,
57}
58
59impl AdminListTransactionsDiscoveryError {
60    /// Consumes this error into exact diagnostic parts.
61    pub fn into_parts(self) -> (i16, Option<String>, bool) {
62        (self.code, self.message, self.message_truncated)
63    }
64}
65
66/// Successful cluster-wide terminal in deterministic byte order.
67#[derive(Clone, Debug, Eq, PartialEq)]
68pub struct AdminListTransactionsEngineBatch {
69    throttle_time_ms: u32,
70    unknown_state_filters: Vec<String>,
71    transactions: Vec<AdminListedTransaction>,
72    broker_errors: Vec<AdminListTransactionsBrokerError>,
73}
74
75impl AdminListTransactionsEngineBatch {
76    /// Consumes maximum throttle, unknown filters, listings, and exact errors.
77    pub fn into_parts(
78        self,
79    ) -> (
80        u32,
81        Vec<String>,
82        Vec<AdminListedTransaction>,
83        Vec<AdminListTransactionsBrokerError>,
84    ) {
85        (
86            self.throttle_time_ms,
87            self.unknown_state_filters,
88            self.transactions,
89            self.broker_errors,
90        )
91    }
92}
93
94/// Stable whole-operation failure category.
95#[derive(Clone, Copy, Debug, Eq, PartialEq)]
96pub enum AdminListTransactionsFailureKind {
97    /// The original public absolute deadline elapsed.
98    DeadlineElapsed,
99    /// Driver or local request admission rejected the current call.
100    DriverRejected,
101    /// Driver-owned transport execution failed.
102    Transport,
103    /// Valid facts exceeded the admitted retained envelope.
104    ResponseTooLarge,
105    /// The requested filters cannot be represented by the broker version.
106    Compatibility,
107    /// Discovery, response, or cross-broker facts conflicted.
108    InvalidResponse,
109}
110
111/// Whole-operation failure with cumulative delivery certainty.
112#[derive(Clone, Copy, Debug, Eq, PartialEq)]
113pub struct AdminListTransactionsFailure {
114    kind: AdminListTransactionsFailureKind,
115    delivery: AdminListTransactionsDeliveryStatus,
116}
117
118impl AdminListTransactionsFailure {
119    /// Returns the stable failure category.
120    pub const fn kind(self) -> AdminListTransactionsFailureKind {
121        self.kind
122    }
123
124    /// Returns cumulative delivery certainty.
125    pub const fn delivery(self) -> AdminListTransactionsDeliveryStatus {
126        self.delivery
127    }
128}
129
130/// Exactly one engine-owned terminal decision.
131#[derive(Clone, Debug, Eq, PartialEq)]
132pub enum AdminListTransactionsOutcome {
133    /// Discovery and every exact-broker request settled.
134    Listed(AdminListTransactionsEngineBatch),
135    /// Controller-routed discovery returned an exact broker error.
136    DiscoveryRejected(AdminListTransactionsDiscoveryError),
137    /// A mechanism or structural failure stopped the operation.
138    Failed(AdminListTransactionsFailure),
139}
140
141/// Failure to observe one named completion.
142#[derive(Clone, Copy, Debug, Eq, PartialEq)]
143pub enum AdminListTransactionsObserverError {
144    /// This linear observer already consumed its terminal.
145    AlreadyObserved,
146    /// The observer generation is no longer live.
147    Stale,
148}
149
150impl fmt::Display for AdminListTransactionsObserverError {
151    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
152        formatter.write_str(match self {
153            Self::AlreadyObserved => "Admin ListTransactions result was already observed",
154            Self::Stale => "Admin ListTransactions observer is stale",
155        })
156    }
157}
158
159impl std::error::Error for AdminListTransactionsObserverError {}