use core::fmt;
use kafka_client_core::TransactionInitializationMachineError;
use crate::completion::CompletionRegistryError;
use super::TransactionInitializationRequest;
use crate::transaction::TransactionLifecycleHostError;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionInitializationCaptureError {
InvalidOperationDeadline,
}
impl fmt::Display for TransactionInitializationCaptureError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("transaction initialization deadline is invalid")
}
}
impl std::error::Error for TransactionInitializationCaptureError {}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TransactionInitializationAdmissionErrorKind {
InvalidRequest,
Contended,
Closed,
Capacity,
RetainedBytes,
IdentityExhausted,
HostUnavailable,
}
#[must_use = "local rejection retains the exact caller input"]
pub struct TransactionInitializationAdmissionError {
kind: TransactionInitializationAdmissionErrorKind,
request: TransactionInitializationRequest,
}
impl TransactionInitializationAdmissionError {
pub(super) const fn new(
kind: TransactionInitializationAdmissionErrorKind,
request: TransactionInitializationRequest,
) -> Self {
Self { kind, request }
}
pub const fn kind(&self) -> TransactionInitializationAdmissionErrorKind {
self.kind
}
pub fn into_request(self) -> TransactionInitializationRequest {
self.request
}
}
impl fmt::Debug for TransactionInitializationAdmissionError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("TransactionInitializationAdmissionError")
.field("kind", &self.kind)
.field("request", &self.request)
.finish()
}
}
impl fmt::Display for TransactionInitializationAdmissionError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
let kind = self.kind;
write!(
formatter,
"transaction initialization admission failed: {kind:?}"
)
}
}
impl std::error::Error for TransactionInitializationAdmissionError {}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum TransactionInitializationHostError {
Machine(TransactionInitializationMachineError),
Completion(CompletionRegistryError),
UnknownOperation,
UnexpectedEffect,
MissingTerminal,
CallCompletion,
ByteAccounting,
OwnerRelease,
Lifecycle(TransactionLifecycleHostError),
Wake,
Unsettled(usize),
}
impl From<TransactionInitializationMachineError> for TransactionInitializationHostError {
fn from(error: TransactionInitializationMachineError) -> Self {
Self::Machine(error)
}
}
impl From<CompletionRegistryError> for TransactionInitializationHostError {
fn from(error: CompletionRegistryError) -> Self {
Self::Completion(error)
}
}
impl From<TransactionLifecycleHostError> for TransactionInitializationHostError {
fn from(error: TransactionLifecycleHostError) -> Self {
Self::Lifecycle(error)
}
}
impl fmt::Display for TransactionInitializationHostError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
formatter,
"transaction initialization host failed: {self:?}"
)
}
}
impl std::error::Error for TransactionInitializationHostError {}