use kafka_client_core::ClassicGeneration;
use kafka_wire::HeartbeatRequest;
use super::validation::valid_kafka_string;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ClassicHeartbeatRequestFailure {
GroupName,
MemberId,
GroupInstanceId,
}
#[must_use = "a prepared classic Heartbeat request must be submitted or deliberately released"]
pub(crate) struct PreparedClassicHeartbeatRequest {
request: HeartbeatRequest,
}
impl PreparedClassicHeartbeatRequest {
pub(crate) fn into_generated_heartbeat_request(self) -> HeartbeatRequest {
self.request
}
#[cfg(test)]
pub(super) const fn request_for_test(&self) -> &HeartbeatRequest {
&self.request
}
}
pub(crate) fn classic_heartbeat_request(
group: &str,
member: &str,
generation: ClassicGeneration,
) -> Result<PreparedClassicHeartbeatRequest, ClassicHeartbeatRequestFailure> {
build_classic_heartbeat_request(group, member, None, generation)
}
pub(crate) fn classic_heartbeat_request_with_instance(
group: &str,
member: &str,
group_instance_id: Option<&str>,
generation: ClassicGeneration,
) -> Result<PreparedClassicHeartbeatRequest, ClassicHeartbeatRequestFailure> {
build_classic_heartbeat_request(group, member, group_instance_id, generation)
}
fn build_classic_heartbeat_request(
group: &str,
member: &str,
group_instance_id: Option<&str>,
generation: ClassicGeneration,
) -> Result<PreparedClassicHeartbeatRequest, ClassicHeartbeatRequestFailure> {
if !valid_kafka_string(group) {
return Err(ClassicHeartbeatRequestFailure::GroupName);
}
if !valid_kafka_string(member) {
return Err(ClassicHeartbeatRequestFailure::MemberId);
}
if group_instance_id.is_some_and(|value| !valid_kafka_string(value)) {
return Err(ClassicHeartbeatRequestFailure::GroupInstanceId);
}
let mut request = HeartbeatRequest::default();
request.group_id = group.into();
request.generation_id = generation.get();
request.member_id = member.into();
request.group_instance_id = group_instance_id.map(Into::into);
Ok(PreparedClassicHeartbeatRequest { request })
}