use kafka_client_core::GroupId;
use kafka_driver::{
CompletionError, Delivery, RouteFailureToken, RouteKind, RoutedCall, RoutedOutcome,
};
use kafka_wire::LeaveGroupResponse;
use crate::{
clock::OperationDeadline,
protocol::consumer::{
ClassicLeaveGroupOutcome, PreparedClassicLeaveGroupRequest,
normalize_classic_leave_group_response,
},
};
use super::{
super::DriverOwner,
classic_group::PendingClassicCoordinatorInvalidation,
classic_group_leave_failure::{ClassicGroupLeaveDriverFailureKind, classify_request_error},
leave_group_submission::LeaveGroupSubmitError,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ClassicGroupLeaveCompletionError {
Closed,
Consumed,
Unknown,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ClassicGroupLeaveResolution {
Succeeded,
BrokerRejected(i16),
Failed {
kind: ClassicGroupLeaveDriverFailureKind,
definitely_not_sent: bool,
},
}
#[derive(Debug)]
pub(crate) struct ClassicGroupLeaveRoute {
token: Option<RouteFailureToken>,
}
impl ClassicGroupLeaveRoute {
pub(crate) fn into_coordinator_invalidation(
self,
group_id: GroupId,
) -> Result<PendingClassicCoordinatorInvalidation, Self> {
if self.token.as_ref().map(RouteFailureToken::kind) != Some(RouteKind::Coordinator) {
return Err(self);
}
let Self { token } = self;
let Some(token) = token else {
unreachable!("coordinator route kind requires a retained token")
};
Ok(PendingClassicCoordinatorInvalidation::new(group_id, token))
}
pub(crate) fn accept(self) {
drop(self);
}
}
pub(crate) struct ClassicGroupLeaveOutcome {
outcome: RoutedOutcome<LeaveGroupResponse>,
}
impl ClassicGroupLeaveOutcome {
pub(crate) fn into_resolution(self) -> (ClassicGroupLeaveResolution, ClassicGroupLeaveRoute) {
let (result, selected_version, route_token) = self.outcome.into_parts();
let route = ClassicGroupLeaveRoute { token: route_token };
let response = match result {
Ok(response) => response,
Err(error) => {
return (
ClassicGroupLeaveResolution::Failed {
kind: classify_request_error(&error),
definitely_not_sent: error.delivery() == Delivery::NotSent,
},
route,
);
}
};
let Some(version) = selected_version else {
return (
ClassicGroupLeaveResolution::Failed {
kind: ClassicGroupLeaveDriverFailureKind::Compatibility,
definitely_not_sent: false,
},
route,
);
};
let resolution = match normalize_classic_leave_group_response(version.value(), &response) {
Ok(ClassicLeaveGroupOutcome::Succeeded { .. }) => {
ClassicGroupLeaveResolution::Succeeded
}
Ok(ClassicLeaveGroupOutcome::Rejected { error_code, .. }) => {
ClassicGroupLeaveResolution::BrokerRejected(error_code.get())
}
Err(_error) => ClassicGroupLeaveResolution::Failed {
kind: ClassicGroupLeaveDriverFailureKind::InvalidResponse,
definitely_not_sent: false,
},
};
(resolution, route)
}
}
pub(crate) struct ClassicGroupLeaveCall {
call: RoutedCall<LeaveGroupResponse>,
}
impl ClassicGroupLeaveCall {
pub(crate) fn submit(
driver: &DriverOwner,
group: &str,
request: PreparedClassicLeaveGroupRequest,
deadline: OperationDeadline,
) -> Result<Self, LeaveGroupSubmitError> {
driver
.submit_tracked_leave_group(
group,
request.into_generated_leave_group_request(),
deadline,
)
.map(|call| Self { call })
}
pub(crate) fn try_result(
&self,
) -> Option<Result<ClassicGroupLeaveOutcome, ClassicGroupLeaveCompletionError>> {
self.call.try_result().map(|result| match result {
Ok(outcome) => Ok(ClassicGroupLeaveOutcome { outcome }),
Err(source) => Err(match source {
CompletionError::Closed => ClassicGroupLeaveCompletionError::Closed,
CompletionError::Consumed => ClassicGroupLeaveCompletionError::Consumed,
_ => ClassicGroupLeaveCompletionError::Unknown,
}),
})
}
}