kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Driver fact normalization, core settlement, and terminal publication.

use std::{
    sync::{Arc, atomic::AtomicBool},
    time::Duration,
};

use kafka_client_core::{
    Moment, TransactionInitializationBrokerCategory, TransactionInitializationBrokerFailure,
    TransactionInitializationEffect, TransactionInitializationInput,
    TransactionInitializationTerminal,
};

use super::{
    LiveTransactionalOwner, TRANSACTION_INITIALIZATION_OPERATION_BYTES,
    TransactionInitializationHost,
};
use crate::transaction::TransactionExecutionHost;
use crate::transaction::initialization::{
    RetainedTransactionInitializationOutcome, TransactionInitializationHostError,
    TransactionalOwnerParts,
};
use crate::{
    driver::{TransactionInitDriverFailureKind, TransactionInitTerminalFact},
    protocol::transaction::{
        TransactionInitBrokerCategory, TransactionInitResponseFailure,
        normalize_transaction_init_response,
    },
};
impl TransactionInitializationHost {
    pub(super) fn poll_one_call(
        &mut self,
        now: Moment,
    ) -> Result<bool, TransactionInitializationHostError> {
        let Some(index) = self
            .operations
            .iter()
            .position(|operation| operation.call.is_some())
        else {
            return Ok(false);
        };
        let poll = self.operations[index]
            .call
            .as_mut()
            .ok_or(TransactionInitializationHostError::UnknownOperation)?
            .poll();
        match poll {
            crate::driver::TransactionInitPoll::Pending => Ok(false),
            crate::driver::TransactionInitPoll::Progress => Ok(true),
            crate::driver::TransactionInitPoll::Terminal(terminal) => {
                drop(self.operations[index].call.take());
                let terminal =
                    terminal.map_err(|_| TransactionInitializationHostError::CallCompletion)?;
                self.settle_or_retry_terminal(index, terminal, now)?;
                Ok(true)
            }
        }
    }

    fn settle_or_retry_terminal(
        &mut self,
        index: usize,
        terminal: crate::driver::TransactionInitTerminal,
        now: Moment,
    ) -> Result<(), TransactionInitializationHostError> {
        if terminal.retry_safe_after_refresh() && self.schedule_retry(index, now)? {
            terminal.discard();
            return Ok(());
        }
        let input = terminal_input(terminal.fact());
        self.operations[index].raw_terminal = Some(terminal);
        self.settle_raw(index, input)
    }

    pub(super) fn settle_raw(
        &mut self,
        index: usize,
        input: TransactionInitializationInput,
    ) -> Result<(), TransactionInitializationHostError> {
        let owner_id = self.operations[index].owner_id;
        let operation_id = self.operations[index].operation_id;
        let transition = self.operations[index].machine.apply(owner_id, input)?;
        let raw = self.operations[index]
            .raw_terminal
            .take()
            .ok_or(TransactionInitializationHostError::MissingTerminal)?;
        raw.discard();
        match transition.into_effect() {
            Some(TransactionInitializationEffect::Complete {
                owner_id: effect_owner,
                operation_id: effect_operation,
                terminal,
            }) if effect_owner == owner_id && effect_operation == operation_id => {
                self.retain_initialization_outcome(index, terminal)?;
                self.publish_terminal(index)
            }
            _ => Err(TransactionInitializationHostError::UnexpectedEffect),
        }
    }

    pub(super) fn apply(
        &mut self,
        index: usize,
        input: TransactionInitializationInput,
    ) -> Result<(), TransactionInitializationHostError> {
        let owner_id = self.operations[index].owner_id;
        let transition = self.operations[index].machine.apply(owner_id, input)?;
        match transition.into_effect() {
            None => Ok(()),
            Some(TransactionInitializationEffect::Complete {
                owner_id: effect_owner,
                operation_id,
                terminal,
            }) if effect_owner == owner_id
                && operation_id == self.operations[index].operation_id =>
            {
                self.retain_initialization_outcome(index, terminal)?;
                self.publish_terminal(index)
            }
            _ => Err(TransactionInitializationHostError::UnexpectedEffect),
        }
    }

