use core::fmt;
use kafka_client_core::{
DeleteConsumerGroupOffsetResult as CoreOffsetResult,
DeleteConsumerGroupOffsetsFailureKind as CoreFailureKind,
DeleteConsumerGroupOffsetsTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DeleteConsumerGroupOffsetsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DeleteConsumerGroupOffsetBrokerError {
code: i16,
}
impl DeleteConsumerGroupOffsetBrokerError {
pub const fn code(self) -> i16 {
self.code
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DeleteConsumerGroupOffsetResult {
topic: String,
partition: i32,
result: Result<(), DeleteConsumerGroupOffsetBrokerError>,
}
impl DeleteConsumerGroupOffsetResult {
pub fn into_parts(
self,
) -> (
String,
i32,
Result<(), DeleteConsumerGroupOffsetBrokerError>,
) {
(self.topic, self.partition, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DeleteConsumerGroupOffsetsBatch {
throttle_time_ms: u32,
offsets: Vec<DeleteConsumerGroupOffsetResult>,
}
impl DeleteConsumerGroupOffsetsBatch {
pub fn into_parts(self) -> (u32, Vec<DeleteConsumerGroupOffsetResult>) {
(self.throttle_time_ms, self.offsets)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DeleteConsumerGroupOffsetsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
Broker(i16),
ResponseTooLarge,
Compatibility,
InvalidResponse,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DeleteConsumerGroupOffsetsFailure {
kind: DeleteConsumerGroupOffsetsFailureKind,
delivery: DeleteConsumerGroupOffsetsDeliveryStatus,
}
impl DeleteConsumerGroupOffsetsFailure {
pub const fn kind(self) -> DeleteConsumerGroupOffsetsFailureKind {
self.kind
}
pub const fn delivery(self) -> DeleteConsumerGroupOffsetsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DeleteConsumerGroupOffsetsOutcome {
Deleted(DeleteConsumerGroupOffsetsBatch),
Failed(DeleteConsumerGroupOffsetsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DeleteConsumerGroupOffsetsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for DeleteConsumerGroupOffsetsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "DeleteConsumerGroupOffsets result was already observed",
Self::Stale => "DeleteConsumerGroupOffsets observer is stale",
})
}
}
impl std::error::Error for DeleteConsumerGroupOffsetsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> DeleteConsumerGroupOffsetsOutcome {
match terminal {
CoreTerminal::Deleted(batch) => {
let (throttle_time_ms, outcomes) = batch.into_parts();
DeleteConsumerGroupOffsetsOutcome::Deleted(DeleteConsumerGroupOffsetsBatch {
throttle_time_ms,
offsets: outcomes
.into_iter()
.map(|outcome| {
let (topic, partition, result) = outcome.into_parts();
let result = match result {
CoreOffsetResult::Deleted => Ok(()),
CoreOffsetResult::Failed(error) => {
Err(DeleteConsumerGroupOffsetBrokerError { code: error.code() })
}
};
DeleteConsumerGroupOffsetResult {
topic,
partition,
result,
}
})
.collect(),
})
}
CoreTerminal::Failed(failure) => {
DeleteConsumerGroupOffsetsOutcome::Failed(DeleteConsumerGroupOffsetsFailure {
kind: failure_kind(failure.kind()),
delivery: delivery(failure.delivery()),
})
}
}
}
const fn failure_kind(kind: CoreFailureKind) -> DeleteConsumerGroupOffsetsFailureKind {
match kind {
CoreFailureKind::DeadlineElapsed => DeleteConsumerGroupOffsetsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => DeleteConsumerGroupOffsetsFailureKind::DriverRejected,
CoreFailureKind::Transport => DeleteConsumerGroupOffsetsFailureKind::Transport,
CoreFailureKind::Broker(code) => DeleteConsumerGroupOffsetsFailureKind::Broker(code.get()),
CoreFailureKind::ResponseTooLarge => {
DeleteConsumerGroupOffsetsFailureKind::ResponseTooLarge
}
CoreFailureKind::Compatibility => DeleteConsumerGroupOffsetsFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => DeleteConsumerGroupOffsetsFailureKind::InvalidResponse,
}
}
const fn delivery(status: CoreDeliveryStatus) -> DeleteConsumerGroupOffsetsDeliveryStatus {
match status {
CoreDeliveryStatus::NotSent => DeleteConsumerGroupOffsetsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => DeleteConsumerGroupOffsetsDeliveryStatus::PossiblySent,
}
}