kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Host wait selection and cross-thread turn-demand scenarios.

use std::time::Duration;

use kafka_client_core::{Deadline, Moment};

use crate::producer::host_turn::ProducerTurnOutcome;

use super::{
    assigned_consumer::AssignedConsumerProgress,
    group_consumer::GroupConsumerProgress,
    wait::{assigned_consumer, group_consumer, host_turn, producer},
};

#[test]
fn prepared_submission_parks_on_its_original_deadline() {
    let outcome = outcome(Some(Deadline::from_tick(250)), false, false);

    assert_eq!(
        producer(Moment::from_tick(100), Some(outcome), false),
        Duration::from_nanos(150)
    );
}

#[test]
fn every_nonzero_wait_is_capped_for_failed_wake_liveness() {
    let outcome = outcome(Some(Deadline::from_tick(1_000_000_000)), false, false);

    assert_eq!(
        producer(Moment::from_tick(0), Some(outcome), false),
        Duration::from_millis(100)
    );
}

#[test]
fn only_runnable_or_driver_local_work_requests_an_immediate_turn() {
    let runnable = outcome(None, true, false);
    assert_eq!(
        producer(Moment::from_tick(0), Some(runnable), false),
        Duration::ZERO
    );
    let idle = outcome(None, false, false);
    assert_eq!(
        producer(Moment::from_tick(0), Some(idle), true),
        Duration::ZERO
    );
}

#[test]
fn transient_lock_or_notification_work_uses_the_liveness_cap() {
    let blocked = outcome(None, false, true);

    assert_eq!(
        producer(Moment::from_tick(0), Some(blocked), false),
        Duration::from_millis(100)
    );
}

#[test]
fn host_turn_demand_preempts_the_selected_wait() {
    assert_eq!(host_turn(Duration::from_secs(1), true), Duration::ZERO);
    assert_eq!(
        host_turn(Duration::from_millis(17), false),
        Duration::from_millis(17)
    );
}

#[test]
fn actual_assigned_progress_requests_an_immediate_turn() {
    let progress = assigned_progress(None, true, false);

    assert_eq!(
        assigned_consumer(Moment::from_tick(10), Duration::from_millis(100), &progress),
        Duration::ZERO
    );
}

#[test]
fn assigned_deadline_can_preempt_other_domain_waits() {
    let progress = assigned_progress(Some(Deadline::from_tick(30)), false, false);

    assert_eq!(
        assigned_consumer(Moment::from_tick(10), Duration::from_nanos(80), &progress),
        Duration::from_nanos(20)
    );
}

#[test]
fn elapsed_assigned_deadline_is_immediate_without_claiming_progress() {
    let progress = assigned_progress(Some(Deadline::from_tick(9)), false, false);

    assert_eq!(
        assigned_consumer(Moment::from_tick(10), Duration::from_millis(100), &progress),
        Duration::ZERO
    );
}

#[test]
fn assigned_contention_uses_the_liveness_cap_instead_of_spinning() {
    let progress = assigned_progress(None, false, true);

    assert_eq!(
        assigned_consumer(Moment::from_tick(10), Duration::from_millis(100), &progress),
        Duration::from_millis(100)
    );
}

#[test]
fn group_progress_requests_an_immediate_followup_turn() {
    let progress = group_progress(None, true, false);

    assert_eq!(
        group_consumer(Moment::from_tick(10), Duration::from_millis(100), &progress),
        Duration::ZERO
    );
}

#[test]
fn group_deadline_can_preempt_other_domain_waits() {
    let progress = group_progress(Some(Deadline::from_tick(30)), false, false);

    assert_eq!(
        group_consumer(Moment::from_tick(10), Duration::from_nanos(80), &progress),
        Duration::from_nanos(20)
    );
}

#[test]
fn blocked_group_work_uses_the_liveness_cap_instead_of_spinning() {
    let progress = group_progress(None, false, true);

    assert_eq!(
        group_consumer(Moment::from_tick(10), Duration::from_millis(100), &progress),
        Duration::from_millis(100)
    );
}

const fn outcome(
    next_deadline: Option<Deadline>,
    runnable_work: bool,
    blocked_work: bool,
) -> ProducerTurnOutcome {
    ProducerTurnOutcome {
        batch_timers: 0,
        prepared_effects: 0,
        submission_expiries: 0,
        completion_retries: 0,
        reclaim_attempts: 0,
        waiting_admissions: 0,
        next_deadline,
        runnable_work,
        blocked_work,
    }
}

const fn assigned_progress(
    next_deadline: Option<Deadline>,
    progressed: bool,
    blocked_work: bool,
) -> AssignedConsumerProgress {
    AssignedConsumerProgress {
        unsettled: 1,
        progressed,
        blocked_work,
        next_deadline,
        close_completed: false,
    }
}

const fn group_progress(
    next_deadline: Option<Deadline>,
    progressed: bool,
    blocked_work: bool,
) -> GroupConsumerProgress {
    GroupConsumerProgress {
        unsettled: 1,
        progressed,
        blocked_work,
        next_deadline,
    }
}