use std::{fmt, sync::Arc, time::Duration};
use super::GroupConsumerCommitObserver;
use crate::consumer::{
GroupConsumerCheckpoint, GroupConsumerHandle, group::GroupConsumerCommitPortErrorCategory,
};
impl GroupConsumerHandle {
pub fn try_commit(
&mut self,
checkpoint: GroupConsumerCheckpoint,
timeout: Duration,
) -> Result<GroupConsumerCommitAccepted, GroupConsumerCommitAdmissionError> {
let capture = match self.port.capture_commit_deadline(timeout) {
Ok(capture) => capture,
Err(_error) => {
return Err(GroupConsumerCommitAdmissionError {
kind: GroupConsumerCommitAdmissionErrorKind::InvalidDeadline,
checkpoint,
});
}
};
let (observation, submission) = match checkpoint.try_into_commit_parts() {
Ok(parts) => parts,
Err(checkpoint) => {
return Err(GroupConsumerCommitAdmissionError {
kind: GroupConsumerCommitAdmissionErrorKind::Backpressure,
checkpoint,
});
}
};
let admission = match self
.port
.admit_captured_commit(self.group_id, capture, submission)
{
Ok(admission) => admission,
Err(failure) => {
let kind = admission_error_kind(failure.public_category());
drop(failure.into_checkpoint());
let checkpoint = observation.into_checkpoint();
return Err(GroupConsumerCommitAdmissionError { kind, checkpoint });
}
};
let (accepted, wake_failed) = admission.into_public_parts();
let host_faulted = accepted.host_faulted();
Ok(GroupConsumerCommitAccepted {
observer: GroupConsumerCommitObserver::new(
accepted.into_observer(),
observation,
Arc::clone(&self.lifetime),
),
host_faulted,
wake_failed,
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum GroupConsumerCommitAdmissionErrorKind {
InvalidDeadline,
Closed,
Contended,
GroupUnavailable,
Backpressure,
StaleCheckpoint,
HostUnavailable,
}
#[must_use = "commit rejection retains the exact non-clone checkpoint"]
pub struct GroupConsumerCommitAdmissionError {
kind: GroupConsumerCommitAdmissionErrorKind,
checkpoint: GroupConsumerCheckpoint,
}
impl GroupConsumerCommitAdmissionError {
pub const fn kind(&self) -> GroupConsumerCommitAdmissionErrorKind {
self.kind
}
pub fn into_checkpoint(self) -> GroupConsumerCheckpoint {
self.checkpoint
}
}
impl fmt::Debug for GroupConsumerCommitAdmissionError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("GroupConsumerCommitAdmissionError")
.field("kind", &self.kind)
.field("checkpoint", &self.checkpoint)
.finish()
}
}
impl fmt::Display for GroupConsumerCommitAdmissionError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
formatter,
"classic-group checkpoint commit rejected: {:?}",
self.kind
)
}
}
impl std::error::Error for GroupConsumerCommitAdmissionError {}
#[must_use = "accepted commit retains its sole terminal observer"]
pub struct GroupConsumerCommitAccepted {
observer: GroupConsumerCommitObserver,
host_faulted: bool,
wake_failed: bool,
}
impl GroupConsumerCommitAccepted {
pub const fn host_faulted(&self) -> bool {
self.host_faulted
}
pub const fn wake_failed(&self) -> bool {
self.wake_failed
}
pub fn into_observer(self) -> GroupConsumerCommitObserver {
self.observer
}
}
impl fmt::Debug for GroupConsumerCommitAccepted {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("GroupConsumerCommitAccepted")
.field("observer", &self.observer)
.field("host_faulted", &self.host_faulted)
.field("wake_failed", &self.wake_failed)
.finish()
}
}
const fn admission_error_kind(
category: GroupConsumerCommitPortErrorCategory,
) -> GroupConsumerCommitAdmissionErrorKind {
match category {
GroupConsumerCommitPortErrorCategory::InvalidDeadline => {
GroupConsumerCommitAdmissionErrorKind::InvalidDeadline
}
GroupConsumerCommitPortErrorCategory::Closed => {
GroupConsumerCommitAdmissionErrorKind::Closed
}
GroupConsumerCommitPortErrorCategory::Contended => {
GroupConsumerCommitAdmissionErrorKind::Contended
}
GroupConsumerCommitPortErrorCategory::GroupUnavailable => {
GroupConsumerCommitAdmissionErrorKind::GroupUnavailable
}
GroupConsumerCommitPortErrorCategory::Backpressure => {
GroupConsumerCommitAdmissionErrorKind::Backpressure
}
GroupConsumerCommitPortErrorCategory::StaleCheckpoint => {
GroupConsumerCommitAdmissionErrorKind::StaleCheckpoint
}
GroupConsumerCommitPortErrorCategory::HostUnavailable => {
GroupConsumerCommitAdmissionErrorKind::HostUnavailable
}
}
}