use core::num::NonZeroI16;
use kafka_client_core::{NextFetchOffset, PartitionIndex};
use kafka_wire::{
ListOffsetsResponse,
list_offsets_response::{ListOffsetsPartitionResponse, ListOffsetsTopicResponse},
};
use super::{ListOffsetsOutcome, NormalizedListOffsetsResponse, ResolvedPosition};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ListOffsetsResponseFailure {
UnsupportedApiVersion {
actual: i16,
},
NegativeThrottleTime {
actual: i32,
},
MissingTopic,
DuplicateTopic,
UnexpectedTopic,
MissingPartition,
DuplicatePartition,
InvalidPartitionIndex {
actual: i32,
},
UnexpectedPartition {
actual: i32,
},
RequestedPartitionOutOfRange {
actual: u32,
},
InvalidOffset {
actual: i64,
},
InvalidTimestamp {
actual: i64,
},
InvalidLeaderEpoch {
actual: i32,
},
}
pub(crate) fn normalize_list_offsets_response(
topic: &str,
partition: PartitionIndex,
selected_version: i16,
response: &ListOffsetsResponse,
) -> Result<NormalizedListOffsetsResponse, ListOffsetsResponseFailure> {
if !(1..=11).contains(&selected_version) {
return Err(ListOffsetsResponseFailure::UnsupportedApiVersion {
actual: selected_version,
});
}
let throttle_time_ms = if selected_version == 1 {
0
} else {
u32::try_from(response.throttle_time_ms).map_err(|_| {
ListOffsetsResponseFailure::NegativeThrottleTime {
actual: response.throttle_time_ms,
}
})?
};
let topic_response = matching_topic(topic, &response.topics)?;
let expected_partition = i32::try_from(partition.get()).map_err(|_| {
ListOffsetsResponseFailure::RequestedPartitionOutOfRange {
actual: partition.get(),
}
})?;
let partition_response = matching_partition(expected_partition, &topic_response.partitions)?;
if let Some(code) = NonZeroI16::new(partition_response.error_code) {
return Ok(NormalizedListOffsetsResponse::new(
throttle_time_ms,
ListOffsetsOutcome::BrokerError { code },
));
}
let Some(next_offset) = NextFetchOffset::try_from_raw(partition_response.offset) else {
return Err(ListOffsetsResponseFailure::InvalidOffset {
actual: partition_response.offset,
});
};
let timestamp_ms = optional_timestamp(partition_response.timestamp)?;
let leader_epoch = optional_leader_epoch(selected_version, partition_response.leader_epoch)?;
Ok(NormalizedListOffsetsResponse::new(
throttle_time_ms,
ListOffsetsOutcome::Resolved(ResolvedPosition::new(
next_offset,
timestamp_ms,
leader_epoch,
)),
))
}
fn matching_topic<'a>(
expected: &str,
topics: &'a [ListOffsetsTopicResponse],
) -> Result<&'a ListOffsetsTopicResponse, ListOffsetsResponseFailure> {
let mut matching = None;
for topic in topics {
if topic.name.as_str() != expected {
return Err(ListOffsetsResponseFailure::UnexpectedTopic);
}
if matching.replace(topic).is_some() {
return Err(ListOffsetsResponseFailure::DuplicateTopic);
}
}
matching.ok_or(ListOffsetsResponseFailure::MissingTopic)
}
fn matching_partition(
expected: i32,
partitions: &[ListOffsetsPartitionResponse],
) -> Result<&ListOffsetsPartitionResponse, ListOffsetsResponseFailure> {
let mut matching = None;
for partition in partitions {
if partition.partition_index < 0 {
return Err(ListOffsetsResponseFailure::InvalidPartitionIndex {
actual: partition.partition_index,
});
}
if partition.partition_index != expected {
return Err(ListOffsetsResponseFailure::UnexpectedPartition {
actual: partition.partition_index,
});
}
if matching.replace(partition).is_some() {
return Err(ListOffsetsResponseFailure::DuplicatePartition);
}
}
matching.ok_or(ListOffsetsResponseFailure::MissingPartition)
}
fn optional_timestamp(value: i64) -> Result<Option<i64>, ListOffsetsResponseFailure> {
match value {
-1 => Ok(None),
0.. => Ok(Some(value)),
actual => Err(ListOffsetsResponseFailure::InvalidTimestamp { actual }),
}
}
fn optional_leader_epoch(
selected_version: i16,
value: i32,
) -> Result<Option<i32>, ListOffsetsResponseFailure> {
if selected_version < 4 {
return Ok(None);
}
match value {
-1 => Ok(None),
0.. => Ok(Some(value)),
actual => Err(ListOffsetsResponseFailure::InvalidLeaderEpoch { actual }),
}
}