kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Exact unsettled accounting and deadline observation for classic membership.

use kafka_client_core::ClassicGroupPhase;

use crate::driver::classic_group::{
    ClassicCoordinatorInvalidationShutdownRecovery, ClassicCoordinatorInvalidations,
    TrackedClassicHeartbeatCalls, TrackedJoinGroupCalls, TrackedSyncGroupCalls,
};
use crate::driver::{
    GroupPositionOffsetFetchShutdownRecovery, TrackedGroupPositionOffsetFetchCalls,
};

use super::{
    classic_group_position::ClassicGroupPositionRecoveryFault,
    classic_group_recovery::recovery_unsettled_count,
    registry::GroupConsumerRegistry,
    registry_entry::{GroupConsumerEntry, GroupConsumerEntryState},
};

impl GroupConsumerRegistry {
    pub(super) fn position_unsettled(&self) -> usize {
        let entries = self
            .entries
            .iter()
            .map(|entry| entry.position.unsettled())
            .sum::<usize>();
        entries
            .saturating_add(self.position_calls.as_ref().map_or(
                0,
                TrackedGroupPositionOffsetFetchCalls::retained_group_position_offset_fetch_count,
            ))
            .saturating_add(
                self.position_shutdown_recovery
                    .as_ref()
                    .map_or(0, GroupPositionOffsetFetchShutdownRecovery::retained_count),
            )
            .saturating_add(
                self.position_recovery_fault
                    .as_ref()
                    .map_or(0, ClassicGroupPositionRecoveryFault::retained_owner_count),
            )
    }

    pub(super) fn position_next_deadline(&self) -> Option<kafka_client_core::Deadline> {
        self.entries
            .iter()
            .filter(|entry| {
                entry.fault.is_none() || entry.state == GroupConsumerEntryState::Closing
            })
            .filter_map(|entry| entry.position.next_deadline())
            .min()
    }

    pub(super) fn membership_unsettled(&self) -> usize {
        let entries: usize = self
            .entries
            .iter()
            .map(GroupConsumerEntry::membership_unsettled)
            .sum();
        let joins = self
            .join_calls
            .as_ref()
            .map_or(0, TrackedJoinGroupCalls::retained_join_group_count);
        let syncs = self
            .sync_calls
            .as_ref()
            .map_or(0, TrackedSyncGroupCalls::retained_sync_group_count);
        let heartbeats = self.heartbeat_calls.as_ref().map_or(
            0,
            TrackedClassicHeartbeatCalls::retained_classic_heartbeat_count,
        );
        let invalidations = self
            .coordinator_invalidations
            .as_ref()
            .map_or(0, ClassicCoordinatorInvalidations::retained_count);
        let invalidation_recovery = self
            .coordinator_invalidation_shutdown_recovery
            .as_ref()
            .map_or(
                0,
                ClassicCoordinatorInvalidationShutdownRecovery::retained_count,
            );
        let recovery = recovery_unsettled_count(
            self.heartbeat_shutdown_recovery.as_ref(),
            self.join_shutdown_recovery.as_ref(),
            self.sync_shutdown_recovery.as_ref(),
            self.heartbeat_recovery_fault.as_ref(),
            self.join_recovery_fault.as_ref(),
            self.sync_recovery_fault.as_ref(),
        );
        entries
            .saturating_add(joins)
            .saturating_add(syncs)
            .saturating_add(heartbeats)
            .saturating_add(invalidations)
            .saturating_add(invalidation_recovery)
            .saturating_add(recovery)
    }

    pub(super) fn membership_next_deadline(&self) -> Option<kafka_client_core::Deadline> {
        self.entries
            .iter()
            .filter(|entry| {
                entry.fault.is_none() || entry.state == GroupConsumerEntryState::Closing
            })
            .filter_map(|entry| {
                if let Some(consumer) = entry.consumer.as_ref() {
                    return [consumer.next_deadline(), entry.leave.next_deadline()]
                        .into_iter()
                        .flatten()
                        .min();
                }
                let route_blocked = entry.rediscovery.blocks_join()
                    || self
                        .coordinator_invalidations
                        .as_ref()
                        .is_some_and(|owner| owner.blocks_join(entry.group_id()));
                let rejoin_blocked = route_blocked || entry.classic_reconciliation.is_some();
                [
                    entry.execution.next_deadline(),
                    entry.heartbeat.next_deadline(),
                    entry.leave.next_deadline(),
                    if rejoin_blocked {
                        None
                    } else {
                        entry.rejoin.next_deadline()
                    },
                ]
                .into_iter()
                .flatten()
                .min()
            })
            .min()
    }
}

impl GroupConsumerEntry {
    fn membership_unsettled(&self) -> usize {
        let classic_reconciliation = usize::from(self.classic_reconciliation.is_some());
        if let Some(consumer) = self.consumer.as_ref() {
            return consumer
                .unsettled()
                .saturating_add(usize::from(self.consumer_revocation.is_some()))
                .saturating_add(usize::from(self.consumer_reconciliation.is_some()))
                .saturating_add(classic_reconciliation);
        }
        if let Some(fault) = &self.fault {
            return fault
                .retained_owner_count()
                .saturating_add(self.execution.unsettled())
                .saturating_add(self.heartbeat.unsettled())
                .saturating_add(self.leave.unsettled())
                .saturating_add(self.rejoin.unsettled())
                .saturating_add(self.rediscovery.unsettled())
                .saturating_add(classic_reconciliation);
        }
        if self.state == GroupConsumerEntryState::Closing
            && self.classic.machine().phase() != ClassicGroupPhase::Closed
        {
            return 1usize
                .saturating_add(self.heartbeat.unsettled())
                .saturating_add(self.leave.unsettled())
                .saturating_add(self.rejoin.unsettled())
                .saturating_add(self.rediscovery.unsettled())
                .saturating_add(classic_reconciliation);
        }
        self.execution
            .unsettled()
            .saturating_add(self.heartbeat.unsettled())
            .saturating_add(self.leave.unsettled())
            .saturating_add(self.rejoin.unsettled())
            .saturating_add(self.rediscovery.unsettled())
            .saturating_add(classic_reconciliation)
    }
}