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