use kafka_wire::{LeaveGroupRequest, leave_group_request::MemberIdentity};
use kafka_wire_core::StrBytes;
use super::validation::valid_kafka_string;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ClassicLeaveGroupRequestFailure {
GroupName,
MemberId,
GroupInstanceId,
}
#[must_use = "a prepared LeaveGroup request must be submitted or deliberately released"]
pub(crate) struct PreparedClassicLeaveGroupRequest {
request: LeaveGroupRequest,
}
impl PreparedClassicLeaveGroupRequest {
pub(crate) fn into_generated_leave_group_request(self) -> LeaveGroupRequest {
self.request
}
#[cfg(test)]
pub(super) const fn request_for_test(&self) -> &LeaveGroupRequest {
&self.request
}
}
pub(crate) fn classic_leave_group_request(
group: &str,
member: &str,
) -> Result<PreparedClassicLeaveGroupRequest, ClassicLeaveGroupRequestFailure> {
classic_leave_group_request_with_instance(group, member, None)
}
pub(crate) fn classic_leave_group_request_with_instance(
group: &str,
member: &str,
group_instance_id: Option<&str>,
) -> Result<PreparedClassicLeaveGroupRequest, ClassicLeaveGroupRequestFailure> {
if !valid_kafka_string(group) {
return Err(ClassicLeaveGroupRequestFailure::GroupName);
}
if !valid_kafka_string(member) {
return Err(ClassicLeaveGroupRequestFailure::MemberId);
}
if group_instance_id.is_some_and(|value| !valid_kafka_string(value)) {
return Err(ClassicLeaveGroupRequestFailure::GroupInstanceId);
}
let mut request = LeaveGroupRequest::default();
request.group_id = group.into();
if let Some(group_instance_id) = group_instance_id {
request.member_id = StrBytes::default();
let mut identity = MemberIdentity::default();
identity.member_id = member.into();
identity.group_instance_id = Some(group_instance_id.into());
request.members.push(identity);
} else {
request.member_id = member.into();
request.members.clear();
}
Ok(PreparedClassicLeaveGroupRequest { request })
}