use kafka_driver::{
CallFailure, ConnectionCloseReason, NegotiationFailure, RequestError, ResponseCloseReason,
};
use kafka_wire_core::{DecodeError, EncodeError};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ConsumerGroupHeartbeatDriverFailureKind {
DeadlineElapsed,
Compatibility,
DriverRejected,
Transport,
InvalidResponse,
ResponseTooLarge,
}
pub(super) fn classify_consumer_group_heartbeat_request_error(
error: &RequestError,
) -> ConsumerGroupHeartbeatDriverFailureKind {
#[allow(
clippy::match_same_arms,
unreachable_patterns,
reason = "the published driver RC exposes a non-exhaustive request error while the reviewed path dependency is exhaustive"
)]
match error {
RequestError::Encode(error) => classify_encode(error),
RequestError::Decode(error) => classify_decode(error),
RequestError::UnsupportedVersion { .. }
| RequestError::ApiUnavailable { .. }
| RequestError::VersionLimitUnavailable { .. }
| RequestError::VersionFloorUnavailable { .. }
| RequestError::VersionBoundsInvalid { .. } => {
ConsumerGroupHeartbeatDriverFailureKind::Compatibility
}
RequestError::ResponseCapacityReached { .. }
| RequestError::IdentityConflict
| RequestError::DeadlineOverflow
| RequestError::RouteCapacityReached { .. }
| RequestError::MetadataQueryCapacityReached { .. }
| RequestError::CoordinatorCapacityReached { .. }
| RequestError::NameResolutionCapacityReached { .. } => {
ConsumerGroupHeartbeatDriverFailureKind::DriverRejected
}
RequestError::RouteUnavailable | RequestError::NameResolutionFailed { .. } => {
ConsumerGroupHeartbeatDriverFailureKind::Transport
}
RequestError::Rejected { failure, .. } => classify_call(*failure),
RequestError::ConnectionClosed(reason) => classify_response_close(*reason),
_ => ConsumerGroupHeartbeatDriverFailureKind::DriverRejected,
}
}
fn classify_encode(error: &EncodeError) -> ConsumerGroupHeartbeatDriverFailureKind {
match error {
EncodeError::UnsupportedVersion { .. }
| EncodeError::FieldNotRepresentable { .. }
| EncodeError::NullNotAllowed { .. }
| EncodeError::TaggedFieldsNotRepresentable { .. } => {
ConsumerGroupHeartbeatDriverFailureKind::Compatibility
}
_ => ConsumerGroupHeartbeatDriverFailureKind::DriverRejected,
}
}
fn classify_decode(error: &DecodeError) -> ConsumerGroupHeartbeatDriverFailureKind {
match error {
DecodeError::UnsupportedVersion { .. } => {
ConsumerGroupHeartbeatDriverFailureKind::Compatibility
}
DecodeError::LimitExceeded { .. } | DecodeError::LengthOverflow { .. } => {
ConsumerGroupHeartbeatDriverFailureKind::ResponseTooLarge
}
_ => ConsumerGroupHeartbeatDriverFailureKind::InvalidResponse,
}
}
const fn classify_call(failure: CallFailure) -> ConsumerGroupHeartbeatDriverFailureKind {
match failure {
CallFailure::DeadlineExceeded => ConsumerGroupHeartbeatDriverFailureKind::DeadlineElapsed,
CallFailure::CapacityReached { .. }
| CallFailure::CorrelationSpaceExhausted
| CallFailure::LocallyRejected => ConsumerGroupHeartbeatDriverFailureKind::DriverRejected,
CallFailure::CorrelationMismatch { .. } => {
ConsumerGroupHeartbeatDriverFailureKind::InvalidResponse
}
CallFailure::ConnectionClosed { reason } => classify_connection_close(reason),
CallFailure::NotReady | CallFailure::Draining | CallFailure::Closed => {
ConsumerGroupHeartbeatDriverFailureKind::Transport
}
}
}
const fn classify_connection_close(
reason: ConnectionCloseReason,
) -> ConsumerGroupHeartbeatDriverFailureKind {
match reason {
ConnectionCloseReason::NegotiationFailed(NegotiationFailure::Malformed)
| ConnectionCloseReason::CorrelationMismatch { .. }
| ConnectionCloseReason::UnexpectedResponse
| ConnectionCloseReason::MalformedResponse => {
ConsumerGroupHeartbeatDriverFailureKind::InvalidResponse
}
ConnectionCloseReason::NegotiationFailed(NegotiationFailure::Capacity) => {
ConsumerGroupHeartbeatDriverFailureKind::ResponseTooLarge
}
_ => ConsumerGroupHeartbeatDriverFailureKind::Transport,
}
}
#[allow(
clippy::match_same_arms,
unreachable_patterns,
reason = "an unknown close reason cannot safely acquire transport-retry semantics"
)]
const fn classify_response_close(
reason: ResponseCloseReason,
) -> ConsumerGroupHeartbeatDriverFailureKind {
match reason {
ResponseCloseReason::ProtocolFault => {
ConsumerGroupHeartbeatDriverFailureKind::InvalidResponse
}
ResponseCloseReason::TransportClosed | ResponseCloseReason::Shutdown => {
ConsumerGroupHeartbeatDriverFailureKind::Transport
}
_ => ConsumerGroupHeartbeatDriverFailureKind::InvalidResponse,
}
}