Skip to main content

kafka_client_engine/transaction/initialization/
observer.rs

1//! Runtime-neutral observation of one transaction-initialization terminal.
2
3use std::{
4    future::Future,
5    pin::Pin,
6    sync::Arc,
7    task::{Context, Poll},
8};
9
10use crate::completion::{CompletionObserver, CompletionObserverError};
11
12use super::{
13    RetainedTransactionInitializationOutcome, TransactionInitializationObserverError,
14    TransactionInitializationOutcome, TransactionLifecycleControlPort,
15};
16
17/// Single runtime-neutral observer for one accepted initialization.
18#[must_use = "dropping abandons observation without cancelling accepted initialization"]
19pub struct TransactionInitializationObserver {
20    inner: CompletionObserver<RetainedTransactionInitializationOutcome>,
21    lifetime: Option<Arc<dyn Send + Sync>>,
22    control: Option<TransactionLifecycleControlPort>,
23}
24
25impl TransactionInitializationObserver {
26    pub(super) const fn new(
27        inner: CompletionObserver<RetainedTransactionInitializationOutcome>,
28        lifetime: Arc<dyn Send + Sync>,
29        control: TransactionLifecycleControlPort,
30    ) -> Self {
31        Self {
32            inner,
33            lifetime: Some(lifetime),
34            control: Some(control),
35        }
36    }
37
38    /// Blocks on the same terminal cell used by [`Future::poll`].
39    pub fn wait(
40        mut self,
41    ) -> Result<TransactionInitializationOutcome, TransactionInitializationObserverError> {
42        let terminal = self.inner.wait().map_err(observer_error)?;
43        let lifetime = self
44            .lifetime
45            .take()
46            .ok_or(TransactionInitializationObserverError::AlreadyObserved)?;
47        let control = self
48            .control
49            .take()
50            .ok_or(TransactionInitializationObserverError::AlreadyObserved)?;
51        Ok(terminal.into_observed(lifetime, control))
52    }
53}
54
55impl Future for TransactionInitializationObserver {
56    type Output = Result<TransactionInitializationOutcome, TransactionInitializationObserverError>;
57
58    fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output> {
59        let this = self.get_mut();
60        match Pin::new(&mut this.inner).poll(context) {
61            Poll::Ready(Ok(terminal)) => {
62                let Some(lifetime) = this.lifetime.take() else {
63                    return Poll::Ready(Err(
64                        TransactionInitializationObserverError::AlreadyObserved,
65                    ));
66                };
67                let Some(control) = this.control.take() else {
68                    return Poll::Ready(Err(
69                        TransactionInitializationObserverError::AlreadyObserved,
70                    ));
71                };
72                Poll::Ready(Ok(terminal.into_observed(lifetime, control)))
73            }
74            Poll::Ready(Err(error)) => {
75                drop(this.lifetime.take());
76                drop(this.control.take());
77                Poll::Ready(Err(observer_error(error)))
78            }
79            Poll::Pending => Poll::Pending,
80        }
81    }
82}
83
84impl std::fmt::Debug for TransactionInitializationObserver {
85    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
86        formatter
87            .debug_struct("TransactionInitializationObserver")
88            .finish_non_exhaustive()
89    }
90}
91
92const fn observer_error(error: CompletionObserverError) -> TransactionInitializationObserverError {
93    match error {
94        CompletionObserverError::AlreadyObserved => {
95            TransactionInitializationObserverError::AlreadyObserved
96        }
97        CompletionObserverError::Stale => TransactionInitializationObserverError::Stale,
98    }
99}