kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Bounded call admission and shared classic-group commit call fixtures.

use std::{
    sync::Arc,
    time::{Duration, Instant},
};

use kafka_client_core::{
    AssignmentGeneration, Deadline, GroupAssignmentPartition, GroupCheckpoint,
    GroupCheckpointEntry, GroupId, GroupOffsetCommitEffect, GroupOffsetCommitInput,
    GroupOffsetCommitMachine, LiveGroupAssignment, MemberId, OperationId, PartitionIndex, TopicId,
};

use crate::{
    EngineConfig,
    clock::OperationDeadline,
    protocol::consumer::{
        ClassicGroupCommitSession, GroupOffsetCommitEntryReservation,
        GroupOffsetCommitResultReservation, GroupOffsetCommitTopicName, PreparedGroupOffsetCommit,
        PreparedGroupOffsetCommitRequest, group_offset_commit_request,
    },
};

use super::{
    super::DriverOwner, group_offset_commit_calls::TrackedGroupOffsetCommitCalls,
    group_offset_commit_settlement_test::broker_rejection,
};

#[test]
fn exactly_eight_accepted_calls_occupy_the_configured_first_lane() {
    let mut owner = owner();
    let mut calls = TrackedGroupOffsetCommitCalls::new(8);
    for operation in 1..=8 {
        let permit = calls
            .try_reserve_group_commit()
            .unwrap_or_else(|| panic!("slot {operation} must be available"));
        let prepared = prepared(operation);
        let request = PreparedGroupOffsetCommitRequest::from_request_for_test(
            group_offset_commit_request(&prepared),
        );
        assert_eq!(
            permit
                .submit_prebuilt(&owner, prepared, request)
                .unwrap_or_else(|_| panic!("driver accepts call {operation}")),
            GroupOffsetCommitInput::DriverAccepted
        );
    }
    assert_eq!(calls.retained_group_commit_count(), 8);
    assert!(calls.try_reserve_group_commit().is_none());
    owner
        .shutdown_with_turn_limit(128, Duration::from_millis(5))
        .unwrap_or_else(|error| panic!("bounded driver shutdown: {error}"));
    let recovery = calls.recover_group_commits_after_driver_shutdown();
    let (recovered, settled, pending, completion) = recovery.into_parts();
    assert_eq!(recovered.len(), 8);
    assert_eq!(recovered[0].operation_id(), OperationId::from_raw(1));
    assert_eq!(recovered[7].operation_id(), OperationId::from_raw(8));
    assert!(settled.is_none());
    assert_eq!(pending, None);
    assert!(completion.is_none());
    assert_eq!(calls.retained_group_commit_count(), 0);
}

#[test]
fn driver_admission_failure_recovers_prepared_before_core_rejection() {
    let mut owner = owner();
    owner
        .shutdown_with_turn_limit(64, Duration::from_millis(5))
        .unwrap_or_else(|error| panic!("bounded driver shutdown: {error}"));
    let mut calls = TrackedGroupOffsetCommitCalls::new(8);
    let permit = calls
        .try_reserve_group_commit()
        .unwrap_or_else(|| panic!("one slot"));
    let prepared = prepared(12);
    let request = PreparedGroupOffsetCommitRequest::from_request_for_test(
        group_offset_commit_request(&prepared),
    );
    let failure = result_error(
        permit.submit_prebuilt(&owner, prepared, request),
        "closed driver rejects definitely unsent",
    );
    let (prepared, input, source) = failure.into_parts();
    assert_eq!(prepared.operation_id(), OperationId::from_raw(12));
    assert_eq!(
        prepared.operation_deadline().core(),
        Deadline::from_tick(100)
    );
    assert_eq!(prepared.entries_capacity(), 1);
    let mut machine = awaiting_machine(OperationId::from_raw(12));
    let transition = machine
        .apply(input)
        .unwrap_or_else(|error| panic!("core accepts driver rejection: {error}"));
    assert!(matches!(
        transition.into_effect(),
        Some(GroupOffsetCommitEffect::Complete { .. })
    ));
    assert!(matches!(
        source,
        super::group_offset_commit_submission::GroupOffsetCommitSubmitError::Driver(
            kafka_driver::SubmitError::Closed
        )
    ));
    assert_eq!(calls.retained_group_commit_count(), 0);
}

