use core::fmt;
use kafka_client_core::{
AdminListOffsetResult as CoreResult, AdminListOffsetsFailureKind as CoreFailureKind,
AdminListOffsetsTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AdminListOffsetsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AdminListOffsetEngineBrokerError {
code: i16,
}
impl AdminListOffsetEngineBrokerError {
pub const fn code(self) -> i16 {
self.code
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AdminListOffsetDescription {
offset: Option<i64>,
timestamp_ms: Option<i64>,
leader_epoch: Option<i32>,
}
impl AdminListOffsetDescription {
pub const fn into_parts(self) -> (Option<i64>, Option<i64>, Option<i32>) {
(self.offset, self.timestamp_ms, self.leader_epoch)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AdminListOffsetEngineResult {
topic: String,
partition: i32,
result: Result<AdminListOffsetDescription, AdminListOffsetEngineBrokerError>,
}
impl AdminListOffsetEngineResult {
pub fn into_parts(
self,
) -> (
String,
i32,
Result<AdminListOffsetDescription, AdminListOffsetEngineBrokerError>,
) {
(self.topic, self.partition, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AdminListOffsetsEngineBatch {
throttle_time_ms: u32,
offsets: Vec<AdminListOffsetEngineResult>,
}
impl AdminListOffsetsEngineBatch {
pub fn into_parts(self) -> (u32, Vec<AdminListOffsetEngineResult>) {
(self.throttle_time_ms, self.offsets)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AdminListOffsetsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
ResponseTooLarge,
Compatibility,
InvalidResponse,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AdminListOffsetsFailure {
kind: AdminListOffsetsFailureKind,
delivery: AdminListOffsetsDeliveryStatus,
}
impl AdminListOffsetsFailure {
pub const fn kind(self) -> AdminListOffsetsFailureKind {
self.kind
}
pub const fn delivery(self) -> AdminListOffsetsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum AdminListOffsetsOutcome {
Offsets(AdminListOffsetsEngineBatch),
Failed(AdminListOffsetsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AdminListOffsetsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for AdminListOffsetsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "Admin ListOffsets result was already observed",
Self::Stale => "Admin ListOffsets observer is stale",
})
}
}
impl std::error::Error for AdminListOffsetsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> AdminListOffsetsOutcome {
match terminal {
CoreTerminal::Listed(batch) => {
let (throttle_time_ms, outcomes) = batch.into_parts();
AdminListOffsetsOutcome::Offsets(AdminListOffsetsEngineBatch {
throttle_time_ms,
offsets: outcomes
.into_iter()
.map(|outcome| {
let (topic, partition, result) = outcome.into_parts();
let result = match result {
CoreResult::Listed(value) => Ok(AdminListOffsetDescription {
offset: value.offset(),
timestamp_ms: value.timestamp_ms(),
leader_epoch: value.leader_epoch(),
}),
CoreResult::Failed(error) => {
Err(AdminListOffsetEngineBrokerError { code: error.code() })
}
};
AdminListOffsetEngineResult {
topic,
partition,
result,
}
})
.collect(),
})
}
CoreTerminal::Failed(failure) => AdminListOffsetsOutcome::Failed(AdminListOffsetsFailure {
kind: failure_kind(failure.kind()),
delivery: delivery(failure.delivery()),
}),
}
}
const fn failure_kind(kind: CoreFailureKind) -> AdminListOffsetsFailureKind {
match kind {
CoreFailureKind::DeadlineElapsed => AdminListOffsetsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => AdminListOffsetsFailureKind::DriverRejected,
CoreFailureKind::Transport => AdminListOffsetsFailureKind::Transport,
CoreFailureKind::ResponseTooLarge => AdminListOffsetsFailureKind::ResponseTooLarge,
CoreFailureKind::Compatibility => AdminListOffsetsFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => AdminListOffsetsFailureKind::InvalidResponse,
}
}
const fn delivery(status: CoreDeliveryStatus) -> AdminListOffsetsDeliveryStatus {
match status {
CoreDeliveryStatus::NotSent => AdminListOffsetsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => AdminListOffsetsDeliveryStatus::PossiblySent,
}
}