use kafka_wire::ExpireDelegationTokenResponse;
use super::{
NormalizedExpireDelegationTokenResponse,
retention::{EXPIRE_DELEGATION_TOKEN_MAX_RETAINED_BYTES, response_charge},
};
const MIN_VERSION: i16 = 1;
const MAX_VERSION: i16 = 2;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ExpireDelegationTokenResponseFailure {
MissingSelectedVersion,
UnsupportedApiVersion { actual: i16 },
NegativeThrottleTime { actual: i32 },
InvalidExpiryTimestamp { actual: i64 },
RetainedBytes { required: usize, limit: usize },
}
pub(crate) fn normalize_expire_delegation_token_response(
selected_version: Option<i16>,
response: &ExpireDelegationTokenResponse,
retained_limit: usize,
) -> Result<NormalizedExpireDelegationTokenResponse, ExpireDelegationTokenResponseFailure> {
let selected_version =
selected_version.ok_or(ExpireDelegationTokenResponseFailure::MissingSelectedVersion)?;
if !(MIN_VERSION..=MAX_VERSION).contains(&selected_version) {
return Err(
ExpireDelegationTokenResponseFailure::UnsupportedApiVersion {
actual: selected_version,
},
);
}
let throttle_time_ms = u32::try_from(response.throttle_time_ms).map_err(|_| {
ExpireDelegationTokenResponseFailure::NegativeThrottleTime {
actual: response.throttle_time_ms,
}
})?;
let expiry_timestamp_ms = if response.error_code == 0 {
if response.expiry_timestamp_ms < 0 {
return Err(
ExpireDelegationTokenResponseFailure::InvalidExpiryTimestamp {
actual: response.expiry_timestamp_ms,
},
);
}
Some(response.expiry_timestamp_ms)
} else {
None
};
let required = response_charge();
let effective_limit = retained_limit.min(EXPIRE_DELEGATION_TOKEN_MAX_RETAINED_BYTES);
if required > effective_limit {
return Err(ExpireDelegationTokenResponseFailure::RetainedBytes {
required,
limit: effective_limit,
});
}
Ok(NormalizedExpireDelegationTokenResponse::new(
throttle_time_ms,
response.error_code,
expiry_timestamp_ms,
required,
))
}