use core::fmt;
use kafka_client_core::{
DeliveryStatus as CoreDeliveryStatus, DescribeReplicaLogDirsFailure as CoreFailure,
DescribeReplicaLogDirsFailureKind as CoreFailureKind,
DescribeReplicaLogDirsReplicaResult as CoreReplicaResult,
DescribeReplicaLogDirsTerminal as CoreTerminal, ReplicaLogDirInfo as CoreInfo,
ReplicaLogDirLocation as CoreLocation,
};
use super::DescribeReplicaLogDirsTarget;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeReplicaLogDirsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DescribeReplicaLogDirsBrokerError {
code: i16,
}
impl DescribeReplicaLogDirsBrokerError {
pub const fn code(self) -> i16 {
self.code
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ReplicaLogDirLocation {
path: String,
offset_lag: i64,
}
impl ReplicaLogDirLocation {
pub fn into_parts(self) -> (String, i64) {
(self.path, self.offset_lag)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ReplicaLogDirInfo {
current: Option<ReplicaLogDirLocation>,
future: Option<ReplicaLogDirLocation>,
}
impl ReplicaLogDirInfo {
pub fn into_parts(self) -> (Option<ReplicaLogDirLocation>, Option<ReplicaLogDirLocation>) {
(self.current, self.future)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeReplicaLogDirsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
ResponseTooLarge,
Compatibility,
InvalidResponse,
NotAttempted,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DescribeReplicaLogDirsFailure {
kind: DescribeReplicaLogDirsFailureKind,
delivery: DescribeReplicaLogDirsDeliveryStatus,
}
impl DescribeReplicaLogDirsFailure {
pub const fn kind(self) -> DescribeReplicaLogDirsFailureKind {
self.kind
}
pub const fn delivery(self) -> DescribeReplicaLogDirsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DescribeReplicaLogDirsEngineReplicaResult {
Described(ReplicaLogDirInfo),
BrokerFailed(DescribeReplicaLogDirsBrokerError),
OperationFailed(DescribeReplicaLogDirsFailure),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DescribeReplicaLogDirsEngineReplicaOutcome {
target: DescribeReplicaLogDirsTarget,
result: DescribeReplicaLogDirsEngineReplicaResult,
}
impl DescribeReplicaLogDirsEngineReplicaOutcome {
pub fn into_parts(
self,
) -> (
DescribeReplicaLogDirsTarget,
DescribeReplicaLogDirsEngineReplicaResult,
) {
(self.target, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DescribeReplicaLogDirsEngineBatch {
throttle_time_ms: u32,
outcomes: Vec<DescribeReplicaLogDirsEngineReplicaOutcome>,
}
impl DescribeReplicaLogDirsEngineBatch {
pub fn into_parts(self) -> (u32, Vec<DescribeReplicaLogDirsEngineReplicaOutcome>) {
(self.throttle_time_ms, self.outcomes)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DescribeReplicaLogDirsOutcome {
Described(DescribeReplicaLogDirsEngineBatch),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeReplicaLogDirsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for DescribeReplicaLogDirsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "Admin DescribeReplicaLogDirs result was already observed",
Self::Stale => "Admin DescribeReplicaLogDirs observer is stale",
})
}
}
impl std::error::Error for DescribeReplicaLogDirsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> DescribeReplicaLogDirsOutcome {
match terminal {
CoreTerminal::Described(batch) => {
let (throttle_time_ms, outcomes) = batch.into_parts();
DescribeReplicaLogDirsOutcome::Described(DescribeReplicaLogDirsEngineBatch {
throttle_time_ms,
outcomes: outcomes
.into_iter()
.map(|outcome| {
let (replica, result) = outcome.into_parts();
let (topic, partition, broker_id) = replica.into_parts();
DescribeReplicaLogDirsEngineReplicaOutcome {
target: DescribeReplicaLogDirsTarget::new(topic, partition, broker_id),
result: translate_result(result),
}
})
.collect(),
})
}
}
}
fn translate_result(result: CoreReplicaResult) -> DescribeReplicaLogDirsEngineReplicaResult {
match result {
CoreReplicaResult::Described(info) => {
DescribeReplicaLogDirsEngineReplicaResult::Described(translate_info(info))
}
CoreReplicaResult::BrokerFailed(error) => {
DescribeReplicaLogDirsEngineReplicaResult::BrokerFailed(
DescribeReplicaLogDirsBrokerError { code: error.code() },
)
}
CoreReplicaResult::OperationFailed(failure) => {
DescribeReplicaLogDirsEngineReplicaResult::OperationFailed(translate_failure(failure))
}
}
}
fn translate_info(info: CoreInfo) -> ReplicaLogDirInfo {
let (current, future) = info.into_parts();
ReplicaLogDirInfo {
current: current.map(translate_location),
future: future.map(translate_location),
}
}
fn translate_location(location: CoreLocation) -> ReplicaLogDirLocation {
let (path, offset_lag) = location.into_parts();
ReplicaLogDirLocation { path, offset_lag }
}
const fn translate_failure(failure: CoreFailure) -> DescribeReplicaLogDirsFailure {
DescribeReplicaLogDirsFailure {
kind: match failure.kind() {
CoreFailureKind::DeadlineElapsed => DescribeReplicaLogDirsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => DescribeReplicaLogDirsFailureKind::DriverRejected,
CoreFailureKind::Transport => DescribeReplicaLogDirsFailureKind::Transport,
CoreFailureKind::ResponseTooLarge => {
DescribeReplicaLogDirsFailureKind::ResponseTooLarge
}
CoreFailureKind::Compatibility => DescribeReplicaLogDirsFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => DescribeReplicaLogDirsFailureKind::InvalidResponse,
CoreFailureKind::NotAttempted => DescribeReplicaLogDirsFailureKind::NotAttempted,
},
delivery: match failure.delivery() {
CoreDeliveryStatus::NotSent => DescribeReplicaLogDirsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => DescribeReplicaLogDirsDeliveryStatus::PossiblySent,
},
}
}