Skip to main content

kafka_client_engine/admin/group_offset_delete/
outcome.rs

1//! Stable engine terminal values for consumer-group offset deletion.
2
3use core::fmt;
4
5use kafka_client_core::{
6    DeleteConsumerGroupOffsetResult as CoreOffsetResult,
7    DeleteConsumerGroupOffsetsFailureKind as CoreFailureKind,
8    DeleteConsumerGroupOffsetsTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
9};
10
11/// Stable delivery certainty independent of core and driver types.
12#[derive(Clone, Copy, Debug, Eq, PartialEq)]
13pub enum DeleteConsumerGroupOffsetsDeliveryStatus {
14    /// The request definitely did not reach Kafka.
15    NotSent,
16    /// The request may have reached Kafka.
17    PossiblySent,
18}
19
20/// Exact broker rejection for one requested topic-partition.
21#[derive(Clone, Copy, Debug, Eq, PartialEq)]
22pub struct DeleteConsumerGroupOffsetBrokerError {
23    code: i16,
24}
25
26impl DeleteConsumerGroupOffsetBrokerError {
27    /// Returns Kafka's exact signed error code.
28    pub const fn code(self) -> i16 {
29        self.code
30    }
31}
32
33/// One caller-ordered topic-partition deletion result.
34#[derive(Clone, Debug, Eq, PartialEq)]
35pub struct DeleteConsumerGroupOffsetResult {
36    topic: String,
37    partition: i32,
38    result: Result<(), DeleteConsumerGroupOffsetBrokerError>,
39}
40
41impl DeleteConsumerGroupOffsetResult {
42    /// Consumes this result into stable identity and exact broker outcome.
43    pub fn into_parts(
44        self,
45    ) -> (
46        String,
47        i32,
48        Result<(), DeleteConsumerGroupOffsetBrokerError>,
49    ) {
50        (self.topic, self.partition, self.result)
51    }
52}
53
54/// Ordered successful result plus Kafka's throttle observation.
55#[derive(Clone, Debug, Eq, PartialEq)]
56pub struct DeleteConsumerGroupOffsetsBatch {
57    throttle_time_ms: u32,
58    offsets: Vec<DeleteConsumerGroupOffsetResult>,
59}
60
61impl DeleteConsumerGroupOffsetsBatch {
62    /// Consumes the batch into throttle and caller-ordered results.
63    pub fn into_parts(self) -> (u32, Vec<DeleteConsumerGroupOffsetResult>) {
64        (self.throttle_time_ms, self.offsets)
65    }
66}
67
68/// Stable whole-operation failure category.
69#[derive(Clone, Copy, Debug, Eq, PartialEq)]
70pub enum DeleteConsumerGroupOffsetsFailureKind {
71    /// The original absolute deadline elapsed.
72    DeadlineElapsed,
73    /// The driver rejected the request before ownership.
74    DriverRejected,
75    /// Driver-owned transport execution failed.
76    Transport,
77    /// Kafka rejected the explicit group with this exact signed code.
78    Broker(i16),
79    /// A valid response exceeded admitted retained capacity.
80    ResponseTooLarge,
81    /// The selected API cannot represent the requested semantics.
82    Compatibility,
83    /// The broker response could not be normalized.
84    InvalidResponse,
85}
86
87/// Whole-operation failure with authoritative delivery certainty.
88#[derive(Clone, Copy, Debug, Eq, PartialEq)]
89pub struct DeleteConsumerGroupOffsetsFailure {
90    kind: DeleteConsumerGroupOffsetsFailureKind,
91    delivery: DeleteConsumerGroupOffsetsDeliveryStatus,
92}
93
94impl DeleteConsumerGroupOffsetsFailure {
95    /// Returns the stable failure category.
96    pub const fn kind(self) -> DeleteConsumerGroupOffsetsFailureKind {
97        self.kind
98    }
99
100    /// Returns authoritative delivery certainty.
101    pub const fn delivery(self) -> DeleteConsumerGroupOffsetsDeliveryStatus {
102        self.delivery
103    }
104}
105
106/// Exactly one engine-owned terminal decision.
107#[derive(Clone, Debug, Eq, PartialEq)]
108pub enum DeleteConsumerGroupOffsetsOutcome {
109    /// Ordered per-partition outcomes plus broker throttle.
110    Deleted(DeleteConsumerGroupOffsetsBatch),
111    /// Whole-operation failure.
112    Failed(DeleteConsumerGroupOffsetsFailure),
113}
114
115/// Failure to observe a named completion.
116#[derive(Clone, Copy, Debug, Eq, PartialEq)]
117pub enum DeleteConsumerGroupOffsetsObserverError {
118    /// This linear observer already consumed its terminal.
119    AlreadyObserved,
120    /// The observer generation is no longer live.
121    Stale,
122}
123
124impl fmt::Display for DeleteConsumerGroupOffsetsObserverError {
125    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
126        formatter.write_str(match self {
127            Self::AlreadyObserved => "DeleteConsumerGroupOffsets result was already observed",
128            Self::Stale => "DeleteConsumerGroupOffsets observer is stale",
129        })
130    }
131}
132
133impl std::error::Error for DeleteConsumerGroupOffsetsObserverError {}
134
135pub(crate) fn translate_terminal(terminal: CoreTerminal) -> DeleteConsumerGroupOffsetsOutcome {
136    match terminal {
137        CoreTerminal::Deleted(batch) => {
138            let (throttle_time_ms, outcomes) = batch.into_parts();
139            DeleteConsumerGroupOffsetsOutcome::Deleted(DeleteConsumerGroupOffsetsBatch {
140                throttle_time_ms,
141                offsets: outcomes
142                    .into_iter()
143                    .map(|outcome| {
144                        let (topic, partition, result) = outcome.into_parts();
145                        let result = match result {
146                            CoreOffsetResult::Deleted => Ok(()),
147                            CoreOffsetResult::Failed(error) => {
148                                Err(DeleteConsumerGroupOffsetBrokerError { code: error.code() })
149                            }
150                        };
151                        DeleteConsumerGroupOffsetResult {
152                            topic,
153                            partition,
154                            result,
155                        }
156                    })
157                    .collect(),
158            })
159        }
160        CoreTerminal::Failed(failure) => {
161            DeleteConsumerGroupOffsetsOutcome::Failed(DeleteConsumerGroupOffsetsFailure {
162                kind: failure_kind(failure.kind()),
163                delivery: delivery(failure.delivery()),
164            })
165        }
166    }
167}
168
169const fn failure_kind(kind: CoreFailureKind) -> DeleteConsumerGroupOffsetsFailureKind {
170    match kind {
171        CoreFailureKind::DeadlineElapsed => DeleteConsumerGroupOffsetsFailureKind::DeadlineElapsed,
172        CoreFailureKind::DriverRejected => DeleteConsumerGroupOffsetsFailureKind::DriverRejected,
173        CoreFailureKind::Transport => DeleteConsumerGroupOffsetsFailureKind::Transport,
174        CoreFailureKind::Broker(code) => DeleteConsumerGroupOffsetsFailureKind::Broker(code.get()),
175        CoreFailureKind::ResponseTooLarge => {
176            DeleteConsumerGroupOffsetsFailureKind::ResponseTooLarge
177        }
178        CoreFailureKind::Compatibility => DeleteConsumerGroupOffsetsFailureKind::Compatibility,
179        CoreFailureKind::InvalidResponse => DeleteConsumerGroupOffsetsFailureKind::InvalidResponse,
180    }
181}
182
183const fn delivery(status: CoreDeliveryStatus) -> DeleteConsumerGroupOffsetsDeliveryStatus {
184    match status {
185        CoreDeliveryStatus::NotSent => DeleteConsumerGroupOffsetsDeliveryStatus::NotSent,
186        CoreDeliveryStatus::PossiblySent => DeleteConsumerGroupOffsetsDeliveryStatus::PossiblySent,
187    }
188}