kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Checked request, correlation-scratch, and result retention accounting.

use core::mem::size_of;

use kafka_client_core::{
    ALTER_USER_SCRAM_CREDENTIALS_DIAGNOSTIC_BYTES, ALTER_USER_SCRAM_CREDENTIALS_MAX_CHANGES,
    ALTER_USER_SCRAM_CREDENTIALS_MAX_ITERATIONS, ALTER_USER_SCRAM_CREDENTIALS_MAX_USER_NAME_BYTES,
    ALTER_USER_SCRAM_CREDENTIALS_MAX_USERS, ALTER_USER_SCRAM_CREDENTIALS_MIN_ITERATIONS,
};
use kafka_wire::alter_user_scram_credentials_request::{
    ScramCredentialDeletion, ScramCredentialUpsertion,
};

use super::{
    AlterUserScramCredentialAlterationRef, AlterUserScramCredentialsCorrelationRef,
    AlterUserScramCredentialsRequestRef, NormalizedAlterUserScramCredentialOutcome,
    NormalizedAlterUserScramCredentialsResponse,
    crypto::{GENERATED_SALT_BYTES, output_len},
    request_validation::{CanonicalAlterationKey, FirstUserRef},
};

pub(super) const MAX_ALTERATIONS: usize = ALTER_USER_SCRAM_CREDENTIALS_MAX_CHANGES;
pub(super) const MAX_USERS: usize = ALTER_USER_SCRAM_CREDENTIALS_MAX_USERS;
pub(super) const MAX_USER_BYTES: usize = ALTER_USER_SCRAM_CREDENTIALS_MAX_USER_NAME_BYTES;
pub(super) const MAX_PASSWORD_BYTES: usize = 16 * 1024;
pub(super) const MIN_SALT_BYTES: usize = 16;
pub(super) const MAX_SALT_BYTES: usize = 64;
pub(super) const MIN_ITERATIONS: u32 = ALTER_USER_SCRAM_CREDENTIALS_MIN_ITERATIONS;
pub(super) const MAX_ITERATIONS: u32 = ALTER_USER_SCRAM_CREDENTIALS_MAX_ITERATIONS;
pub(super) const MAX_DIAGNOSTIC_BYTES: usize = ALTER_USER_SCRAM_CREDENTIALS_DIAGNOSTIC_BYTES;

pub(super) fn request_peak_charge(
    source: AlterUserScramCredentialsRequestRef<'_>,
) -> Option<usize> {
    let scratch = source
        .alterations()
        .len()
        .checked_mul(size_of::<CanonicalAlterationKey<'static>>())?
        .checked_add(
            source
                .alterations()
                .len()
                .checked_mul(size_of::<FirstUserRef<'static>>())?,
        )?;
    source
        .alterations()
        .iter()
        .try_fold(scratch, |bytes, alteration| {
            let bytes = bytes.checked_add(alteration.user().len().checked_mul(2)?)?;
            match alteration {
                AlterUserScramCredentialAlterationRef::Delete { .. } => {
                    bytes.checked_add(size_of::<ScramCredentialDeletion>())
                }
                AlterUserScramCredentialAlterationRef::Upsert {
                    mechanism,
                    password,
                    salt,
                    ..
                } => {
                    let salt_bytes = match salt {
                        Some(salt) => salt.len().checked_mul(2)?,
                        None => GENERATED_SALT_BYTES,
                    };
                    bytes
                        .checked_add(size_of::<ScramCredentialUpsertion>())?
                        .checked_add(password.len())?
                        .checked_add(salt_bytes)?
                        .checked_add(output_len(*mechanism).unwrap_or(0))
                }
            }
        })
}

pub(super) fn response_peak_charge(
    correlation: AlterUserScramCredentialsCorrelationRef<'_>,
    response: &kafka_wire::AlterUserScramCredentialsResponse,
) -> Option<usize> {
    let correlation_charge = correlation
        .affected_users()
        .iter()
        .try_fold(0_usize, |bytes, user| bytes.checked_add(user.len()))?;
    let request_scratch = correlation
        .affected_users()
        .len()
        .checked_mul(size_of::<&'static str>())?;
    let response_scratch = response
        .results
        .len()
        .checked_mul(size_of::<&'static ()>())?;
    let order_scratch = correlation
        .affected_users()
        .len()
        .checked_mul(size_of::<&'static str>())?;
    let normalized = normalized_output_charge(response)?;
    correlation_charge.checked_add(
        request_scratch
            .checked_add(response_scratch)?
            .checked_add(order_scratch)?
            .checked_add(normalized.checked_mul(3)?)?,
    )
}

fn normalized_output_charge(
    response: &kafka_wire::AlterUserScramCredentialsResponse,
) -> Option<usize> {
    response.results.iter().try_fold(
        size_of::<NormalizedAlterUserScramCredentialsResponse>().checked_add(
            response
                .results
                .len()
                .checked_mul(size_of::<NormalizedAlterUserScramCredentialOutcome>())?,
        )?,
        |bytes, result| {
            bytes
                .checked_add(result.user.len())?
                .checked_add(bounded_diagnostic_len(result.error_message.as_deref()))
        },
    )
}

pub(super) fn normalized_retained_charge(
    response: &NormalizedAlterUserScramCredentialsResponse,
) -> Option<usize> {
    response.outcomes.iter().try_fold(
        size_of::<NormalizedAlterUserScramCredentialsResponse>().checked_add(
            response
                .outcomes
                .capacity()
                .checked_mul(size_of::<NormalizedAlterUserScramCredentialOutcome>())?,
        )?,
        |bytes, outcome| {
            bytes
                .checked_add(outcome.user.capacity())?
                .checked_add(outcome.error_message.as_ref().map_or(0, String::capacity))
        },
    )
}

pub(super) fn bounded_diagnostic(message: Option<&str>) -> (Option<&str>, bool) {
    let Some(message) = message else {
        return (None, false);
    };
    let len = bounded_diagnostic_len(Some(message));
    (Some(&message[..len]), len < message.len())
}

fn bounded_diagnostic_len(message: Option<&str>) -> usize {
    let Some(message) = message else {
        return 0;
    };
    let mut index = MAX_DIAGNOSTIC_BYTES.min(message.len());
    while !message.is_char_boundary(index) {
        index = index.saturating_sub(1);
    }
    index
}