Skip to main content

kafka_client_engine/consumer/assigned_host/
close_observer.rs

1//! Named runtime-neutral observation of one assigned-consumer close terminal.
2
3use std::{
4    fmt,
5    future::Future,
6    pin::Pin,
7    task::{Context, Poll},
8};
9
10use kafka_client_core::AssignedConsumerCloseId;
11
12use crate::completion::{CompletionObserver, CompletionObserverError};
13
14/// Terminal authority for one accepted assigned-consumer close.
15#[derive(Clone, Copy, Debug, Eq, PartialEq)]
16pub(crate) enum AssignedConsumerCloseTerminal {
17    Closed(AssignedConsumerCloseId),
18    ExecutionUnavailable,
19}
20
21/// Observation failure without changing close or delivery semantics.
22#[derive(Clone, Copy, Debug, Eq, PartialEq)]
23pub enum AssignedConsumerCloseObserverError {
24    /// The engine lost execution ownership after close was accepted.
25    ExecutionUnavailable,
26    /// This single observer already yielded its terminal result.
27    AlreadyObserved,
28    /// The completion generation no longer belongs to this observer.
29    Stale,
30}
31
32/// Single non-clone observer shared by asynchronous and blocking callers.
33#[must_use = "dropping abandons close observation without cancelling accepted close work"]
34pub struct AssignedConsumerCloseObserver {
35    inner: CompletionObserver<AssignedConsumerCloseTerminal>,
36}
37
38impl AssignedConsumerCloseObserver {
39    pub(crate) const fn from_completion(
40        inner: CompletionObserver<AssignedConsumerCloseTerminal>,
41    ) -> Self {
42        Self { inner }
43    }
44
45    /// Blocks on the same terminal cell used by `Future::poll`.
46    pub fn wait(self) -> Result<(), AssignedConsumerCloseObserverError> {
47        translate_terminal(self.inner.wait().map_err(observer_error)?)
48    }
49}
50
51impl Future for AssignedConsumerCloseObserver {
52    type Output = Result<(), AssignedConsumerCloseObserverError>;
53
54    fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output> {
55        let this = self.get_mut();
56        Pin::new(&mut this.inner)
57            .poll(context)
58            .map(|result| result.map_err(observer_error).and_then(translate_terminal))
59    }
60}
61
62impl fmt::Debug for AssignedConsumerCloseObserver {
63    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
64        formatter
65            .debug_struct("AssignedConsumerCloseObserver")
66            .finish_non_exhaustive()
67    }
68}
69
70const fn observer_error(error: CompletionObserverError) -> AssignedConsumerCloseObserverError {
71    match error {
72        CompletionObserverError::AlreadyObserved => {
73            AssignedConsumerCloseObserverError::AlreadyObserved
74        }
75        CompletionObserverError::Stale => AssignedConsumerCloseObserverError::Stale,
76    }
77}
78
79const fn translate_terminal(
80    terminal: AssignedConsumerCloseTerminal,
81) -> Result<(), AssignedConsumerCloseObserverError> {
82    match terminal {
83        AssignedConsumerCloseTerminal::Closed(_close_id) => Ok(()),
84        AssignedConsumerCloseTerminal::ExecutionUnavailable => {
85            Err(AssignedConsumerCloseObserverError::ExecutionUnavailable)
86        }
87    }
88}
89
90impl fmt::Display for AssignedConsumerCloseObserverError {
91    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
92        match self {
93            Self::ExecutionUnavailable => {
94                formatter.write_str("assigned-consumer close execution became unavailable")
95            }
96            Self::AlreadyObserved => formatter.write_str("close completion was already observed"),
97            Self::Stale => formatter.write_str("close observer is stale"),
98        }
99    }
100}
101
102impl std::error::Error for AssignedConsumerCloseObserverError {}