kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Allocation-free normalization of one API-key 40 scalar terminal.

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;

/// Invalid selected version, scalar shape, or terminal capacity.
#[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 },
}

/// Preserves exact signed broker status and validates success expiry.
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,
    ))
}