use std::sync::Arc;
use bytes::Bytes;
use kafka_client_core::Moment;
use kafka_wire::{
ProduceRequest,
produce_request::{PartitionProduceData, TopicProduceData},
};
use crate::clock::OperationDeadline;
pub(super) const ACKS_ALL: i16 = -1;
const NANOSECONDS_PER_MILLISECOND: u64 = 1_000_000;
#[derive(Debug)]
pub(crate) struct MaterializedProduce {
topic: Arc<str>,
partition: i32,
record_count: u32,
records: Bytes,
}
impl MaterializedProduce {
pub(super) const fn new(
topic: Arc<str>,
partition: i32,
record_count: u32,
records: Bytes,
) -> Self {
Self {
topic,
partition,
record_count,
records,
}
}
#[cfg(test)]
pub(crate) fn from_encoded_test_parts(
topic: impl Into<Arc<str>>,
partition: i32,
records: Bytes,
) -> Self {
Self::new(topic.into(), partition, 1, records)
}
#[cfg(test)]
pub(crate) fn from_broker_routed_test_parts(
topic: impl Into<Arc<str>>,
partition: i32,
_leader_broker_id: i32,
records: Bytes,
) -> Self {
Self::new(topic.into(), partition, 1, records)
}
#[cfg(test)]
pub(crate) fn topic_name(&self) -> &str {
self.topic.as_ref()
}
pub(crate) fn topic_owner(&self) -> Arc<str> {
Arc::clone(&self.topic)
}
pub(crate) const fn partition(&self) -> i32 {
self.partition
}
pub(crate) const fn record_count(&self) -> u32 {
self.record_count
}
pub(crate) fn retained_record_bytes(&self) -> usize {
self.records.len()
}
pub(crate) fn into_name_routed_request(
self,
now: Moment,
deadline: OperationDeadline,
) -> ProduceRequest {
self.into_request(None, now, deadline)
}
#[cfg(test)]
pub(crate) fn into_broker_routed_request(
batches: Vec<Self>,
now: Moment,
deadline: OperationDeadline,
) -> Result<ProduceRequest, Vec<Self>> {
super::request_broker::build_broker_routed_request(batches, now, deadline)
}
pub(crate) fn transactional_name_routed_request(
&self,
transactional_id: &str,
now: Moment,
deadline: OperationDeadline,
) -> ProduceRequest {
self.request(Some(transactional_id), now, deadline)
}
fn into_request(
self,
transactional_id: Option<&str>,
now: Moment,
deadline: OperationDeadline,
) -> ProduceRequest {
Self::build_request(
self.topic.as_ref(),
self.partition,
self.records,
transactional_id,
now,
deadline,
)
}
#[cfg(test)]
pub(super) fn into_partition_data(self) -> (Arc<str>, PartitionProduceData) {
let mut partition = PartitionProduceData::default();
partition.index = self.partition;
partition.records = Some(self.records);
(self.topic, partition)
}
fn request(
&self,
transactional_id: Option<&str>,
now: Moment,
deadline: OperationDeadline,
) -> ProduceRequest {
Self::build_request(
self.topic.as_ref(),
self.partition,
self.records.clone(),
transactional_id,
now,
deadline,
)
}
fn build_request(
topic_name: &str,
partition_index: i32,
records: Bytes,
transactional_id: Option<&str>,
now: Moment,
deadline: OperationDeadline,
) -> ProduceRequest {
let mut partition = PartitionProduceData::default();
partition.index = partition_index;
partition.records = Some(records);
let mut topic = TopicProduceData::default();
topic.name = topic_name.into();
topic.partition_data.push(partition);
let mut request = ProduceRequest::default();
request.transactional_id = transactional_id.map(Into::into);
request.acks = ACKS_ALL;
request.timeout_ms = remaining_broker_timeout_ms(now, deadline);
request.topic_data.push(topic);
request
}
#[cfg(test)]
pub(crate) const fn encoded_records(&self) -> &Bytes {
&self.records
}
}
pub(super) fn remaining_broker_timeout_ms(now: Moment, deadline: OperationDeadline) -> i32 {
let remaining_nanoseconds = deadline.core().tick().saturating_sub(now.tick());
let rounded_milliseconds = remaining_nanoseconds
.saturating_add(NANOSECONDS_PER_MILLISECOND - 1)
/ NANOSECONDS_PER_MILLISECOND;
match i32::try_from(rounded_milliseconds) {
Ok(timeout_ms) => timeout_ms,
Err(_overflow) => i32::MAX,
}
}