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