kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Hosted group-delivery fixture for public batch ownership tests.

use std::sync::Arc;

use kafka_client_core::GroupId;

use crate::{
    clock::MonotonicClock,
    consumer::{
        GroupConsumerHandle, GroupConsumerRegistration,
        group::{
            GroupConsumerShardOwner, GroupConsumerShardWake, GroupConsumerShardWakeError,
            install_group_session_for_public_test, install_ready_group_delivery_for_public_test,
            started_group_registry_for_public_test,
        },
    },
};

pub(crate) struct GroupBatchFixture {
    pub(crate) owner: GroupConsumerShardOwner,
    pub(crate) handle: GroupConsumerHandle,
    pub(crate) group_id: GroupId,
}

impl GroupBatchFixture {
    pub(crate) fn start() -> Self {
        let registry = started_group_registry_for_public_test();
        let (owner, port) = GroupConsumerShardOwner::new(
            registry,
            Arc::new(MonotonicClock::new()),
            Arc::new(NoopWake),
        );
        let lifetime: Arc<dyn Send + Sync> = Arc::new(());
        let handle = GroupConsumerHandle::try_register(
            port,
            lifetime,
            GroupConsumerRegistration::new(Arc::from("workers"), vec![Arc::from("orders")]),
        )
        .unwrap_or_else(|error| panic!("group registration: {error}"));
        let group_id = handle.group_id_for_test();
        {
            let mut registry = owner.lock_registry_for_test();
            install_group_session_for_public_test(&mut registry, group_id);
            install_ready_group_delivery_for_public_test(&mut registry, group_id, 17);
        }
        Self {
            owner,
            handle,
            group_id,
        }
    }

    pub(crate) fn finish(self) {
        let Self {
            mut owner,
            handle,
            group_id: _group_id,
        } = self;
        drop(handle);
        let mut registry = owner.terminal_registry();
        registry
            .recover_after_driver_shutdown()
            .unwrap_or_else(|error| panic!("registry recovery: {error}"));
        let commit_join = registry
            .finish_shutdown()
            .unwrap_or_else(|error| panic!("registry finish: {error}"));
        drop(registry);
        let recv_join = owner
            .stop_recv_notifier()
            .unwrap_or_else(|| panic!("group receive notifier owner"));
        commit_join
            .join_off_notifier()
            .unwrap_or_else(|error| panic!("commit notifier join: {error}"));
        recv_join
            .join_off_notifier()
            .unwrap_or_else(|error| panic!("receive notifier join: {error}"));
    }
}

struct NoopWake;

impl GroupConsumerShardWake for NoopWake {
    fn request_group_turn(&self) -> Result<(), GroupConsumerShardWakeError> {
        Ok(())
    }
}