Skip to main content

kafka_client_engine/admin/remove_consumer_group_members/
outcome.rs

1//! Stable engine terminal values for static consumer-group member removal.
2
3use core::fmt;
4
5use kafka_client_core::{
6    ConsumerGroupMemberRemovalResult as CoreResult, DeliveryStatus as CoreDeliveryStatus,
7    RemoveConsumerGroupMembersFailureKind as CoreFailureKind,
8    RemoveConsumerGroupMembersTerminal as CoreTerminal,
9};
10
11/// Stable delivery certainty independent of core and driver types.
12#[derive(Clone, Copy, Debug, Eq, PartialEq)]
13pub enum RemoveConsumerGroupMembersDeliveryStatus {
14    /// The request definitely did not reach Kafka.
15    NotSent,
16    /// The request may have reached Kafka.
17    PossiblySent,
18}
19
20/// Exact signed broker failure for a request or one selected member.
21#[derive(Clone, Copy, Debug, Eq, PartialEq)]
22pub struct ConsumerGroupMemberRemovalBrokerError {
23    code: i16,
24}
25
26impl ConsumerGroupMemberRemovalBrokerError {
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 per-member result.
34#[derive(Clone, Debug, Eq, PartialEq)]
35pub struct ConsumerGroupMemberRemovalResult {
36    group_instance_id: String,
37    result: Result<(), ConsumerGroupMemberRemovalBrokerError>,
38}
39
40impl ConsumerGroupMemberRemovalResult {
41    /// Consumes the result into static identity and exact broker outcome.
42    pub fn into_parts(self) -> (String, Result<(), ConsumerGroupMemberRemovalBrokerError>) {
43        (self.group_instance_id, self.result)
44    }
45}
46
47/// Ordered successful response plus Kafka's throttle observation.
48#[derive(Clone, Debug, Eq, PartialEq)]
49pub struct RemoveConsumerGroupMembersBatch {
50    throttle_time_ms: u32,
51    members: Vec<ConsumerGroupMemberRemovalResult>,
52}
53
54impl RemoveConsumerGroupMembersBatch {
55    /// Consumes the batch into throttle and caller-ordered member results.
56    pub fn into_parts(self) -> (u32, Vec<ConsumerGroupMemberRemovalResult>) {
57        (self.throttle_time_ms, self.members)
58    }
59}
60
61/// Stable whole-operation failure category.
62#[derive(Clone, Copy, Debug, Eq, PartialEq)]
63pub enum RemoveConsumerGroupMembersFailureKind {
64    /// The original public deadline elapsed.
65    DeadlineElapsed,
66    /// The bounded driver rejected the request before transport ownership.
67    DriverRejected,
68    /// Transport failed after admission.
69    Transport,
70    /// Kafka rejected the named group with this exact signed code.
71    Broker(ConsumerGroupMemberRemovalBrokerError),
72    /// Retaining the broker response exceeded the bounded byte budget.
73    ResponseTooLarge,
74    /// The broker supports no version preserving the selected semantics.
75    Compatibility,
76    /// Kafka returned structurally invalid or uncorrelated data.
77    InvalidResponse,
78}
79
80/// Whole-operation failure with authoritative delivery certainty.
81#[derive(Clone, Copy, Debug, Eq, PartialEq)]
82pub struct RemoveConsumerGroupMembersFailure {
83    kind: RemoveConsumerGroupMembersFailureKind,
84    delivery: RemoveConsumerGroupMembersDeliveryStatus,
85}
86
87impl RemoveConsumerGroupMembersFailure {
88    /// Consumes this failure into stable parts.
89    pub const fn into_parts(
90        self,
91    ) -> (
92        RemoveConsumerGroupMembersFailureKind,
93        RemoveConsumerGroupMembersDeliveryStatus,
94    ) {
95        (self.kind, self.delivery)
96    }
97}
98
99/// Exactly one engine-owned terminal decision.
100#[derive(Clone, Debug, Eq, PartialEq)]
101pub enum RemoveConsumerGroupMembersOutcome {
102    /// Kafka returned caller-correlated per-member outcomes.
103    Removed(RemoveConsumerGroupMembersBatch),
104    /// The whole operation terminated without a valid per-member batch.
105    Failed(RemoveConsumerGroupMembersFailure),
106}
107
108/// Failure to observe one named completion.
109#[derive(Clone, Copy, Debug, Eq, PartialEq)]
110pub enum RemoveConsumerGroupMembersObserverError {
111    /// The retained terminal was already consumed.
112    AlreadyObserved,
113    /// The observer no longer names a retained completion.
114    Stale,
115}
116
117impl fmt::Display for RemoveConsumerGroupMembersObserverError {
118    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
119        formatter.write_str(match self {
120            Self::AlreadyObserved => "RemoveConsumerGroupMembers result was already observed",
121            Self::Stale => "RemoveConsumerGroupMembers observer is stale",
122        })
123    }
124}
125
126impl std::error::Error for RemoveConsumerGroupMembersObserverError {}
127
128pub(crate) fn translate_terminal(terminal: CoreTerminal) -> RemoveConsumerGroupMembersOutcome {
129    match terminal {
130        CoreTerminal::Removed(batch) => {
131            let (throttle_time_ms, outcomes) = batch.into_parts();
132            RemoveConsumerGroupMembersOutcome::Removed(RemoveConsumerGroupMembersBatch {
133                throttle_time_ms,
134                members: outcomes
135                    .into_iter()
136                    .map(|outcome| {
137                        let (group_instance_id, result) = outcome.into_parts();
138                        ConsumerGroupMemberRemovalResult {
139                            group_instance_id,
140                            result: match result {
141                                CoreResult::Removed => Ok(()),
142                                CoreResult::Failed(error) => Err(broker_error(error.code())),
143                            },
144                        }
145                    })
146                    .collect(),
147            })
148        }
149        CoreTerminal::Failed(failure) => {
150            RemoveConsumerGroupMembersOutcome::Failed(RemoveConsumerGroupMembersFailure {
151                kind: failure_kind(failure.kind()),
152                delivery: delivery_status(failure.delivery()),
153            })
154        }
155    }
156}
157
158const fn broker_error(code: i16) -> ConsumerGroupMemberRemovalBrokerError {
159    ConsumerGroupMemberRemovalBrokerError { code }
160}
161
162fn failure_kind(kind: CoreFailureKind) -> RemoveConsumerGroupMembersFailureKind {
163    match kind {
164        CoreFailureKind::DeadlineElapsed => RemoveConsumerGroupMembersFailureKind::DeadlineElapsed,
165        CoreFailureKind::DriverRejected => RemoveConsumerGroupMembersFailureKind::DriverRejected,
166        CoreFailureKind::Transport => RemoveConsumerGroupMembersFailureKind::Transport,
167        CoreFailureKind::Broker(code) => {
168            RemoveConsumerGroupMembersFailureKind::Broker(broker_error(code.get()))
169        }
170        CoreFailureKind::ResponseTooLarge => {
171            RemoveConsumerGroupMembersFailureKind::ResponseTooLarge
172        }
173        CoreFailureKind::Compatibility => RemoveConsumerGroupMembersFailureKind::Compatibility,
174        CoreFailureKind::InvalidResponse => RemoveConsumerGroupMembersFailureKind::InvalidResponse,
175    }
176}
177
178const fn delivery_status(delivery: CoreDeliveryStatus) -> RemoveConsumerGroupMembersDeliveryStatus {
179    match delivery {
180        CoreDeliveryStatus::NotSent => RemoveConsumerGroupMembersDeliveryStatus::NotSent,
181        CoreDeliveryStatus::PossiblySent => RemoveConsumerGroupMembersDeliveryStatus::PossiblySent,
182    }
183}