use kafka_client_core::{
DeliveryStatus, TransactionInitializationBrokerCategory,
TransactionInitializationFailureKind as CoreFailureKind, TransactionInitializationTerminal,
};
use super::{
RetainedTransactionInitializationOutcome, TransactionInitializationHostError,
TransactionInitializationObserver, TransactionalOwnerHandle,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionInitializationAcceptedFaultKind {
Wake,
HostInvariant,
}
#[derive(Debug)]
#[must_use = "accepted initialization retains its sole terminal observer"]
pub struct TransactionInitializationAccepted {
pub(super) observer: TransactionInitializationObserver,
pub(super) fault: Option<TransactionInitializationAcceptedFaultKind>,
}
impl TransactionInitializationAccepted {
pub const fn fault(&self) -> Option<TransactionInitializationAcceptedFaultKind> {
self.fault
}
pub fn into_observer(self) -> TransactionInitializationObserver {
self.observer
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionInitializationDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionInitializationFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
Broker {
code: i16,
fenced: bool,
},
InvalidResponse,
ExecutionUnavailable,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct TransactionInitializationFailure {
pub(crate) kind: TransactionInitializationFailureKind,
pub(crate) delivery: TransactionInitializationDeliveryStatus,
}
impl TransactionInitializationFailure {
pub const fn kind(self) -> TransactionInitializationFailureKind {
self.kind
}
pub const fn delivery(self) -> TransactionInitializationDeliveryStatus {
self.delivery
}
}
#[derive(Debug)]
pub enum TransactionInitializationOutcome {
Initialized(TransactionalOwnerHandle),
Failed(TransactionInitializationFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionInitializationObserverError {
AlreadyObserved,
Stale,
}
impl std::fmt::Display for TransactionInitializationObserverError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "transaction initialization was already observed",
Self::Stale => "transaction initialization observer is stale",
})
}
}
impl std::error::Error for TransactionInitializationObserverError {}
pub(super) fn failed_retained_outcome(
terminal: TransactionInitializationTerminal,
) -> Option<RetainedTransactionInitializationOutcome> {
let TransactionInitializationTerminal::Failed(failure) = terminal else {
return None;
};
let kind = match failure.kind() {
CoreFailureKind::DeadlineElapsed => {
self::TransactionInitializationFailureKind::DeadlineElapsed
}
CoreFailureKind::DriverRejected => {
self::TransactionInitializationFailureKind::DriverRejected
}
CoreFailureKind::Transport => self::TransactionInitializationFailureKind::Transport,
CoreFailureKind::Broker(broker) => self::TransactionInitializationFailureKind::Broker {
code: broker.code(),
fenced: broker.category() == TransactionInitializationBrokerCategory::Fenced,
},
CoreFailureKind::InvalidResponse => {
self::TransactionInitializationFailureKind::InvalidResponse
}
};
Some(RetainedTransactionInitializationOutcome::Failed(
TransactionInitializationFailure {
kind,
delivery: delivery(failure.delivery()),
},
))
}
pub(super) const fn accepted_fault(
error: TransactionInitializationHostError,
) -> TransactionInitializationAcceptedFaultKind {
match error {
TransactionInitializationHostError::Wake => {
TransactionInitializationAcceptedFaultKind::Wake
}
_ => TransactionInitializationAcceptedFaultKind::HostInvariant,
}
}
pub(super) const fn execution_unavailable_retained_outcome()
-> RetainedTransactionInitializationOutcome {
RetainedTransactionInitializationOutcome::Failed(TransactionInitializationFailure {
kind: TransactionInitializationFailureKind::ExecutionUnavailable,
delivery: TransactionInitializationDeliveryStatus::PossiblySent,
})
}
const fn delivery(status: DeliveryStatus) -> TransactionInitializationDeliveryStatus {
match status {
DeliveryStatus::NotSent => TransactionInitializationDeliveryStatus::NotSent,
DeliveryStatus::PossiblySent => TransactionInitializationDeliveryStatus::PossiblySent,
}
}