kafka_client_engine/admin/group_offset_delete/
outcome.rs1use 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#[derive(Clone, Copy, Debug, Eq, PartialEq)]
13pub enum DeleteConsumerGroupOffsetsDeliveryStatus {
14 NotSent,
16 PossiblySent,
18}
19
20#[derive(Clone, Copy, Debug, Eq, PartialEq)]
22pub struct DeleteConsumerGroupOffsetBrokerError {
23 code: i16,
24}
25
26impl DeleteConsumerGroupOffsetBrokerError {
27 pub const fn code(self) -> i16 {
29 self.code
30 }
31}
32
33#[derive(Clone, Debug, Eq, PartialEq)]
35pub struct DeleteConsumerGroupOffsetResult {
36 topic: String,
37 partition: i32,
38 result: Result<(), DeleteConsumerGroupOffsetBrokerError>,
39}
40
41impl DeleteConsumerGroupOffsetResult {
42 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#[derive(Clone, Debug, Eq, PartialEq)]
56pub struct DeleteConsumerGroupOffsetsBatch {
57 throttle_time_ms: u32,
58 offsets: Vec<DeleteConsumerGroupOffsetResult>,
59}
60
61impl DeleteConsumerGroupOffsetsBatch {
62 pub fn into_parts(self) -> (u32, Vec<DeleteConsumerGroupOffsetResult>) {
64 (self.throttle_time_ms, self.offsets)
65 }
66}
67
68#[derive(Clone, Copy, Debug, Eq, PartialEq)]
70pub enum DeleteConsumerGroupOffsetsFailureKind {
71 DeadlineElapsed,
73 DriverRejected,
75 Transport,
77 Broker(i16),
79 ResponseTooLarge,
81 Compatibility,
83 InvalidResponse,
85}
86
87#[derive(Clone, Copy, Debug, Eq, PartialEq)]
89pub struct DeleteConsumerGroupOffsetsFailure {
90 kind: DeleteConsumerGroupOffsetsFailureKind,
91 delivery: DeleteConsumerGroupOffsetsDeliveryStatus,
92}
93
94impl DeleteConsumerGroupOffsetsFailure {
95 pub const fn kind(self) -> DeleteConsumerGroupOffsetsFailureKind {
97 self.kind
98 }
99
100 pub const fn delivery(self) -> DeleteConsumerGroupOffsetsDeliveryStatus {
102 self.delivery
103 }
104}
105
106#[derive(Clone, Debug, Eq, PartialEq)]
108pub enum DeleteConsumerGroupOffsetsOutcome {
109 Deleted(DeleteConsumerGroupOffsetsBatch),
111 Failed(DeleteConsumerGroupOffsetsFailure),
113}
114
115#[derive(Clone, Copy, Debug, Eq, PartialEq)]
117pub enum DeleteConsumerGroupOffsetsObserverError {
118 AlreadyObserved,
120 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}