use core::fmt;
use kafka_client_core::{
AbortPartitionTransactionFailureKind as CoreFailureKind,
AbortPartitionTransactionTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AbortPartitionTransactionDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AbortPartitionTransactionBrokerError {
code: i16,
}
impl AbortPartitionTransactionBrokerError {
pub const fn code(self) -> i16 {
self.code
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AbortPartitionTransactionFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
ResponseTooLarge,
Compatibility,
InvalidResponse,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AbortPartitionTransactionFailure {
kind: AbortPartitionTransactionFailureKind,
delivery: AbortPartitionTransactionDeliveryStatus,
}
impl AbortPartitionTransactionFailure {
pub const fn kind(self) -> AbortPartitionTransactionFailureKind {
self.kind
}
pub const fn delivery(self) -> AbortPartitionTransactionDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum AbortPartitionTransactionOutcome {
Aborted,
BrokerRejected(AbortPartitionTransactionBrokerError),
Failed(AbortPartitionTransactionFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AbortPartitionTransactionObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for AbortPartitionTransactionObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "partition transaction-abort result was already observed",
Self::Stale => "partition transaction-abort observer is stale",
})
}
}
impl std::error::Error for AbortPartitionTransactionObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> AbortPartitionTransactionOutcome {
match terminal {
CoreTerminal::Aborted => AbortPartitionTransactionOutcome::Aborted,
CoreTerminal::BrokerRejected(error) => {
AbortPartitionTransactionOutcome::BrokerRejected(AbortPartitionTransactionBrokerError {
code: error.code(),
})
}
CoreTerminal::Failed(failure) => {
AbortPartitionTransactionOutcome::Failed(AbortPartitionTransactionFailure {
kind: failure_kind(failure.kind()),
delivery: delivery(failure.delivery()),
})
}
}
}
const fn failure_kind(kind: CoreFailureKind) -> AbortPartitionTransactionFailureKind {
match kind {
CoreFailureKind::DeadlineElapsed => AbortPartitionTransactionFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => AbortPartitionTransactionFailureKind::DriverRejected,
CoreFailureKind::Transport => AbortPartitionTransactionFailureKind::Transport,
CoreFailureKind::ResponseTooLarge => AbortPartitionTransactionFailureKind::ResponseTooLarge,
CoreFailureKind::Compatibility => AbortPartitionTransactionFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => AbortPartitionTransactionFailureKind::InvalidResponse,
}
}
const fn delivery(status: CoreDeliveryStatus) -> AbortPartitionTransactionDeliveryStatus {
match status {
CoreDeliveryStatus::NotSent => AbortPartitionTransactionDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => AbortPartitionTransactionDeliveryStatus::PossiblySent,
}
}