use core::fmt;
use kafka_client_core::{
DeleteConsumerGroupsFailureKind as CoreFailureKind, DeleteConsumerGroupsResult as CoreResult,
DeleteConsumerGroupsTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DeleteConsumerGroupsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DeleteConsumerGroupsEngineBrokerError {
code: i16,
message: Option<String>,
message_truncated: bool,
}
impl DeleteConsumerGroupsEngineBrokerError {
pub const fn code(&self) -> i16 {
self.code
}
pub fn message(&self) -> Option<&str> {
self.message.as_deref()
}
pub const fn message_truncated(&self) -> bool {
self.message_truncated
}
pub fn into_parts(self) -> (i16, Option<String>, bool) {
(self.code, self.message, self.message_truncated)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DeleteConsumerGroupsEngineResult {
group_id: String,
result: Result<(), DeleteConsumerGroupsEngineBrokerError>,
}
impl DeleteConsumerGroupsEngineResult {
pub fn into_parts(self) -> (String, Result<(), DeleteConsumerGroupsEngineBrokerError>) {
(self.group_id, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DeleteConsumerGroupsEngineBatch {
throttle_time_ms: u32,
groups: Vec<DeleteConsumerGroupsEngineResult>,
}
impl DeleteConsumerGroupsEngineBatch {
pub fn into_parts(self) -> (u32, Vec<DeleteConsumerGroupsEngineResult>) {
(self.throttle_time_ms, self.groups)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DeleteConsumerGroupsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
ResponseTooLarge,
Compatibility,
InvalidResponse,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DeleteConsumerGroupsFailure {
kind: DeleteConsumerGroupsFailureKind,
delivery: DeleteConsumerGroupsDeliveryStatus,
throttle_time_ms: u32,
completed: Vec<DeleteConsumerGroupsEngineResult>,
failed_group_id: String,
unattempted_group_ids: Vec<String>,
}
impl DeleteConsumerGroupsFailure {
pub const fn kind(&self) -> DeleteConsumerGroupsFailureKind {
self.kind
}
pub const fn delivery(&self) -> DeleteConsumerGroupsDeliveryStatus {
self.delivery
}
pub fn into_parts(
self,
) -> (
DeleteConsumerGroupsFailureKind,
DeleteConsumerGroupsDeliveryStatus,
u32,
Vec<DeleteConsumerGroupsEngineResult>,
String,
Vec<String>,
) {
(
self.kind,
self.delivery,
self.throttle_time_ms,
self.completed,
self.failed_group_id,
self.unattempted_group_ids,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DeleteConsumerGroupsOutcome {
Deleted(DeleteConsumerGroupsEngineBatch),
Failed(DeleteConsumerGroupsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DeleteConsumerGroupsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for DeleteConsumerGroupsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "Admin DeleteConsumerGroups result was already observed",
Self::Stale => "Admin DeleteConsumerGroups observer is stale",
})
}
}
impl std::error::Error for DeleteConsumerGroupsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> DeleteConsumerGroupsOutcome {
match terminal {
CoreTerminal::Deleted(batch) => {
let (throttle_time_ms, outcomes) = batch.into_parts();
DeleteConsumerGroupsOutcome::Deleted(DeleteConsumerGroupsEngineBatch {
throttle_time_ms,
groups: outcomes.into_iter().map(translate_result).collect(),
})
}
CoreTerminal::Failed(failure) => {
let (kind, delivery_status, throttle_time_ms, completed, failed, unattempted) =
failure.into_parts();
DeleteConsumerGroupsOutcome::Failed(DeleteConsumerGroupsFailure {
kind: failure_kind(kind),
delivery: delivery(delivery_status),
throttle_time_ms,
completed: completed.into_iter().map(translate_result).collect(),
failed_group_id: failed.group_id().to_owned(),
unattempted_group_ids: unattempted
.into_iter()
.map(|target| target.group_id().to_owned())
.collect(),
})
}
}
}
fn translate_result(
outcome: kafka_client_core::DeleteConsumerGroupsOutcome,
) -> DeleteConsumerGroupsEngineResult {
let (group_id, result) = outcome.into_parts();
let result = match result {
CoreResult::Deleted => Ok(()),
CoreResult::Failed(error) => {
let (code, message, message_truncated) = error.into_parts();
Err(DeleteConsumerGroupsEngineBrokerError {
code,
message,
message_truncated,
})
}
};
DeleteConsumerGroupsEngineResult { group_id, result }
}
const fn failure_kind(kind: CoreFailureKind) -> DeleteConsumerGroupsFailureKind {
match kind {
CoreFailureKind::DeadlineElapsed => DeleteConsumerGroupsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => DeleteConsumerGroupsFailureKind::DriverRejected,
CoreFailureKind::Transport => DeleteConsumerGroupsFailureKind::Transport,
CoreFailureKind::ResponseTooLarge => DeleteConsumerGroupsFailureKind::ResponseTooLarge,
CoreFailureKind::Compatibility => DeleteConsumerGroupsFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => DeleteConsumerGroupsFailureKind::InvalidResponse,
}
}
const fn delivery(status: CoreDeliveryStatus) -> DeleteConsumerGroupsDeliveryStatus {
match status {
CoreDeliveryStatus::NotSent => DeleteConsumerGroupsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => DeleteConsumerGroupsDeliveryStatus::PossiblySent,
}
}