kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! One bounded scheduling action for queued and driver-owned commits.

use kafka_client_core::{DeliveryStatus, GroupOffsetCommitInput, Moment};

use crate::driver::{DriverOwner, GroupOffsetCommitPoll, GroupOffsetCommitRefreshPoll};

use super::host::{
    GroupOffsetCommitAttempt, GroupOffsetCommitHost, GroupOffsetCommitHostError,
    GroupOffsetCommitTurn,
};

impl GroupOffsetCommitHost {
    pub(in crate::consumer::group) fn turn(
        &mut self,
        now: Moment,
        driver: &DriverOwner,
    ) -> Result<GroupOffsetCommitTurn, GroupOffsetCommitHostError> {
        match self.turn_once(now, driver) {
            Ok(turn) => Ok(turn),
            Err(error) => {
                if !matches!(
                    error,
                    GroupOffsetCommitHostError::Completion(
                        crate::completion::CompletionRegistryError::NotificationBackpressure
                    )
                ) {
                    self.fault = Some(error);
                }
                Err(error)
            }
        }
    }

    fn turn_once(
        &mut self,
        now: Moment,
        driver: &DriverOwner,
    ) -> Result<GroupOffsetCommitTurn, GroupOffsetCommitHostError> {
        if let Some(fault) = self.fault {
            return Err(fault);
        }
        if self.reclaim_one()? {
            return Ok(GroupOffsetCommitTurn::Progress);
        }
        if let Some(index) = self
            .operations
            .iter()
            .position(|operation| operation.terminal.is_some())
        {
            self.publish_terminal(index)?;
            return Ok(GroupOffsetCommitTurn::Progress);
        }
        match self.calls.poll_group_commit() {
            Ok(GroupOffsetCommitPoll::TerminalReady { operation_id }) => {
                let deadline = self
                    .operations
                    .iter()
                    .find(|operation| operation.operation_id == operation_id)
                    .map(|operation| operation.deadline.core())
                    .ok_or(GroupOffsetCommitHostError::UnknownOperation)?;
                if deadline.is_elapsed_at(now) {
                    if !self
                        .calls
                        .expire_group_commit_coordinator_refresh(operation_id)
                    {
                        return Err(GroupOffsetCommitHostError::Settlement);
                    }
                } else {
                    match self
                        .calls
                        .poll_group_commit_coordinator_refresh(operation_id, driver)
                    {
                        Some(GroupOffsetCommitRefreshPoll::Ready) => {}
                        Some(GroupOffsetCommitRefreshPoll::Submitted) => {
                            return Ok(GroupOffsetCommitTurn::Progress);
                        }
                        Some(GroupOffsetCommitRefreshPoll::Pending) => {
                            return Ok(GroupOffsetCommitTurn::Idle);
                        }
                        None => return Err(GroupOffsetCommitHostError::Settlement),
                    }
                }
                self.settle_driver_terminal(operation_id)?;
                return Ok(GroupOffsetCommitTurn::Progress);
            }
            Ok(GroupOffsetCommitPoll::ConfirmationPending { .. }) => {
                return Err(GroupOffsetCommitHostError::Settlement);
            }
            Err(_observation) => return Err(GroupOffsetCommitHostError::DriverCompletion),
            Ok(GroupOffsetCommitPoll::Idle) => {}
        }
        if let Some(index) = self.expired_queued(now) {
            self.apply_terminal(
                index,
                GroupOffsetCommitInput::DeadlineElapsed {
                    delivery: DeliveryStatus::NotSent,
                },
                super::host::GroupOffsetCommitSettlementProvenance::DefinitelyUnsent,
            )?;
            self.operations[index].replace_attempt(None);
            self.publish_terminal(index)?;
            return Ok(GroupOffsetCommitTurn::Progress);
        }
        let Some(index) = self.queued_index() else {
            return Ok(GroupOffsetCommitTurn::Idle);
        };
        if self.submit(index, driver)? {
            Ok(GroupOffsetCommitTurn::Progress)
        } else {
            Ok(GroupOffsetCommitTurn::Idle)
        }
    }

    pub(in crate::consumer::group) fn next_deadline(&self) -> Option<kafka_client_core::Deadline> {
        self.operations
            .iter()
            .filter(|operation| operation.attempt.is_some())
            .map(|operation| operation.deadline.core())
            .min()
    }

    fn expired_queued(&self, now: Moment) -> Option<usize> {
        self.operations.iter().position(|operation| {
            matches!(operation.attempt, Some(GroupOffsetCommitAttempt::Queued(_)))
                && operation.deadline.core().is_elapsed_at(now)
        })
    }

    fn queued_index(&self) -> Option<usize> {
        self.operations.iter().position(|operation| {
            matches!(operation.attempt, Some(GroupOffsetCommitAttempt::Queued(_)))
        })
    }

    fn submit(
        &mut self,
        index: usize,
        driver: &DriverOwner,
    ) -> Result<bool, GroupOffsetCommitHostError> {
        let Some(permit) = self.calls.try_reserve_group_commit() else {
            return Ok(false);
        };
        let Some(GroupOffsetCommitAttempt::Queued(submission)) =
            self.operations[index].replace_attempt(None)
        else {
            return Err(GroupOffsetCommitHostError::MissingPrepared);
        };
        self.operations[index].replace_attempt(Some(GroupOffsetCommitAttempt::HandedOff));
        match permit.submit_prebuilt(driver, submission.prepared, submission.request) {
            Ok(input) => {
                self.apply_nonterminal(index, input)?;
                Ok(true)
            }
            Err(failure) => {
                let (prepared, input, _source) = failure.into_parts();
                self.operations[index]
                    .replace_attempt(Some(GroupOffsetCommitAttempt::Recovery(prepared)));
                self.apply_terminal(
                    index,
                    input,
                    super::host::GroupOffsetCommitSettlementProvenance::DefinitelyUnsent,
                )?;
                self.operations[index].replace_attempt(None);
                self.publish_terminal(index)?;
                Ok(true)
            }
        }
    }
}