use core::fmt;
use kafka_client_core::{
CreatePartitionsFailureKind as CoreFailureKind, CreatePartitionsTerminal,
DeliveryStatus as CoreDeliveryStatus, PartitionIncreaseResult as CoreTopicResult,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CreatePartitionsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PartitionIncreaseError {
code: i16,
message: Option<String>,
message_truncated: bool,
}
impl PartitionIncreaseError {
pub const fn code(&self) -> i16 {
self.code
}
pub fn message(&self) -> Option<&str> {
self.message.as_deref()
}
pub const fn message_truncated(&self) -> bool {
self.message_truncated
}
pub fn into_parts(self) -> (i16, Option<String>, bool) {
(self.code, self.message, self.message_truncated)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PartitionIncreaseResult {
topic: String,
result: Result<(), PartitionIncreaseError>,
}
impl PartitionIncreaseResult {
pub fn topic(&self) -> &str {
&self.topic
}
pub const fn result(&self) -> &Result<(), PartitionIncreaseError> {
&self.result
}
pub fn into_parts(self) -> (String, Result<(), PartitionIncreaseError>) {
(self.topic, self.result)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CreatePartitionsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
InvalidResponse,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct CreatePartitionsFailure {
kind: CreatePartitionsFailureKind,
delivery: CreatePartitionsDeliveryStatus,
}
impl CreatePartitionsFailure {
pub const fn kind(self) -> CreatePartitionsFailureKind {
self.kind
}
pub const fn delivery(self) -> CreatePartitionsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum CreatePartitionsOutcome {
Topics(Vec<PartitionIncreaseResult>),
Failed(CreatePartitionsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CreatePartitionsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for CreatePartitionsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "CreatePartitions result was already observed",
Self::Stale => "CreatePartitions observer is stale",
})
}
}
impl std::error::Error for CreatePartitionsObserverError {}
pub(crate) fn translate_terminal(terminal: CreatePartitionsTerminal) -> CreatePartitionsOutcome {
match terminal {
CreatePartitionsTerminal::Topics(outcomes) => CreatePartitionsOutcome::Topics(
outcomes
.into_iter()
.map(|outcome| {
let (topic, result) = outcome.into_parts();
let result = match result {
CoreTopicResult::Increased => Ok(()),
CoreTopicResult::Failed(error) => {
let (code, message, message_truncated) = error.into_parts();
Err(PartitionIncreaseError {
code,
message,
message_truncated,
})
}
};
PartitionIncreaseResult { topic, result }
})
.collect(),
),
CreatePartitionsTerminal::Failed(failure) => {
let kind = match failure.kind() {
CoreFailureKind::DeadlineElapsed => CreatePartitionsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => CreatePartitionsFailureKind::DriverRejected,
CoreFailureKind::Transport => CreatePartitionsFailureKind::Transport,
CoreFailureKind::InvalidResponse => CreatePartitionsFailureKind::InvalidResponse,
};
CreatePartitionsOutcome::Failed(CreatePartitionsFailure {
kind,
delivery: match failure.delivery() {
CoreDeliveryStatus::NotSent => CreatePartitionsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => {
CreatePartitionsDeliveryStatus::PossiblySent
}
},
})
}
}
}