kafka_client_engine/admin/list_consumer_groups/
outcome.rs1use core::fmt;
4
5use kafka_client_core::{
6 AdminListConsumerGroupsFailureKind as CoreFailureKind,
7 AdminListConsumerGroupsTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
8};
9
10#[derive(Clone, Copy, Debug, Eq, PartialEq)]
12pub enum ListConsumerGroupsDeliveryStatus {
13 NotSent,
15 PossiblySent,
17}
18
19#[derive(Clone, Debug, Eq, PartialEq)]
21pub struct ConsumerGroupListing {
22 group_id: String,
23 protocol_type: String,
24 group_state: Option<String>,
25 group_type: Option<String>,
26}
27
28impl ConsumerGroupListing {
29 pub fn into_parts(self) -> (String, String, Option<String>, Option<String>) {
31 (
32 self.group_id,
33 self.protocol_type,
34 self.group_state,
35 self.group_type,
36 )
37 }
38}
39
40#[derive(Clone, Copy, Debug, Eq, PartialEq)]
42pub struct ListConsumerGroupsBrokerError {
43 broker_id: i32,
44 code: i16,
45}
46
47impl ListConsumerGroupsBrokerError {
48 pub const fn into_parts(self) -> (i32, i16) {
50 (self.broker_id, self.code)
51 }
52}
53
54#[derive(Clone, Debug, Eq, PartialEq)]
56pub struct ListConsumerGroupsDiscoveryError {
57 code: i16,
58 message: Option<String>,
59 message_truncated: bool,
60}
61
62impl ListConsumerGroupsDiscoveryError {
63 pub fn into_parts(self) -> (i16, Option<String>, bool) {
65 (self.code, self.message, self.message_truncated)
66 }
67}
68
69#[derive(Clone, Debug, Eq, PartialEq)]
71pub struct ListConsumerGroupsBatch {
72 throttle_time_ms: u32,
73 groups: Vec<ConsumerGroupListing>,
74 broker_errors: Vec<ListConsumerGroupsBrokerError>,
75}
76
77impl ListConsumerGroupsBatch {
78 pub fn into_parts(
80 self,
81 ) -> (
82 u32,
83 Vec<ConsumerGroupListing>,
84 Vec<ListConsumerGroupsBrokerError>,
85 ) {
86 (self.throttle_time_ms, self.groups, self.broker_errors)
87 }
88}
89
90#[derive(Clone, Copy, Debug, Eq, PartialEq)]
92pub enum ListConsumerGroupsFailureKind {
93 DeadlineElapsed,
95 DriverRejected,
97 Transport,
99 ResponseTooLarge,
101 Compatibility,
103 InvalidResponse,
105}
106
107#[derive(Clone, Copy, Debug, Eq, PartialEq)]
109pub struct ListConsumerGroupsFailure {
110 kind: ListConsumerGroupsFailureKind,
111 delivery: ListConsumerGroupsDeliveryStatus,
112}
113
114impl ListConsumerGroupsFailure {
115 pub const fn kind(self) -> ListConsumerGroupsFailureKind {
117 self.kind
118 }
119
120 pub const fn delivery(self) -> ListConsumerGroupsDeliveryStatus {
122 self.delivery
123 }
124}
125
126#[derive(Clone, Debug, Eq, PartialEq)]
128pub enum ListConsumerGroupsOutcome {
129 Groups(ListConsumerGroupsBatch),
131 DiscoveryRejected(ListConsumerGroupsDiscoveryError),
133 Failed(ListConsumerGroupsFailure),
135}
136
137#[derive(Clone, Copy, Debug, Eq, PartialEq)]
139pub enum ListConsumerGroupsObserverError {
140 AlreadyObserved,
142 Stale,
144}
145
146impl fmt::Display for ListConsumerGroupsObserverError {
147 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
148 formatter.write_str(match self {
149 Self::AlreadyObserved => "ListConsumerGroups result was already observed",
150 Self::Stale => "ListConsumerGroups observer is stale",
151 })
152 }
153}
154
155impl std::error::Error for ListConsumerGroupsObserverError {}
156
157pub(crate) fn translate_terminal(terminal: CoreTerminal) -> ListConsumerGroupsOutcome {
158 match terminal {
159 CoreTerminal::Listed(batch) => {
160 let (throttle_time_ms, groups, broker_errors) = batch.into_parts();
161 ListConsumerGroupsOutcome::Groups(ListConsumerGroupsBatch {
162 throttle_time_ms,
163 groups: groups
164 .into_iter()
165 .map(|group| {
166 let (group_id, protocol_type, group_state, group_type) = group.into_parts();
167 ConsumerGroupListing {
168 group_id,
169 protocol_type,
170 group_state,
171 group_type,
172 }
173 })
174 .collect(),
175 broker_errors: broker_errors
176 .into_iter()
177 .map(|error| {
178 let (broker_id, code) = error.into_parts();
179 ListConsumerGroupsBrokerError { broker_id, code }
180 })
181 .collect(),
182 })
183 }
184 CoreTerminal::DiscoveryRejected(error) => {
185 let (code, message, message_truncated) = error.into_parts();
186 ListConsumerGroupsOutcome::DiscoveryRejected(ListConsumerGroupsDiscoveryError {
187 code,
188 message,
189 message_truncated,
190 })
191 }
192 CoreTerminal::Failed(failure) => {
193 ListConsumerGroupsOutcome::Failed(ListConsumerGroupsFailure {
194 kind: failure_kind(failure.kind()),
195 delivery: delivery(failure.delivery()),
196 })
197 }
198 }
199}
200
201const fn failure_kind(kind: CoreFailureKind) -> ListConsumerGroupsFailureKind {
202 match kind {
203 CoreFailureKind::DeadlineElapsed => ListConsumerGroupsFailureKind::DeadlineElapsed,
204 CoreFailureKind::DriverRejected => ListConsumerGroupsFailureKind::DriverRejected,
205 CoreFailureKind::Transport => ListConsumerGroupsFailureKind::Transport,
206 CoreFailureKind::ResponseTooLarge => ListConsumerGroupsFailureKind::ResponseTooLarge,
207 CoreFailureKind::Compatibility => ListConsumerGroupsFailureKind::Compatibility,
208 CoreFailureKind::InvalidResponse => ListConsumerGroupsFailureKind::InvalidResponse,
209 }
210}
211
212const fn delivery(status: CoreDeliveryStatus) -> ListConsumerGroupsDeliveryStatus {
213 match status {
214 CoreDeliveryStatus::NotSent => ListConsumerGroupsDeliveryStatus::NotSent,
215 CoreDeliveryStatus::PossiblySent => ListConsumerGroupsDeliveryStatus::PossiblySent,
216 }
217}