kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Infallible broker Fetch-session membership commits after reserved admission.

use kafka_client_core::{AssignedConsumerEffect, PositionFence};

use crate::{driver::BrokerId, protocol::fetch::FetchSessionRequest};

use super::broker_session::{BrokerFetchSessions, BrokerSessionMember, BrokerSessionPlan};

pub(super) struct RetainedBrokerMember {
    pub(super) broker_id: BrokerId,
    pub(super) member: BrokerSessionMember,
    pub(super) forgotten: bool,
}

pub(super) struct BrokerSessionEntry {
    pub(super) broker_id: BrokerId,
    pub(super) metadata: FetchSessionRequest,
    pub(super) in_flight: bool,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum BrokerSessionError {
    Allocation,
    EntryCapacity,
    MemberCapacity,
    InFlight,
    MissingEntry,
    NotInFlight,
    PlanMismatch,
}

impl BrokerFetchSessions {
    pub(super) fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    pub(super) fn len(&self) -> usize {
        self.entries.len()
    }

    pub(super) fn first_broker_id(&self) -> Option<BrokerId> {
        self.entries.first().map(|entry| entry.broker_id)
    }

    pub(super) fn has_forgotten_ready(&self) -> bool {
        self.entries.iter().any(|entry| {
            !entry.in_flight
                && entry.metadata.is_incremental()
                && self
                    .members
                    .iter()
                    .any(|member| member.broker_id == entry.broker_id && member.forgotten)
        })
    }

    pub(super) fn discard_all(&mut self) {
        self.entries.clear();
        self.members.clear();
    }

    pub(super) fn observe_control(&mut self, effect: AssignedConsumerEffect) {
        for retained in &mut self.members {
            if control_covers(retained.member.position(), effect) {
                retained.forgotten = true;
            }
        }
    }

    pub(super) fn live_plan_index(
        &self,
        plan: &BrokerSessionPlan,
    ) -> Result<usize, BrokerSessionError> {
        let Some(index) = self
            .entries
            .iter()
            .position(|entry| entry.broker_id == plan.broker_id())
        else {
            return Err(BrokerSessionError::MissingEntry);
        };
        if !self.entries[index].in_flight {
            return Err(BrokerSessionError::NotInFlight);
        }
        Ok(index)
    }

    pub(super) fn reset_index(&mut self, index: usize) {
        let broker_id = self.entries[index].broker_id;
        self.entries[index].metadata = FetchSessionRequest::INITIAL;
        self.entries[index].in_flight = false;
        self.members.retain(|member| member.broker_id != broker_id);
    }

    pub(super) fn remove_index(&mut self, index: usize) {
        let broker_id = self.entries.swap_remove(index).broker_id;
        self.members.retain(|member| member.broker_id != broker_id);
    }

    pub(super) fn apply_forgotten(&mut self, plan: &BrokerSessionPlan) {
        self.members.retain(|retained| {
            retained.broker_id != plan.broker_id()
                || !plan.forgotten().iter().any(|forgotten| {
                    forgotten.position().partition() == retained.member.position().partition()
                })
        });
    }

    pub(super) fn apply_active(&mut self, broker_id: BrokerId, active: Vec<BrokerSessionMember>) {
        for member in active {
            let partition = member.position().partition();
            for retained in &mut self.members {
                if retained.member.position().partition() == partition
                    && retained.broker_id != broker_id
                {
                    retained.forgotten = true;
                }
            }
            if let Some(retained) = self.members.iter_mut().find(|retained| {
                retained.broker_id == broker_id
                    && retained.member.position().partition() == partition
            }) {
                retained.member = member;
                retained.forgotten = false;
            } else {
                debug_assert!(self.members.len() < self.member_capacity);
                self.members.push(RetainedBrokerMember {
                    broker_id,
                    member,
                    forgotten: false,
                });
            }
        }
    }

    #[cfg(test)]
    pub(super) fn retained(&self) -> (usize, usize) {
        (self.entries.len(), self.members.len())
    }

    #[cfg(test)]
    pub(super) fn metadata(&self, broker_id: BrokerId) -> Option<FetchSessionRequest> {
        self.entries
            .iter()
            .find(|entry| entry.broker_id == broker_id)
            .map(|entry| entry.metadata)
    }
}

fn control_covers(position: PositionFence, effect: AssignedConsumerEffect) -> bool {
    match effect {
        AssignedConsumerEffect::Revoke {
            assignment_epoch,
            partition,
        } => position.assignment_epoch() == assignment_epoch && position.partition() == partition,
        AssignedConsumerEffect::Suspend { fence } => {
            position.assignment_epoch() == fence.assignment_epoch()
                && position.partition() == fence.partition()
                && position.position_epoch() < fence.position_epoch()
        }
        _ => false,
    }
}