use kafka_client_core::{
DeliveryStatus as CoreDeliveryStatus, ProducerFailure as CoreProducerFailure,
ProducerFailureKind as CoreProducerFailureKind, RecordMetadata as CoreRecordMetadata,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ProducerRecordMetadata {
partition: u32,
offset: i64,
append_timestamp: Option<i64>,
leader_epoch: Option<i32>,
}
impl ProducerRecordMetadata {
pub(crate) const fn from_core(metadata: CoreRecordMetadata) -> Self {
Self {
partition: metadata.partition().get(),
offset: metadata.offset(),
append_timestamp: metadata.append_timestamp(),
leader_epoch: metadata.leader_epoch(),
}
}
pub const fn partition(self) -> u32 {
self.partition
}
pub const fn offset(self) -> i64 {
self.offset
}
pub const fn append_timestamp(self) -> Option<i64> {
self.append_timestamp
}
pub const fn leader_epoch(self) -> Option<i32> {
self.leader_epoch
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ProducerDeliveryStatus {
NotSent,
PossiblySent,
}
impl ProducerDeliveryStatus {
const fn from_core(status: CoreDeliveryStatus) -> Self {
match status {
CoreDeliveryStatus::NotSent => Self::NotSent,
CoreDeliveryStatus::PossiblySent => Self::PossiblySent,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ProducerDeliveryFailureKind {
Cancelled,
DriverRejected,
MaterializationFailed,
Routing,
BrokerRetriable,
AccessRejected,
InvalidRecord,
Compatibility,
ProducerFenced,
ProducerIdentity,
Transport,
InvalidResponse,
ExecutionUnavailable,
DeadlineElapsed,
UnknownBroker,
}
impl ProducerDeliveryFailureKind {
const fn from_core(kind: CoreProducerFailureKind) -> Self {
match kind {
CoreProducerFailureKind::Cancelled => Self::Cancelled,
CoreProducerFailureKind::DriverRejected => Self::DriverRejected,
CoreProducerFailureKind::MaterializationFailed => Self::MaterializationFailed,
CoreProducerFailureKind::Routing => Self::Routing,
CoreProducerFailureKind::BrokerRetriable => Self::BrokerRetriable,
CoreProducerFailureKind::AccessRejected => Self::AccessRejected,
CoreProducerFailureKind::InvalidRecord => Self::InvalidRecord,
CoreProducerFailureKind::Compatibility => Self::Compatibility,
CoreProducerFailureKind::ProducerFenced => Self::ProducerFenced,
CoreProducerFailureKind::ProducerIdentity => Self::ProducerIdentity,
CoreProducerFailureKind::Transport => Self::Transport,
CoreProducerFailureKind::InvalidResponse => Self::InvalidResponse,
CoreProducerFailureKind::ExecutionUnavailable => Self::ExecutionUnavailable,
CoreProducerFailureKind::DeadlineElapsed => Self::DeadlineElapsed,
CoreProducerFailureKind::UnknownBroker => Self::UnknownBroker,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ProducerDeliveryFailure {
kind: ProducerDeliveryFailureKind,
status: ProducerDeliveryStatus,
broker_code: Option<i16>,
}
impl ProducerDeliveryFailure {
pub(crate) const fn from_core(failure: CoreProducerFailure) -> Self {
Self {
kind: ProducerDeliveryFailureKind::from_core(failure.kind()),
status: ProducerDeliveryStatus::from_core(failure.delivery()),
broker_code: failure.broker_code(),
}
}
pub const fn kind(self) -> ProducerDeliveryFailureKind {
self.kind
}
pub const fn delivery_status(self) -> ProducerDeliveryStatus {
self.status
}
pub const fn broker_code(self) -> Option<i16> {
self.broker_code
}
}