use core::num::NonZeroI16;
use kafka_wire::HeartbeatResponse;
use super::{
ClassicBrokerRejection,
validation::{HEARTBEAT_MAX_VERSION, HEARTBEAT_MIN_VERSION, STATIC_HEARTBEAT_VERSION},
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ClassicHeartbeatOutcome {
Succeeded { throttle_time_ms: u32 },
Rejected(ClassicBrokerRejection),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ClassicHeartbeatResponseFailure {
UnsupportedApiVersion(i16),
UnexpectedThrottleTime(i32),
NegativeThrottleTime(i32),
}
pub(crate) fn normalize_classic_heartbeat_response(
selected_version: i16,
response: &HeartbeatResponse,
) -> Result<ClassicHeartbeatOutcome, ClassicHeartbeatResponseFailure> {
if !(HEARTBEAT_MIN_VERSION..=HEARTBEAT_MAX_VERSION).contains(&selected_version)
&& selected_version != STATIC_HEARTBEAT_VERSION
{
return Err(ClassicHeartbeatResponseFailure::UnsupportedApiVersion(
selected_version,
));
}
let throttle_time_ms = normalize_throttle(selected_version, response.throttle_time_ms)?;
Ok(match NonZeroI16::new(response.error_code) {
Some(error_code) => ClassicHeartbeatOutcome::Rejected(ClassicBrokerRejection::new(
throttle_time_ms,
error_code,
)),
None => ClassicHeartbeatOutcome::Succeeded { throttle_time_ms },
})
}
fn normalize_throttle(
version: i16,
throttle_time_ms: i32,
) -> Result<u32, ClassicHeartbeatResponseFailure> {
if version == 0 && throttle_time_ms != 0 {
return Err(ClassicHeartbeatResponseFailure::UnexpectedThrottleTime(
throttle_time_ms,
));
}
u32::try_from(throttle_time_ms)
.map_err(|_error| ClassicHeartbeatResponseFailure::NegativeThrottleTime(throttle_time_ms))
}