use kafka_wire::{
DescribeUserScramCredentialsResponse,
describe_user_scram_credentials_response::DescribeUserScramCredentialsResult,
};
use super::{
DescribeUserScramCredentialsRequestRef, NormalizedDescribeUserScramCredentialsResponse,
NormalizedScramCredentialInfo, NormalizedUserScramCredentials,
correlation::{ordered_results, validate_request_selection},
retention::{bounded_diagnostic, normalized_retained_charge, response_peak_charge},
validation::validate_response_shape,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum DescribeUserScramCredentialsResponseFailure {
UnsupportedApiVersion { actual: i16 },
NegativeThrottleTime { actual: i32 },
ResultsWithTopLevelError { actual: usize },
TooManyResults { actual: usize, max: usize },
TooManyCredentialInfos { actual: usize, max: usize },
EmptyUser,
UserTooLong { actual: usize, max: usize },
TooManyCredentialsForUser { actual: usize, max: usize },
EmptyCredentialsOnSuccess,
CredentialsWithUserError { actual: usize },
InvalidMechanism { actual: i8 },
NonPositiveIterations { actual: i32 },
DuplicateMechanism { actual: i8 },
EmptyUserFilter,
TooManyRequestedUsers { actual: usize, max: usize },
EmptyRequestedUser,
RequestedUserTooLong { actual: usize, max: usize },
DuplicateRequestedUser,
DuplicateUser,
MissingUser,
UnexpectedUser,
RetainedBytes { required: usize, limit: usize },
}
pub(crate) fn normalize_describe_user_scram_credentials_response(
selected_version: i16,
request: DescribeUserScramCredentialsRequestRef<'_>,
response: &DescribeUserScramCredentialsResponse,
retained_limit: usize,
) -> Result<
NormalizedDescribeUserScramCredentialsResponse,
DescribeUserScramCredentialsResponseFailure,
> {
validate_response_shape(selected_version, response)?;
let required = response_peak_charge(request, response).unwrap_or(usize::MAX);
ensure_limit(required, retained_limit)?;
let ordered = if response.error_code == 0 {
ordered_results(request, &response.results, required, retained_limit)?
} else {
validate_request_selection(request, required, retained_limit)?;
Vec::new()
};
materialize(response, ordered, required, retained_limit)
}
fn materialize(
response: &DescribeUserScramCredentialsResponse,
ordered: Vec<&DescribeUserScramCredentialsResult>,
required: usize,
limit: usize,
) -> Result<
NormalizedDescribeUserScramCredentialsResponse,
DescribeUserScramCredentialsResponseFailure,
> {
let (error_message, error_message_truncated) =
copy_diagnostic(response.error_message.as_deref(), required, limit)?;
let mut results = Vec::new();
results
.try_reserve_exact(ordered.len())
.map_err(|_| retained(required, limit))?;
for result in ordered {
results.push(materialize_result(result, required, limit)?);
}
let throttle_time_ms = u32::try_from(response.throttle_time_ms).map_err(|_| {
DescribeUserScramCredentialsResponseFailure::NegativeThrottleTime {
actual: response.throttle_time_ms,
}
})?;
let mut normalized = NormalizedDescribeUserScramCredentialsResponse {
throttle_time_ms,
error_code: response.error_code,
error_message,
error_message_truncated,
results,
retained_bytes: 0,
};
let retained = normalized_retained_charge(&normalized).unwrap_or(usize::MAX);
ensure_limit(retained, limit)?;
normalized.retained_bytes = required.max(retained);
Ok(normalized)
}
fn materialize_result(
source: &DescribeUserScramCredentialsResult,
required: usize,
limit: usize,
) -> Result<NormalizedUserScramCredentials, DescribeUserScramCredentialsResponseFailure> {
let (error_message, error_message_truncated) =
copy_diagnostic(source.error_message.as_deref(), required, limit)?;
let mut credential_infos = Vec::new();
credential_infos
.try_reserve_exact(source.credential_infos.len())
.map_err(|_| retained(required, limit))?;
for info in &source.credential_infos {
let iterations = u32::try_from(info.iterations).map_err(|_| {
DescribeUserScramCredentialsResponseFailure::NonPositiveIterations {
actual: info.iterations,
}
})?;
credential_infos.push(NormalizedScramCredentialInfo::new(
info.mechanism,
iterations,
));
}
credential_infos.sort_unstable_by_key(|info| info.into_parts().0);
Ok(NormalizedUserScramCredentials {
user: copy_string(source.user.as_str(), required, limit)?,
error_code: source.error_code,
error_message,
error_message_truncated,
credential_infos,
})
}
fn copy_diagnostic(
source: Option<&str>,
required: usize,
limit: usize,
) -> Result<(Option<String>, bool), DescribeUserScramCredentialsResponseFailure> {
let (bounded, truncated) = bounded_diagnostic(source);
Ok((
bounded
.map(|message| copy_string(message, required, limit))
.transpose()?,
truncated,
))
}
fn copy_string(
source: &str,
required: usize,
limit: usize,
) -> Result<String, DescribeUserScramCredentialsResponseFailure> {
let mut owned = String::new();
owned
.try_reserve_exact(source.len())
.map_err(|_| retained(required, limit))?;
owned.push_str(source);
Ok(owned)
}
fn ensure_limit(
required: usize,
limit: usize,
) -> Result<(), DescribeUserScramCredentialsResponseFailure> {
(required <= limit)
.then_some(())
.ok_or_else(|| retained(required, limit))
}
const fn retained(required: usize, limit: usize) -> DescribeUserScramCredentialsResponseFailure {
DescribeUserScramCredentialsResponseFailure::RetainedBytes { required, limit }
}