kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Exhaustive discovery, API-key 66, and driver-terminal translation.

use core::num::NonZeroI16;

use kafka_client_core::{
    AdminListTransactionsBrokerError, AdminListTransactionsBrokerOutcome,
    AdminListTransactionsInput, AdminListedTransaction as CoreListedTransaction, DeliveryStatus,
};

use crate::{
    driver::{
        ListTransactionsDriverFailureKind, ListTransactionsRawTerminal,
        ListTransactionsRawTerminalFact,
    },
    protocol::admin::{
        list_consumer_groups::{
            ListConsumerGroupsProtocolFailure, NormalizedListConsumerGroupsDiscovery,
            normalize_list_consumer_groups_discovery,
        },
        list_transactions::{
            ListTransactionsProtocolFailure, ListTransactionsResponseFacts,
            normalize_list_transactions_response,
        },
    },
};

pub(super) fn terminal_input(
    raw: &ListTransactionsRawTerminal,
) -> (AdminListTransactionsInput, usize) {
    let retained_bytes = raw.retained_limit();
    match raw.fact() {
        ListTransactionsRawTerminalFact::DiscoveryResponse {
            selected_version,
            response,
        } => discovery_input(normalize_list_consumer_groups_discovery(
            selected_version,
            response,
            retained_bytes,
        )),
        ListTransactionsRawTerminalFact::BrokerResponse {
            broker_id,
            selected_version,
            response,
        } => match normalize_list_transactions_response(selected_version, response, retained_bytes)
        {
            Ok(normalized) => normalized_input(broker_id, normalized)
                .unwrap_or((AdminListTransactionsInput::ResponseTooLarge, 0)),
            Err(error) => (protocol_failure(error), 0),
        },
        ListTransactionsRawTerminalFact::Failed { kind, delivery } => {
            (driver_failure(kind, delivery), 0)
        }
    }
}

fn discovery_input(
    normalized: Result<NormalizedListConsumerGroupsDiscovery, ListConsumerGroupsProtocolFailure>,
) -> (AdminListTransactionsInput, usize) {
    match normalized {
        Ok(NormalizedListConsumerGroupsDiscovery::Brokers {
            broker_ids,
            retained_bytes,
        }) => (
            AdminListTransactionsInput::BrokersDiscovered { broker_ids },
            retained_bytes,
        ),
        Ok(NormalizedListConsumerGroupsDiscovery::Rejected {
            error,
            retained_bytes,
        }) => (
            AdminListTransactionsInput::DiscoveryRejected { error },
            retained_bytes,
        ),
        Err(ListConsumerGroupsProtocolFailure::Compatibility) => (
            AdminListTransactionsInput::ProtocolIncompatible {
                delivery: DeliveryStatus::PossiblySent,
            },
            0,
        ),
        Err(ListConsumerGroupsProtocolFailure::ResponseTooLarge) => {
            (AdminListTransactionsInput::ResponseTooLarge, 0)
        }
        Err(ListConsumerGroupsProtocolFailure::InvalidResponse) => {
            (AdminListTransactionsInput::InvalidResponse, 0)
        }
    }
}

pub(super) fn normalized_input(
    broker_id: i32,
    normalized: ListTransactionsResponseFacts,
) -> Result<(AdminListTransactionsInput, usize), ()> {
    if broker_id < 0 {
        return Err(());
    }
    let (throttle_time_ms, broker_error_code, unknown_state_filters, transactions, retained_bytes) =
        normalized.into_parts();
    let outcome = if let Some(code) = broker_error_code {
        let code = NonZeroI16::new(code).ok_or(())?;
        AdminListTransactionsBrokerOutcome::Rejected(AdminListTransactionsBrokerError::new(
            broker_id, code,
        ))
    } else {
        let mut listed = Vec::new();
        listed
            .try_reserve_exact(transactions.len())
            .map_err(|_| ())?;
        for transaction in transactions {
            let (transactional_id, producer_id, transaction_state) = transaction.into_parts();
            listed.push(CoreListedTransaction::new(
                transactional_id,
                producer_id,
                transaction_state,
            ));
        }
        AdminListTransactionsBrokerOutcome::Listed {
            broker_id,
            unknown_state_filters,
            transactions: listed,
        }
    };
    Ok((
        AdminListTransactionsInput::BrokerResponded {
            throttle_time_ms,
            outcome,
        },
        retained_bytes,
    ))
}

const fn protocol_failure(error: ListTransactionsProtocolFailure) -> AdminListTransactionsInput {
    match error {
        ListTransactionsProtocolFailure::MissingSelectedVersion
        | ListTransactionsProtocolFailure::UnsupportedApiVersion { .. } => {
            AdminListTransactionsInput::ProtocolIncompatible {
                delivery: DeliveryStatus::PossiblySent,
            }
        }
        ListTransactionsProtocolFailure::RetainedBytes { .. }
        | ListTransactionsProtocolFailure::Allocation { .. } => {
            AdminListTransactionsInput::ResponseTooLarge
        }
        ListTransactionsProtocolFailure::NegativeThrottleTime { .. }
        | ListTransactionsProtocolFailure::SuccessPayloadWithBrokerError { .. }
        | ListTransactionsProtocolFailure::TooManyUnknownStateFilters { .. }
        | ListTransactionsProtocolFailure::TooManyTransactions { .. }
        | ListTransactionsProtocolFailure::EmptyTransactionalId
        | ListTransactionsProtocolFailure::TransactionalIdTooLong { .. }
        | ListTransactionsProtocolFailure::EmptyTransactionState
        | ListTransactionsProtocolFailure::StateTooLong { .. }
        | ListTransactionsProtocolFailure::ResponseTextBytesExceeded { .. }
        | ListTransactionsProtocolFailure::DuplicateUnknownStateFilter
        | ListTransactionsProtocolFailure::DuplicateTransactionalId => {
            AdminListTransactionsInput::InvalidResponse
        }
    }
}

const fn driver_failure(
    kind: ListTransactionsDriverFailureKind,
    delivery: DeliveryStatus,
) -> AdminListTransactionsInput {
    match kind {
        ListTransactionsDriverFailureKind::DeadlineElapsed => {
            AdminListTransactionsInput::DriverDeadlineElapsed { delivery }
        }
        ListTransactionsDriverFailureKind::Compatibility => {
            AdminListTransactionsInput::ProtocolIncompatible { delivery }
        }
        ListTransactionsDriverFailureKind::InvalidResponse => {
            AdminListTransactionsInput::InvalidResponse
        }
        ListTransactionsDriverFailureKind::Transport => {
            AdminListTransactionsInput::TransportFailed { delivery }
        }
    }
}