use std::sync::Arc;
use kafka_client_core::{DeliveryStatus, TransactionEpoch};
use crate::producer::materialization::TransactionalMaterializationBatch;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct TransactionPartitionEnrollmentLimits {
max_partitions: usize,
max_topic_bytes: usize,
}
impl TransactionPartitionEnrollmentLimits {
pub(crate) const fn try_new(max_partitions: usize, max_topic_bytes: usize) -> Option<Self> {
if max_partitions == 0 || max_topic_bytes == 0 {
None
} else {
Some(Self {
max_partitions,
max_topic_bytes,
})
}
}
pub(super) const fn max_partitions(self) -> usize {
self.max_partitions
}
pub(super) const fn max_topic_bytes(self) -> usize {
self.max_topic_bytes
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionPartitionEnrollmentStartError {
EmptyTransactionalId,
RetainedBytes,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionPartitionEnrollmentEpochError {
AlreadyActive,
NotActive,
EpochMismatch,
Unsettled,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct TransactionPartitionEnrollmentTarget {
topic: Arc<str>,
partition: i32,
}
impl TransactionPartitionEnrollmentTarget {
pub(super) const fn new(topic: Arc<str>, partition: i32) -> Self {
Self { topic, partition }
}
pub(super) fn topic(&self) -> &Arc<str> {
&self.topic
}
pub(super) const fn partition(&self) -> i32 {
self.partition
}
pub(super) fn retained_topic_bytes(&self) -> usize {
self.topic.len()
}
}
#[must_use = "local rejection retains the exact transactional batch"]
pub(crate) struct TransactionPartitionEnrollmentAdmissionFailure {
kind: TransactionPartitionEnrollmentFailureKind,
batch: TransactionalMaterializationBatch,
}
impl TransactionPartitionEnrollmentAdmissionFailure {
pub(in crate::transaction) const fn new(
kind: TransactionPartitionEnrollmentFailureKind,
batch: TransactionalMaterializationBatch,
) -> Self {
Self { kind, batch }
}
pub(crate) const fn kind(&self) -> TransactionPartitionEnrollmentFailureKind {
self.kind
}
pub(crate) fn into_batch(self) -> TransactionalMaterializationBatch {
self.batch
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionPartitionEnrollmentFailureKind {
Busy,
EpochMismatch,
OwnerMismatch,
InvalidTarget,
Capacity,
RetainedBytes,
DeadlineElapsed,
DriverRejected,
Transport,
Compatibility,
InvalidResponse,
DriverClosed,
Broker {
code: i16,
fenced: bool,
},
}
impl TransactionPartitionEnrollmentFailureKind {
pub(super) const fn is_fatal(self) -> bool {
matches!(self, Self::Broker { fenced: true, .. })
}
}
#[must_use = "an enrollment fence must be handed to transactional Produce or reclaimed"]
pub(crate) struct TransactionPartitionEnrollmentFence {
epoch: TransactionEpoch,
batch: TransactionalMaterializationBatch,
}
impl TransactionPartitionEnrollmentFence {
pub(in crate::transaction) const fn new(
epoch: TransactionEpoch,
batch: TransactionalMaterializationBatch,
) -> Self {
Self { epoch, batch }
}
pub(crate) const fn epoch(&self) -> TransactionEpoch {
self.epoch
}
pub(crate) fn into_batch(self) -> TransactionalMaterializationBatch {
self.batch
}
}
#[must_use = "pending enrollment must be driven to one terminal"]
pub(crate) enum TransactionPartitionEnrollmentAdmission {
Enrolled(TransactionPartitionEnrollmentFence),
Pending,
}
#[must_use = "an enrollment terminal must settle the transactional send"]
pub(crate) enum TransactionPartitionEnrollmentTerminal {
Enrolled(TransactionPartitionEnrollmentFence),
Rejected(TransactionPartitionEnrollmentAdmissionFailure),
AbortRequired {
kind: TransactionPartitionEnrollmentFailureKind,
delivery: DeliveryStatus,
batch: TransactionalMaterializationBatch,
},
Fatal {
kind: TransactionPartitionEnrollmentFailureKind,
batch: TransactionalMaterializationBatch,
},
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionPartitionEnrollmentTurn {
Idle,
Progress,
}