use core::fmt;
use kafka_client_core::{
AlterReplicaLogDirResult as CoreResult, AlterReplicaLogDirsFailure as CoreFailure,
AlterReplicaLogDirsFailureKind as CoreFailureKind, AlterReplicaLogDirsTerminal as CoreTerminal,
DeliveryStatus as CoreDeliveryStatus,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AlterReplicaLogDirsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AlterReplicaLogDirEngineBrokerError {
code: i16,
}
impl AlterReplicaLogDirEngineBrokerError {
pub const fn code(self) -> i16 {
self.code
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AlterReplicaLogDirsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
ResponseTooLarge,
Compatibility,
InvalidResponse,
NotAttempted,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AlterReplicaLogDirsFailure {
kind: AlterReplicaLogDirsFailureKind,
delivery: AlterReplicaLogDirsDeliveryStatus,
}
impl AlterReplicaLogDirsFailure {
pub const fn kind(self) -> AlterReplicaLogDirsFailureKind {
self.kind
}
pub const fn delivery(self) -> AlterReplicaLogDirsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AlterReplicaLogDirEngineResult {
Altered,
BrokerFailed(AlterReplicaLogDirEngineBrokerError),
OperationFailed(AlterReplicaLogDirsFailure),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AlterReplicaLogDirEngineOutcome {
broker_id: i32,
topic: String,
partition: i32,
result: AlterReplicaLogDirEngineResult,
}
impl AlterReplicaLogDirEngineOutcome {
pub fn into_parts(self) -> (i32, String, i32, AlterReplicaLogDirEngineResult) {
(self.broker_id, self.topic, self.partition, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AlterReplicaLogDirsEngineBatch {
throttle_time_ms: u32,
outcomes: Vec<AlterReplicaLogDirEngineOutcome>,
}
impl AlterReplicaLogDirsEngineBatch {
pub fn into_parts(self) -> (u32, Vec<AlterReplicaLogDirEngineOutcome>) {
(self.throttle_time_ms, self.outcomes)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum AlterReplicaLogDirsOutcome {
Altered(AlterReplicaLogDirsEngineBatch),
Failed(AlterReplicaLogDirsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AlterReplicaLogDirsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for AlterReplicaLogDirsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "Admin AlterReplicaLogDirs result was already observed",
Self::Stale => "Admin AlterReplicaLogDirs observer is stale",
})
}
}
impl std::error::Error for AlterReplicaLogDirsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> AlterReplicaLogDirsOutcome {
match terminal {
CoreTerminal::Altered(batch) => {
let (throttle_time_ms, outcomes) = batch.into_parts();
AlterReplicaLogDirsOutcome::Altered(AlterReplicaLogDirsEngineBatch {
throttle_time_ms,
outcomes: outcomes
.into_iter()
.map(|outcome| {
let (broker_id, topic, partition, result) = outcome.into_parts();
AlterReplicaLogDirEngineOutcome {
broker_id,
topic,
partition,
result: match result {
CoreResult::Altered => AlterReplicaLogDirEngineResult::Altered,
CoreResult::BrokerFailed(error) => {
AlterReplicaLogDirEngineResult::BrokerFailed(
AlterReplicaLogDirEngineBrokerError { code: error.code() },
)
}
CoreResult::OperationFailed(failure) => {
AlterReplicaLogDirEngineResult::OperationFailed(engine_failure(
failure,
))
}
},
}
})
.collect(),
})
}
CoreTerminal::Failed(failure) => {
AlterReplicaLogDirsOutcome::Failed(engine_failure(failure))
}
}
}
fn engine_failure(failure: CoreFailure) -> AlterReplicaLogDirsFailure {
AlterReplicaLogDirsFailure {
kind: failure_kind(failure.kind()),
delivery: delivery_status(failure.delivery()),
}
}
const fn failure_kind(kind: CoreFailureKind) -> AlterReplicaLogDirsFailureKind {
match kind {
CoreFailureKind::DeadlineElapsed => AlterReplicaLogDirsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => AlterReplicaLogDirsFailureKind::DriverRejected,
CoreFailureKind::Transport => AlterReplicaLogDirsFailureKind::Transport,
CoreFailureKind::ResponseTooLarge => AlterReplicaLogDirsFailureKind::ResponseTooLarge,
CoreFailureKind::Compatibility => AlterReplicaLogDirsFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => AlterReplicaLogDirsFailureKind::InvalidResponse,
CoreFailureKind::NotAttempted => AlterReplicaLogDirsFailureKind::NotAttempted,
}
}
const fn delivery_status(delivery: CoreDeliveryStatus) -> AlterReplicaLogDirsDeliveryStatus {
match delivery {
CoreDeliveryStatus::NotSent => AlterReplicaLogDirsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => AlterReplicaLogDirsDeliveryStatus::PossiblySent,
}
}