use core::fmt;
use kafka_client_core::{
AdminListConsumerGroupsFailureKind as CoreFailureKind,
AdminListConsumerGroupsTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ListConsumerGroupsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ConsumerGroupListing {
group_id: String,
protocol_type: String,
group_state: Option<String>,
group_type: Option<String>,
}
impl ConsumerGroupListing {
pub fn into_parts(self) -> (String, String, Option<String>, Option<String>) {
(
self.group_id,
self.protocol_type,
self.group_state,
self.group_type,
)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ListConsumerGroupsBrokerError {
broker_id: i32,
code: i16,
}
impl ListConsumerGroupsBrokerError {
pub const fn into_parts(self) -> (i32, i16) {
(self.broker_id, self.code)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ListConsumerGroupsDiscoveryError {
code: i16,
message: Option<String>,
message_truncated: bool,
}
impl ListConsumerGroupsDiscoveryError {
pub fn into_parts(self) -> (i16, Option<String>, bool) {
(self.code, self.message, self.message_truncated)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ListConsumerGroupsBatch {
throttle_time_ms: u32,
groups: Vec<ConsumerGroupListing>,
broker_errors: Vec<ListConsumerGroupsBrokerError>,
}
impl ListConsumerGroupsBatch {
pub fn into_parts(
self,
) -> (
u32,
Vec<ConsumerGroupListing>,
Vec<ListConsumerGroupsBrokerError>,
) {
(self.throttle_time_ms, self.groups, self.broker_errors)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ListConsumerGroupsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
ResponseTooLarge,
Compatibility,
InvalidResponse,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ListConsumerGroupsFailure {
kind: ListConsumerGroupsFailureKind,
delivery: ListConsumerGroupsDeliveryStatus,
}
impl ListConsumerGroupsFailure {
pub const fn kind(self) -> ListConsumerGroupsFailureKind {
self.kind
}
pub const fn delivery(self) -> ListConsumerGroupsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ListConsumerGroupsOutcome {
Groups(ListConsumerGroupsBatch),
DiscoveryRejected(ListConsumerGroupsDiscoveryError),
Failed(ListConsumerGroupsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ListConsumerGroupsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for ListConsumerGroupsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "ListConsumerGroups result was already observed",
Self::Stale => "ListConsumerGroups observer is stale",
})
}
}
impl std::error::Error for ListConsumerGroupsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> ListConsumerGroupsOutcome {
match terminal {
CoreTerminal::Listed(batch) => {
let (throttle_time_ms, groups, broker_errors) = batch.into_parts();
ListConsumerGroupsOutcome::Groups(ListConsumerGroupsBatch {
throttle_time_ms,
groups: groups
.into_iter()
.map(|group| {
let (group_id, protocol_type, group_state, group_type) = group.into_parts();
ConsumerGroupListing {
group_id,
protocol_type,
group_state,
group_type,
}
})
.collect(),
broker_errors: broker_errors
.into_iter()
.map(|error| {
let (broker_id, code) = error.into_parts();
ListConsumerGroupsBrokerError { broker_id, code }
})
.collect(),
})
}
CoreTerminal::DiscoveryRejected(error) => {
let (code, message, message_truncated) = error.into_parts();
ListConsumerGroupsOutcome::DiscoveryRejected(ListConsumerGroupsDiscoveryError {
code,
message,
message_truncated,
})
}
CoreTerminal::Failed(failure) => {
ListConsumerGroupsOutcome::Failed(ListConsumerGroupsFailure {
kind: failure_kind(failure.kind()),
delivery: delivery(failure.delivery()),
})
}
}
}
const fn failure_kind(kind: CoreFailureKind) -> ListConsumerGroupsFailureKind {
match kind {
CoreFailureKind::DeadlineElapsed => ListConsumerGroupsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => ListConsumerGroupsFailureKind::DriverRejected,
CoreFailureKind::Transport => ListConsumerGroupsFailureKind::Transport,
CoreFailureKind::ResponseTooLarge => ListConsumerGroupsFailureKind::ResponseTooLarge,
CoreFailureKind::Compatibility => ListConsumerGroupsFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => ListConsumerGroupsFailureKind::InvalidResponse,
}
}
const fn delivery(status: CoreDeliveryStatus) -> ListConsumerGroupsDeliveryStatus {
match status {
CoreDeliveryStatus::NotSent => ListConsumerGroupsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => ListConsumerGroupsDeliveryStatus::PossiblySent,
}
}