kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Real classic membership transitions that yield exact heartbeat attempt identities.

use kafka_client_core::{
    ClassicGeneration, ClassicGroupEffect, ClassicGroupInput, ClassicGroupMachine,
    ClassicGroupTiming, ClassicHeartbeatAttempt, ClassicHeartbeatPolicy, ClassicRejoinPolicy,
    Deadline, GroupId, MemberId, Moment,
};
use kafka_driver::{RequestError, ResponseCloseReason};
use kafka_wire::HeartbeatResponse;

use super::{ClassicHeartbeatCallKey, TrackedClassicHeartbeatCalls};

pub(crate) fn install_heartbeat_success_terminal(
    calls: &mut TrackedClassicHeartbeatCalls,
    key: ClassicHeartbeatCallKey,
    throttle_time_ms: i32,
) {
    let mut response = HeartbeatResponse::default();
    response.throttle_time_ms = throttle_time_ms;
    calls.install_terminal_for_test(key, Some(2), Ok(response));
}

pub(crate) fn install_heartbeat_broker_rejection_terminal(
    calls: &mut TrackedClassicHeartbeatCalls,
    key: ClassicHeartbeatCallKey,
    error_code: i16,
) {
    let mut response = HeartbeatResponse::default();
    response.error_code = error_code;
    calls.install_terminal_for_test(key, Some(2), Ok(response));
}

pub(crate) fn install_heartbeat_route_failure_terminal(
    calls: &mut TrackedClassicHeartbeatCalls,
    key: ClassicHeartbeatCallKey,
) {
    calls.install_terminal_for_test(key, None, Err(RequestError::RouteUnavailable));
}

pub(crate) fn install_heartbeat_transport_loss_terminal(
    calls: &mut TrackedClassicHeartbeatCalls,
    key: ClassicHeartbeatCallKey,
) {
    calls.install_terminal_for_test(
        key,
        None,
        Err(RequestError::ConnectionClosed(
            ResponseCloseReason::TransportClosed,
        )),
    );
}

pub(crate) fn heartbeat_attempts() -> (ClassicHeartbeatAttempt, ClassicHeartbeatAttempt) {
    let mut machine = machine();
    machine
        .apply(ClassicGroupInput::Begin {
            now: Moment::from_tick(1),
            deadline: Deadline::from_tick(100),
        })
        .unwrap_or_else(|error| panic!("valid Begin: {error}"));
    let cycle = machine
        .active_cycle()
        .unwrap_or_else(|| panic!("active cycle expected"));
    machine
        .apply(ClassicGroupInput::JoinFollower {
            cycle,
            now: Moment::from_tick(2),
            member_id: MemberId::try_from_raw(2)
                .unwrap_or_else(|| panic!("nonzero member expected")),
            generation: ClassicGeneration::try_from_raw(7)
                .unwrap_or_else(|| panic!("nonnegative generation expected")),
        })
        .unwrap_or_else(|error| panic!("valid follower Join: {error}"));
    let installed = machine
        .apply(ClassicGroupInput::SyncSucceeded {
            cycle,
            now: Moment::from_tick(3),
            partitions: Vec::new(),
        })
        .unwrap_or_else(|error| panic!("valid Sync success: {error}"));
    let (first, first_due) = installed
        .into_effects()
        .find_map(|effect| match effect {
            ClassicGroupEffect::Install { heartbeat, .. } => {
                Some((heartbeat.attempt(), heartbeat.due()))
            }
            _ => None,
        })
        .unwrap_or_else(|| panic!("Install heartbeat schedule expected"));
    machine
        .apply(ClassicGroupInput::HeartbeatDue {
            attempt: first,
            now: Moment::from_tick(first_due.tick()),
        })
        .unwrap_or_else(|error| panic!("due heartbeat: {error}"));
    let succeeded = machine
        .apply(ClassicGroupInput::HeartbeatSucceeded {
            attempt: first,
            now: Moment::from_tick(first_due.tick() + 1),
            throttle_ticks: 0,
        })
        .unwrap_or_else(|error| panic!("successful heartbeat: {error}"));
    let next = succeeded
        .into_effects()
        .find_map(|effect| match effect {
            ClassicGroupEffect::ArmHeartbeat { schedule } => Some(schedule.attempt()),
            _ => None,
        })
        .unwrap_or_else(|| panic!("next heartbeat schedule expected"));
    (first, next)
}

fn machine() -> ClassicGroupMachine {
    ClassicGroupMachine::new(
        GroupId::try_from_raw(1).unwrap_or_else(|| panic!("nonzero group expected")),
        ClassicGroupTiming::try_new(10_000, 30_000)
            .unwrap_or_else(|error| panic!("valid timing: {error}")),
        ClassicHeartbeatPolicy::try_new(10, 20)
            .unwrap_or_else(|error| panic!("valid heartbeat policy: {error}")),
        ClassicRejoinPolicy::try_new(30, 40)
            .unwrap_or_else(|error| panic!("valid rejoin policy: {error:?}")),
    )
}