use core::fmt;
use kafka_client_core::{
AdminDescribeLogDirsBrokerResult as CoreBrokerResult,
AdminDescribeLogDirsFailure as CoreFailure, AdminDescribeLogDirsFailureKind as CoreFailureKind,
AdminDescribeLogDirsTerminal as CoreTerminal, AdminLogDirResult as CoreLogDirResult,
DeliveryStatus as CoreDeliveryStatus,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeLogDirsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DescribeLogDirEngineBrokerError {
code: i16,
}
impl DescribeLogDirEngineBrokerError {
pub const fn code(self) -> i16 {
self.code
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DescribeLogDirsReplicaInfo {
topic: String,
partition: i32,
size_bytes: i64,
offset_lag: i64,
future: bool,
}
impl DescribeLogDirsReplicaInfo {
pub fn into_parts(self) -> (String, i32, i64, i64, bool) {
(
self.topic,
self.partition,
self.size_bytes,
self.offset_lag,
self.future,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DescribeLogDirDescription {
replicas: Vec<DescribeLogDirsReplicaInfo>,
total_bytes: Option<i64>,
usable_bytes: Option<i64>,
cordoned: Option<bool>,
}
impl DescribeLogDirDescription {
pub fn into_parts(
self,
) -> (
Vec<DescribeLogDirsReplicaInfo>,
Option<i64>,
Option<i64>,
Option<bool>,
) {
(
self.replicas,
self.total_bytes,
self.usable_bytes,
self.cordoned,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DescribeLogDirEngineOutcome {
path: String,
result: Result<DescribeLogDirDescription, DescribeLogDirEngineBrokerError>,
}
impl DescribeLogDirEngineOutcome {
pub fn into_parts(
self,
) -> (
String,
Result<DescribeLogDirDescription, DescribeLogDirEngineBrokerError>,
) {
(self.path, self.result)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeLogDirsBrokerFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
ResponseTooLarge,
Compatibility,
InvalidResponse,
NotAttempted,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DescribeLogDirsBrokerFailure {
kind: DescribeLogDirsBrokerFailureKind,
delivery: DescribeLogDirsDeliveryStatus,
}
impl DescribeLogDirsBrokerFailure {
pub const fn kind(self) -> DescribeLogDirsBrokerFailureKind {
self.kind
}
pub const fn delivery(self) -> DescribeLogDirsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DescribeLogDirsEngineBrokerResult {
Described(Vec<DescribeLogDirEngineOutcome>),
BrokerFailed(DescribeLogDirEngineBrokerError),
OperationFailed(DescribeLogDirsBrokerFailure),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DescribeLogDirsEngineBrokerOutcome {
broker_id: i32,
result: DescribeLogDirsEngineBrokerResult,
}
impl DescribeLogDirsEngineBrokerOutcome {
pub fn into_parts(self) -> (i32, DescribeLogDirsEngineBrokerResult) {
(self.broker_id, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DescribeLogDirsEngineBatch {
throttle_time_ms: u32,
outcomes: Vec<DescribeLogDirsEngineBrokerOutcome>,
}
impl DescribeLogDirsEngineBatch {
pub fn into_parts(self) -> (u32, Vec<DescribeLogDirsEngineBrokerOutcome>) {
(self.throttle_time_ms, self.outcomes)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DescribeLogDirsFailure {
kind: DescribeLogDirsBrokerFailureKind,
delivery: DescribeLogDirsDeliveryStatus,
}
impl DescribeLogDirsFailure {
pub const fn kind(self) -> DescribeLogDirsBrokerFailureKind {
self.kind
}
pub const fn delivery(self) -> DescribeLogDirsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DescribeLogDirsOutcome {
Described(DescribeLogDirsEngineBatch),
Failed(DescribeLogDirsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeLogDirsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for DescribeLogDirsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "Admin DescribeLogDirs result was already observed",
Self::Stale => "Admin DescribeLogDirs observer is stale",
})
}
}
impl std::error::Error for DescribeLogDirsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> DescribeLogDirsOutcome {
match terminal {
CoreTerminal::Described(batch) => {
let (throttle_time_ms, outcomes) = batch.into_parts();
DescribeLogDirsOutcome::Described(DescribeLogDirsEngineBatch {
throttle_time_ms,
outcomes: outcomes.into_iter().map(translate_broker).collect(),
})
}
CoreTerminal::Failed(failure) => {
DescribeLogDirsOutcome::Failed(translate_operation_failure(failure))
}
}
}
fn translate_broker(
outcome: kafka_client_core::AdminDescribeLogDirsBrokerOutcome,
) -> DescribeLogDirsEngineBrokerOutcome {
let (broker_id, result) = outcome.into_parts();
let result = match result {
CoreBrokerResult::Described(log_dirs) => DescribeLogDirsEngineBrokerResult::Described(
log_dirs.into_iter().map(translate_log_dir).collect(),
),
CoreBrokerResult::BrokerFailed(error) => {
DescribeLogDirsEngineBrokerResult::BrokerFailed(DescribeLogDirEngineBrokerError {
code: error.code(),
})
}
CoreBrokerResult::OperationFailed(failure) => {
DescribeLogDirsEngineBrokerResult::OperationFailed(translate_broker_failure(failure))
}
};
DescribeLogDirsEngineBrokerOutcome { broker_id, result }
}
fn translate_log_dir(
outcome: kafka_client_core::AdminLogDirOutcome,
) -> DescribeLogDirEngineOutcome {
let (path, result) = outcome.into_parts();
let result = match result {
CoreLogDirResult::Described(description) => {
let (replicas, total_bytes, usable_bytes, cordoned) = description.into_parts();
Ok(DescribeLogDirDescription {
replicas: replicas
.into_iter()
.map(|replica| {
let (topic, partition, size_bytes, offset_lag, future) =
replica.into_parts();
DescribeLogDirsReplicaInfo {
topic,
partition,
size_bytes,
offset_lag,
future,
}
})
.collect(),
total_bytes,
usable_bytes,
cordoned,
})
}
CoreLogDirResult::BrokerFailed(error) => {
Err(DescribeLogDirEngineBrokerError { code: error.code() })
}
};
DescribeLogDirEngineOutcome { path, result }
}
const fn translate_operation_failure(failure: CoreFailure) -> DescribeLogDirsFailure {
DescribeLogDirsFailure {
kind: failure_kind(failure.kind()),
delivery: delivery(failure.delivery()),
}
}
const fn translate_broker_failure(failure: CoreFailure) -> DescribeLogDirsBrokerFailure {
DescribeLogDirsBrokerFailure {
kind: failure_kind(failure.kind()),
delivery: delivery(failure.delivery()),
}
}
const fn failure_kind(kind: CoreFailureKind) -> DescribeLogDirsBrokerFailureKind {
match kind {
CoreFailureKind::DeadlineElapsed => DescribeLogDirsBrokerFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => DescribeLogDirsBrokerFailureKind::DriverRejected,
CoreFailureKind::Transport => DescribeLogDirsBrokerFailureKind::Transport,
CoreFailureKind::ResponseTooLarge => DescribeLogDirsBrokerFailureKind::ResponseTooLarge,
CoreFailureKind::Compatibility => DescribeLogDirsBrokerFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => DescribeLogDirsBrokerFailureKind::InvalidResponse,
CoreFailureKind::NotAttempted => DescribeLogDirsBrokerFailureKind::NotAttempted,
}
}
const fn delivery(status: CoreDeliveryStatus) -> DescribeLogDirsDeliveryStatus {
match status {
CoreDeliveryStatus::NotSent => DescribeLogDirsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => DescribeLogDirsDeliveryStatus::PossiblySent,
}
}