use core::fmt;
use kafka_client_core::{
DeliveryStatus as CoreDeliveryStatus, LegacyAlterConfigResult as CoreConfigResult,
LegacyAlterConfigsFailureKind as CoreFailureKind, LegacyAlterConfigsTerminal as CoreTerminal,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LegacyAlterConfigsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct LegacyAlterConfigError {
code: i16,
message: Option<String>,
message_truncated: bool,
}
impl LegacyAlterConfigError {
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 LegacyAlterConfigResult {
resource_type: i8,
resource_name: String,
result: Result<(), LegacyAlterConfigError>,
}
impl LegacyAlterConfigResult {
pub const fn resource_type(&self) -> i8 {
self.resource_type
}
pub fn resource_name(&self) -> &str {
&self.resource_name
}
pub fn topic(&self) -> &str {
&self.resource_name
}
pub const fn result(&self) -> &Result<(), LegacyAlterConfigError> {
&self.result
}
pub fn into_parts(self) -> (String, Result<(), LegacyAlterConfigError>) {
(self.resource_name, self.result)
}
pub fn into_resource_parts(self) -> (i8, String, Result<(), LegacyAlterConfigError>) {
(self.resource_type, self.resource_name, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct LegacyAlterConfigsResult {
throttle_time_ms: u32,
resources: Vec<LegacyAlterConfigResult>,
}
impl LegacyAlterConfigsResult {
pub const fn throttle_time_ms(&self) -> u32 {
self.throttle_time_ms
}
pub fn resources(&self) -> &[LegacyAlterConfigResult] {
&self.resources
}
pub fn topics(&self) -> &[LegacyAlterConfigResult] {
&self.resources
}
pub fn into_parts(self) -> (u32, Vec<LegacyAlterConfigResult>) {
(self.throttle_time_ms, self.resources)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LegacyAlterConfigsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
InvalidResponse,
ResponseTooLarge,
Compatibility,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct LegacyAlterConfigsFailure {
kind: LegacyAlterConfigsFailureKind,
delivery: LegacyAlterConfigsDeliveryStatus,
}
impl LegacyAlterConfigsFailure {
pub const fn kind(self) -> LegacyAlterConfigsFailureKind {
self.kind
}
pub const fn delivery(self) -> LegacyAlterConfigsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum LegacyAlterConfigsOutcome {
Configs(LegacyAlterConfigsResult),
Failed(LegacyAlterConfigsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LegacyAlterConfigsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for LegacyAlterConfigsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "LegacyAlterConfigs result was already observed",
Self::Stale => "LegacyAlterConfigs observer is stale",
})
}
}
impl std::error::Error for LegacyAlterConfigsObserverError {}
pub(crate) fn translate_terminal(terminal: CoreTerminal) -> LegacyAlterConfigsOutcome {
match terminal {
CoreTerminal::Configs(batch) => {
let (throttle_time_ms, resources) = batch.into_parts();
LegacyAlterConfigsOutcome::Configs(LegacyAlterConfigsResult {
throttle_time_ms,
resources: resources
.into_iter()
.map(|outcome| {
let (resource_type, resource_name, result) = outcome.into_resource_parts();
let result = match result {
CoreConfigResult::Altered => Ok(()),
CoreConfigResult::Failed(error) => {
let (code, message, message_truncated) = error.into_parts();
Err(LegacyAlterConfigError {
code,
message,
message_truncated,
})
}
};
LegacyAlterConfigResult {
resource_type,
resource_name,
result,
}
})
.collect(),
})
}
CoreTerminal::Failed(failure) => {
let kind = match failure.kind() {
CoreFailureKind::DeadlineElapsed => LegacyAlterConfigsFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => LegacyAlterConfigsFailureKind::DriverRejected,
CoreFailureKind::Transport => LegacyAlterConfigsFailureKind::Transport,
CoreFailureKind::InvalidResponse => LegacyAlterConfigsFailureKind::InvalidResponse,
CoreFailureKind::ResponseTooLarge => {
LegacyAlterConfigsFailureKind::ResponseTooLarge
}
CoreFailureKind::Compatibility => LegacyAlterConfigsFailureKind::Compatibility,
};
LegacyAlterConfigsOutcome::Failed(LegacyAlterConfigsFailure {
kind,
delivery: match failure.delivery() {
CoreDeliveryStatus::NotSent => LegacyAlterConfigsDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => {
LegacyAlterConfigsDeliveryStatus::PossiblySent
}
},
})
}
}
}