#[test]
fn deadline_expiry_preserves_the_exact_settled_broker_input() {
    let operation_id = OperationId::from_raw(21);
    let input = broker_rejection(16);
    let mut calls = TrackedGroupOffsetCommitCalls::new(1);
    calls.install_settlement_for_test(operation_id, input);

    assert!(!calls.expire_group_commit_coordinator_refresh(OperationId::from_raw(22)));
    assert!(calls.expire_group_commit_coordinator_refresh(operation_id));
    let input = calls
        .begin_group_commit_settlement(operation_id)
        .unwrap_or_else(|error| panic!("begin exact settlement: {error:?}"));
    assert_eq!(input, broker_rejection(16));
}

pub(super) fn prepared(operation: u64) -> PreparedGroupOffsetCommit {
    let entry_reservation = GroupOffsetCommitEntryReservation::try_new(1)
        .unwrap_or_else(|error| panic!("reserve entry capacity: {error:?}"));
    let result_reservation = GroupOffsetCommitResultReservation::try_new(1)
        .unwrap_or_else(|error| panic!("reserve result capacity: {error:?}"));
    let deadline = OperationDeadline::from_parts_for_test(
        Deadline::from_tick(100),
        Instant::now() + Duration::from_secs(1),
    );
    let checkpoint = GroupCheckpoint::try_new(
        group_id(),
        member_id(),
        generation(),
        vec![
            GroupCheckpointEntry::try_new(
                TopicId::from_raw(1),
                PartitionIndex::from_raw(0),
                10,
                None,
            )
            .unwrap_or_else(|error| panic!("valid entry: {error}")),
        ],
    )
    .unwrap_or_else(|error| panic!("valid checkpoint: {error}"));
    PreparedGroupOffsetCommit::from_effect(
        GroupOffsetCommitEffect::Submit {
            operation_id: OperationId::from_raw(operation),
            deadline: deadline.core(),
            checkpoint,
        },
        deadline,
        ClassicGroupCommitSession::new(
            group_id(),
            Arc::from("readers"),
            member_id(),
            Arc::from("member-a"),
            generation(),
            4,
        ),
        vec![GroupOffsetCommitTopicName::new(
            TopicId::from_raw(1),
            Arc::from("orders"),
        )],
        entry_reservation,
        result_reservation,
    )
    .unwrap_or_else(|error| panic!("valid prepared commit: {:?}", error.kind()))
}

pub(super) fn awaiting_machine(operation_id: OperationId) -> GroupOffsetCommitMachine {
    let checkpoint = GroupCheckpoint::try_new(
        group_id(),
        member_id(),
        generation(),
        vec![
            GroupCheckpointEntry::try_new(
                TopicId::from_raw(1),
                PartitionIndex::from_raw(0),
                10,
                None,
            )
            .unwrap_or_else(|error| panic!("valid machine entry: {error}")),
        ],
    )
    .unwrap_or_else(|error| panic!("valid machine checkpoint: {error}"));
    let assignment = LiveGroupAssignment::try_new(
        group_id(),
        member_id(),
        generation(),
        vec![GroupAssignmentPartition::new(
            TopicId::from_raw(1),
            PartitionIndex::from_raw(0),
        )],
    )
    .unwrap_or_else(|error| panic!("valid live assignment: {error}"));
    let admission = GroupOffsetCommitMachine::try_admit(
        operation_id,
        Deadline::from_tick(100),
        Some(&assignment),
        checkpoint,
    )
    .unwrap_or_else(|error| panic!("admit machine: {error}"));
    let (machine, _submit) = admission.into_parts();
    machine
}

pub(super) fn result_error<T, E>(result: Result<T, E>, context: &str) -> E {
    match result {
        Ok(_) => panic!("{context}"),
        Err(error) => error,
    }
}

fn owner() -> DriverOwner {
    DriverOwner::build(&EngineConfig::new(vec!["127.0.0.1:1".to_owned()]))
        .unwrap_or_else(|error| panic!("build driver owner: {error}"))
}

fn group_id() -> GroupId {
    GroupId::try_from_raw(1).unwrap_or_else(|| panic!("nonzero group"))
}

fn member_id() -> MemberId {
    MemberId::try_from_raw(2).unwrap_or_else(|| panic!("nonzero member"))
}

fn generation() -> AssignmentGeneration {
    AssignmentGeneration::try_from_raw(4).unwrap_or_else(|| panic!("nonzero generation"))
}