use kafka_client_core::{
DeliveryStatus, TransactionOffsetCommitId, TransactionOffsetCommitMachineError,
TransactionOffsetCommitStage,
};
use crate::completion::CompletionObserver;
use super::input::TransactionOffsetCommitRequest;
#[must_use = "accepted transactional offsets require terminal observation or transfer"]
pub(crate) struct TransactionOffsetCommitAccepted {
operation_id: TransactionOffsetCommitId,
observer: CompletionObserver<TransactionOffsetCommitResult>,
}
impl TransactionOffsetCommitAccepted {
pub(in crate::transaction) const fn new(
operation_id: TransactionOffsetCommitId,
observer: CompletionObserver<TransactionOffsetCommitResult>,
) -> Self {
Self {
operation_id,
observer,
}
}
pub(crate) const fn operation_id(&self) -> TransactionOffsetCommitId {
self.operation_id
}
pub(crate) fn into_observer(self) -> CompletionObserver<TransactionOffsetCommitResult> {
self.observer
}
}
pub(crate) struct TransactionOffsetCommitAdmissionError {
kind: TransactionOffsetCommitAdmissionErrorKind,
input: TransactionOffsetCommitRequest,
}
impl TransactionOffsetCommitAdmissionError {
pub(in crate::transaction) const fn new(
kind: TransactionOffsetCommitAdmissionErrorKind,
input: TransactionOffsetCommitRequest,
) -> Self {
Self { kind, input }
}
pub(crate) const fn kind(&self) -> TransactionOffsetCommitAdmissionErrorKind {
self.kind
}
pub(crate) fn into_input(self) -> TransactionOffsetCommitRequest {
self.input
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionOffsetCommitAdmissionErrorKind {
Busy,
CompletionCapacity,
StaleOwner,
InvalidLifecycle,
InvalidInput,
OffsetCount { actual: usize, limit: usize },
RetainedBytes { actual: usize, limit: usize },
IdentityExhausted,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionOffsetCommitFailureKind {
DeadlineElapsed,
DriverRejected,
Allocation,
Compatibility,
InvalidResponse,
Transport,
Broker { code: i16, fenced: bool },
Correlation,
DriverShutdown,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct TransactionOffsetCommitFailure {
kind: TransactionOffsetCommitFailureKind,
delivery: DeliveryStatus,
}
impl TransactionOffsetCommitFailure {
pub(in crate::transaction) const fn new(
kind: TransactionOffsetCommitFailureKind,
delivery: DeliveryStatus,
) -> Self {
Self { kind, delivery }
}
pub(crate) const fn kind(self) -> TransactionOffsetCommitFailureKind {
self.kind
}
pub(crate) const fn delivery(self) -> DeliveryStatus {
self.delivery
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionOffsetCommitOutcome {
Succeeded,
RejectedNotSent {
stage: TransactionOffsetCommitStage,
failure: TransactionOffsetCommitFailure,
},
AbortRequired {
stage: TransactionOffsetCommitStage,
failure: TransactionOffsetCommitFailure,
},
Fatal {
stage: TransactionOffsetCommitStage,
failure: TransactionOffsetCommitFailure,
},
}
pub(crate) struct TransactionOffsetCommitResult {
operation_id: TransactionOffsetCommitId,
input: TransactionOffsetCommitRequest,
outcome: TransactionOffsetCommitOutcome,
}
impl TransactionOffsetCommitResult {
pub(super) const fn new(
operation_id: TransactionOffsetCommitId,
input: TransactionOffsetCommitRequest,
outcome: TransactionOffsetCommitOutcome,
) -> Self {
Self {
operation_id,
input,
outcome,
}
}
pub(crate) const fn operation_id(&self) -> TransactionOffsetCommitId {
self.operation_id
}
pub(crate) const fn outcome(&self) -> TransactionOffsetCommitOutcome {
self.outcome
}
pub(crate) fn into_input(self) -> TransactionOffsetCommitRequest {
self.input
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionOffsetCommitHostError {
Completion(crate::completion::CompletionRegistryError),
Core(TransactionOffsetCommitMachineError),
Lifecycle,
UnexpectedEffect,
}