kafka_client_engine/transaction/initialization/
observer.rs1use 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#[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 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}