Skip to main content

kafka_client_engine/transaction/initialization/
error.rs

1//! Local rejection and retained transaction-host invariant failures.
2
3use core::fmt;
4
5use kafka_client_core::TransactionInitializationMachineError;
6
7use crate::completion::CompletionRegistryError;
8
9use super::TransactionInitializationRequest;
10use crate::transaction::TransactionLifecycleHostError;
11
12/// Failure to capture the public operation deadline.
13#[derive(Clone, Copy, Debug, Eq, PartialEq)]
14pub enum TransactionInitializationCaptureError {
15    /// The requested duration cannot form one positive absolute deadline.
16    InvalidOperationDeadline,
17}
18
19impl fmt::Display for TransactionInitializationCaptureError {
20    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
21        formatter.write_str("transaction initialization deadline is invalid")
22    }
23}
24
25impl std::error::Error for TransactionInitializationCaptureError {}
26
27/// Local rejection before the driver owns transaction initialization.
28#[derive(Clone, Copy, Debug, Eq, PartialEq)]
29pub enum TransactionInitializationAdmissionErrorKind {
30    /// The transactional ID or broker timeout is invalid.
31    InvalidRequest,
32    /// The bounded owner lock is currently contended.
33    Contended,
34    /// Engine shutdown has closed initialization admission.
35    Closed,
36    /// The bounded operation or terminal registry is full.
37    Capacity,
38    /// The bounded transactional-ID envelope is exhausted.
39    RetainedBytes,
40    /// The engine's nonreused identity space is exhausted.
41    IdentityExhausted,
42    /// The concrete transaction host is unavailable.
43    HostUnavailable,
44}
45
46/// Local admission rejection retaining the exact engine request.
47#[must_use = "local rejection retains the exact caller input"]
48pub struct TransactionInitializationAdmissionError {
49    kind: TransactionInitializationAdmissionErrorKind,
50    request: TransactionInitializationRequest,
51}
52
53impl TransactionInitializationAdmissionError {
54    pub(super) const fn new(
55        kind: TransactionInitializationAdmissionErrorKind,
56        request: TransactionInitializationRequest,
57    ) -> Self {
58        Self { kind, request }
59    }
60
61    /// Returns the stable rejection category.
62    pub const fn kind(&self) -> TransactionInitializationAdmissionErrorKind {
63        self.kind
64    }
65
66    /// Returns the exact request rejected before driver ownership.
67    pub fn into_request(self) -> TransactionInitializationRequest {
68        self.request
69    }
70}
71
72impl fmt::Debug for TransactionInitializationAdmissionError {
73    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
74        formatter
75            .debug_struct("TransactionInitializationAdmissionError")
76            .field("kind", &self.kind)
77            .field("request", &self.request)
78            .finish()
79    }
80}
81
82impl fmt::Display for TransactionInitializationAdmissionError {
83    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
84        let kind = self.kind;
85        write!(
86            formatter,
87            "transaction initialization admission failed: {kind:?}"
88        )
89    }
90}
91
92impl std::error::Error for TransactionInitializationAdmissionError {}
93
94#[derive(Clone, Copy, Debug, Eq, PartialEq)]
95pub(crate) enum TransactionInitializationHostError {
96    Machine(TransactionInitializationMachineError),
97    Completion(CompletionRegistryError),
98    UnknownOperation,
99    UnexpectedEffect,
100    MissingTerminal,
101    CallCompletion,
102    ByteAccounting,
103    OwnerRelease,
104    Lifecycle(TransactionLifecycleHostError),
105    Wake,
106    Unsettled(usize),
107}
108
109impl From<TransactionInitializationMachineError> for TransactionInitializationHostError {
110    fn from(error: TransactionInitializationMachineError) -> Self {
111        Self::Machine(error)
112    }
113}
114
115impl From<CompletionRegistryError> for TransactionInitializationHostError {
116    fn from(error: CompletionRegistryError) -> Self {
117        Self::Completion(error)
118    }
119}
120
121impl From<TransactionLifecycleHostError> for TransactionInitializationHostError {
122    fn from(error: TransactionLifecycleHostError) -> Self {
123        Self::Lifecycle(error)
124    }
125}
126
127impl fmt::Display for TransactionInitializationHostError {
128    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
129        write!(
130            formatter,
131            "transaction initialization host failed: {self:?}"
132        )
133    }
134}
135
136impl std::error::Error for TransactionInitializationHostError {}