use core::fmt;
use kafka_client_core::{
AlterPartitionReassignmentResult as CoreResult,
AlterPartitionReassignmentsFailureKind as CoreFailureKind,
AlterPartitionReassignmentsTerminal as CoreTerminal, DeliveryStatus as CoreDeliveryStatus,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AlterPartitionReassignmentsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AlterPartitionReassignmentBrokerError {
code: i16,
message: Option<String>,
message_truncated: bool,
}
impl AlterPartitionReassignmentBrokerError {
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 AlterPartitionReassignmentResult {
topic: String,
partition: i32,
result: Result<(), AlterPartitionReassignmentBrokerError>,
}
impl AlterPartitionReassignmentResult {
pub fn into_parts(
self,
) -> (
String,
i32,
Result<(), AlterPartitionReassignmentBrokerError>,
) {
(self.topic, self.partition, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AlterPartitionReassignmentsBatch {
throttle_time_ms: u32,
partitions: Vec<AlterPartitionReassignmentResult>,
}
impl AlterPartitionReassignmentsBatch {
pub fn into_parts(self) -> (u32, Vec<AlterPartitionReassignmentResult>) {
(self.throttle_time_ms, self.partitions)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum AlterPartitionReassignmentsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
Broker(AlterPartitionReassignmentBrokerError),
ResponseTooLarge,
Compatibility,
InvalidResponse,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AlterPartitionReassignmentsFailure {
kind: AlterPartitionReassignmentsFailureKind,
delivery: AlterPartitionReassignmentsDeliveryStatus,
}
impl AlterPartitionReassignmentsFailure {
pub const fn kind(&self) -> &AlterPartitionReassignmentsFailureKind {
&self.kind
}
pub const fn delivery(&self) -> AlterPartitionReassignmentsDeliveryStatus {
self.delivery
}
pub fn into_parts(
self,
) -> (
AlterPartitionReassignmentsFailureKind,
AlterPartitionReassignmentsDeliveryStatus,
) {
(self.kind, self.delivery)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum AlterPartitionReassignmentsOutcome {
Altered(AlterPartitionReassignmentsBatch),
Failed(AlterPartitionReassignmentsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AlterPartitionReassignmentsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for AlterPartitionReassignmentsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "AlterPartitionReassignments result was already observed",
Self::Stale => "AlterPartitionReassignments observer is stale",
})
}
}
impl std::error::Error for AlterPartitionReassignmentsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> AlterPartitionReassignmentsOutcome {
match terminal {
CoreTerminal::Altered(batch) => {
let (throttle_time_ms, outcomes) = batch.into_parts();
AlterPartitionReassignmentsOutcome::Altered(AlterPartitionReassignmentsBatch {
throttle_time_ms,
partitions: outcomes
.into_iter()
.map(|outcome| {
let (topic, partition, result) = outcome.into_parts();
let result = match result {
CoreResult::Altered => Ok(()),
CoreResult::Failed(error) => Err(broker_error(error)),
};
AlterPartitionReassignmentResult {
topic,
partition,
result,
}
})
.collect(),
})
}
CoreTerminal::Failed(failure) => {
let (kind, delivery) = failure.into_parts();
AlterPartitionReassignmentsOutcome::Failed(AlterPartitionReassignmentsFailure {
kind: failure_kind(kind),
delivery: delivery_status(delivery),
})
}
}
}
fn broker_error(
error: kafka_client_core::AlterPartitionReassignmentBrokerError,
) -> AlterPartitionReassignmentBrokerError {
let (code, message, message_truncated) = error.into_parts();
AlterPartitionReassignmentBrokerError {
code,
message,
message_truncated,
}
}
fn failure_kind(kind: CoreFailureKind) -> AlterPartitionReassignmentsFailureKind {
match kind {
CoreFailureKind::DeadlineElapsed => AlterPartitionReassignmentsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => AlterPartitionReassignmentsFailureKind::DriverRejected,
CoreFailureKind::Transport => AlterPartitionReassignmentsFailureKind::Transport,
CoreFailureKind::Broker(error) => {
AlterPartitionReassignmentsFailureKind::Broker(broker_error(error))
}
CoreFailureKind::ResponseTooLarge => {
AlterPartitionReassignmentsFailureKind::ResponseTooLarge
}
CoreFailureKind::Compatibility => AlterPartitionReassignmentsFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => AlterPartitionReassignmentsFailureKind::InvalidResponse,
}
}
const fn delivery_status(
delivery: CoreDeliveryStatus,
) -> AlterPartitionReassignmentsDeliveryStatus {
match delivery {
CoreDeliveryStatus::NotSent => AlterPartitionReassignmentsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => AlterPartitionReassignmentsDeliveryStatus::PossiblySent,
}
}