kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Runtime-neutral observation of one transaction-initialization terminal.

use std::{
    future::Future,
    pin::Pin,
    sync::Arc,
    task::{Context, Poll},
};

use crate::completion::{CompletionObserver, CompletionObserverError};

use super::{
    RetainedTransactionInitializationOutcome, TransactionInitializationObserverError,
    TransactionInitializationOutcome, TransactionLifecycleControlPort,
};

/// Single runtime-neutral observer for one accepted initialization.
#[must_use = "dropping abandons observation without cancelling accepted initialization"]
pub struct TransactionInitializationObserver {
    inner: CompletionObserver<RetainedTransactionInitializationOutcome>,
    lifetime: Option<Arc<dyn Send + Sync>>,
    control: Option<TransactionLifecycleControlPort>,
}

impl TransactionInitializationObserver {
    pub(super) const fn new(
        inner: CompletionObserver<RetainedTransactionInitializationOutcome>,
        lifetime: Arc<dyn Send + Sync>,
        control: TransactionLifecycleControlPort,
    ) -> Self {
        Self {
            inner,
            lifetime: Some(lifetime),
            control: Some(control),
        }
    }

    /// Blocks on the same terminal cell used by [`Future::poll`].
    pub fn wait(
        mut self,
    ) -> Result<TransactionInitializationOutcome, TransactionInitializationObserverError> {
        let terminal = self.inner.wait().map_err(observer_error)?;
        let lifetime = self
            .lifetime
            .take()
            .ok_or(TransactionInitializationObserverError::AlreadyObserved)?;
        let control = self
            .control
            .take()
            .ok_or(TransactionInitializationObserverError::AlreadyObserved)?;
        Ok(terminal.into_observed(lifetime, control))
    }
}

impl Future for TransactionInitializationObserver {
    type Output = Result<TransactionInitializationOutcome, TransactionInitializationObserverError>;

    fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.get_mut();
        match Pin::new(&mut this.inner).poll(context) {
            Poll::Ready(Ok(terminal)) => {
                let Some(lifetime) = this.lifetime.take() else {
                    return Poll::Ready(Err(
                        TransactionInitializationObserverError::AlreadyObserved,
                    ));
                };
                let Some(control) = this.control.take() else {
                    return Poll::Ready(Err(
                        TransactionInitializationObserverError::AlreadyObserved,
                    ));
                };
                Poll::Ready(Ok(terminal.into_observed(lifetime, control)))
            }
            Poll::Ready(Err(error)) => {
                drop(this.lifetime.take());
                drop(this.control.take());
                Poll::Ready(Err(observer_error(error)))
            }
            Poll::Pending => Poll::Pending,
        }
    }
}

impl std::fmt::Debug for TransactionInitializationObserver {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("TransactionInitializationObserver")
            .finish_non_exhaustive()
    }
}

const fn observer_error(error: CompletionObserverError) -> TransactionInitializationObserverError {
    match error {
        CompletionObserverError::AlreadyObserved => {
            TransactionInitializationObserverError::AlreadyObserved
        }
        CompletionObserverError::Stale => TransactionInitializationObserverError::Stale,
    }
}