    fn retain_initialization_outcome(
        &mut self,
        index: usize,
        terminal: TransactionInitializationTerminal,
    ) -> Result<(), TransactionInitializationHostError> {
        match terminal {
            TransactionInitializationTerminal::Initialized(identity) => {
                let request = self.operations[index]
                    .request
                    .take()
                    .ok_or(TransactionInitializationHostError::MissingTerminal)?;
                let (transactional_id, transaction_timeout_ms) = request.into_parts();
                let transactional_id = Arc::<str>::from(transactional_id);
                let active = Arc::new(AtomicBool::new(true));
                let owner_id = self.operations[index].owner_id;
                let publisher = self.completion_owner.lifecycle_publisher()?;
                let send_publisher = self.completion_owner.send_publisher()?;
                let offset_commit_publisher = self.completion_owner.offset_commit_publisher()?;
                let parts = TransactionalOwnerParts::new(
                    owner_id,
                    Arc::clone(&transactional_id),
                    identity.producer_id(),
                    identity.producer_epoch(),
                    Arc::clone(&active),
                    self.release_sender.clone(),
                    publisher,
                    send_publisher,
                    offset_commit_publisher,
                );
                let execution =
                    match TransactionExecutionHost::try_new(parts, self.execution_limits) {
                        Ok(execution) => execution,
                        Err((_error, parts)) => {
                            parts.discard_uninstalled();
                            self.operations[index].terminal = Some(
                            crate::transaction::initialization::outcome::
                                execution_unavailable_retained_outcome(),
                        );
                            return Ok(());
                        }
                    };
                self.executions.push(execution);
                self.live_owners.push(LiveTransactionalOwner {
                    owner_id,
                    active: Arc::clone(&active),
                    retained_bytes: TRANSACTION_INITIALIZATION_OPERATION_BYTES,
                });
                self.operations[index].terminal =
                    Some(RetainedTransactionInitializationOutcome::initialized(
                        owner_id,
                        transactional_id,
                        identity.producer_id(),
                        identity.producer_epoch(),
                        active,
                        self.owner_loss_sender.clone(),
                        Duration::from_millis(u64::from(transaction_timeout_ms)),
                    ));
                Ok(())
            }
            failed @ TransactionInitializationTerminal::Failed(_) => {
                self.operations[index].terminal =
                    crate::transaction::initialization::outcome::failed_retained_outcome(failed);
                Ok(())
            }
        }
    }

    pub(super) fn publish_terminal(
        &mut self,
        index: usize,
    ) -> Result<(), TransactionInitializationHostError> {
        let terminal = self.operations[index]
            .terminal
            .take()
            .ok_or(TransactionInitializationHostError::MissingTerminal)?;
        let initialized = terminal.is_initialized();
        let completion_id = self.operations[index].completion_id;
        match self.completions.publish(completion_id, terminal) {
            Ok(()) => {
                self.operations.remove(index);
                self.published_bytes.push((
                    completion_id,
                    if initialized {
                        0
                    } else {
                        TRANSACTION_INITIALIZATION_OPERATION_BYTES
                    },
                ));
                Ok(())
            }
            Err((error, terminal)) => {
                self.operations[index].terminal = Some(terminal);
                Err(TransactionInitializationHostError::Completion(error))
            }
        }
    }
}

pub(super) fn terminal_input(
    fact: TransactionInitTerminalFact<'_>,
) -> TransactionInitializationInput {
    match fact {
        TransactionInitTerminalFact::Failed { kind, delivery } => match kind {
            TransactionInitDriverFailureKind::DeadlineElapsed => {
                TransactionInitializationInput::DriverDeadlineElapsed { delivery }
            }
            TransactionInitDriverFailureKind::InvalidResponse => {
                TransactionInitializationInput::InvalidResponse
            }
            TransactionInitDriverFailureKind::Compatibility
            | TransactionInitDriverFailureKind::Transport => {
                TransactionInitializationInput::TransportFailed { delivery }
            }
        },
        TransactionInitTerminalFact::Response { response, .. } => {
            match normalize_transaction_init_response(response) {
                Ok(identity) => TransactionInitializationInput::BrokerInitialized {
                    producer_id: identity.producer_id,
                    producer_epoch: identity.producer_epoch,
                },
                Err(TransactionInitResponseFailure::Broker { code, category }) => {
                    TransactionInitializationInput::BrokerRejected {
                        failure: TransactionInitializationBrokerFailure::new(
                            code,
                            match category {
                                TransactionInitBrokerCategory::Fenced => {
                                    TransactionInitializationBrokerCategory::Fenced
                                }
                                TransactionInitBrokerCategory::Rejected => {
                                    TransactionInitializationBrokerCategory::Rejected
                                }
                            },
                        ),
                    }
                }
                Err(TransactionInitResponseFailure::InvalidIdentity) => {
                    TransactionInitializationInput::InvalidResponse
                }
            }
        }
    }
}