use core::fmt;
use kafka_client_core::{
ClusterBroker as CoreBroker, DeliveryStatus as CoreDeliveryStatus,
DescribeClusterFailureKind as CoreFailureKind, DescribeClusterTerminal,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeClusterDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ClusterBroker {
id: i32,
host: String,
port: u16,
rack: Option<String>,
fenced: bool,
}
impl ClusterBroker {
pub const fn id(&self) -> i32 {
self.id
}
pub fn host(&self) -> &str {
&self.host
}
pub const fn port(&self) -> u16 {
self.port
}
pub fn rack(&self) -> Option<&str> {
self.rack.as_deref()
}
pub const fn is_fenced(&self) -> bool {
self.fenced
}
pub fn into_parts(self) -> (i32, String, u16, Option<String>, bool) {
(self.id, self.host, self.port, self.rack, self.fenced)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ClusterDescription {
cluster_id: String,
controller_id: Option<i32>,
brokers: Vec<ClusterBroker>,
authorized_operations: Option<i32>,
}
impl ClusterDescription {
pub fn cluster_id(&self) -> &str {
&self.cluster_id
}
pub const fn controller_id(&self) -> Option<i32> {
self.controller_id
}
pub fn brokers(&self) -> &[ClusterBroker] {
&self.brokers
}
pub const fn authorized_operations(&self) -> Option<i32> {
self.authorized_operations
}
pub fn into_parts(self) -> (String, Option<i32>, Vec<ClusterBroker>) {
(self.cluster_id, self.controller_id, self.brokers)
}
pub fn into_parts_with_authorized_operations(
self,
) -> (String, Option<i32>, Vec<ClusterBroker>, Option<i32>) {
(
self.cluster_id,
self.controller_id,
self.brokers,
self.authorized_operations,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DescribeClusterBrokerError {
code: i16,
message: Option<String>,
message_truncated: bool,
}
impl DescribeClusterBrokerError {
pub fn into_parts(self) -> (i16, Option<String>, bool) {
(self.code, self.message, self.message_truncated)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeClusterFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
Authentication,
Compatibility,
InvalidResponse,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DescribeClusterFailure {
kind: DescribeClusterFailureKind,
delivery: DescribeClusterDeliveryStatus,
}
impl DescribeClusterFailure {
pub const fn kind(self) -> DescribeClusterFailureKind {
self.kind
}
pub const fn delivery(self) -> DescribeClusterDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DescribeClusterOutcome {
Cluster(ClusterDescription),
BrokerRejected(DescribeClusterBrokerError),
Failed(DescribeClusterFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DescribeClusterObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for DescribeClusterObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "DescribeCluster result was already observed",
Self::Stale => "DescribeCluster observer is stale",
})
}
}
impl std::error::Error for DescribeClusterObserverError {}
pub(crate) fn translate_terminal(terminal: DescribeClusterTerminal) -> DescribeClusterOutcome {
match terminal {
DescribeClusterTerminal::Cluster(description) => {
let (cluster_id, controller_id, brokers, authorized_operations) =
description.into_parts_with_authorized_operations();
DescribeClusterOutcome::Cluster(ClusterDescription {
cluster_id,
controller_id,
brokers: brokers.into_iter().map(translate_broker).collect(),
authorized_operations,
})
}
DescribeClusterTerminal::BrokerRejected(error) => {
let (code, message, message_truncated) = error.into_parts();
DescribeClusterOutcome::BrokerRejected(DescribeClusterBrokerError {
code,
message,
message_truncated,
})
}
DescribeClusterTerminal::Failed(failure) => {
DescribeClusterOutcome::Failed(DescribeClusterFailure {
kind: match failure.kind() {
CoreFailureKind::DeadlineElapsed => DescribeClusterFailureKind::DeadlineElapsed,
CoreFailureKind::DriverRejected => DescribeClusterFailureKind::DriverRejected,
CoreFailureKind::Transport => DescribeClusterFailureKind::Transport,
CoreFailureKind::Authentication => DescribeClusterFailureKind::Authentication,
CoreFailureKind::Compatibility => DescribeClusterFailureKind::Compatibility,
CoreFailureKind::InvalidResponse => DescribeClusterFailureKind::InvalidResponse,
},
delivery: translate_delivery(failure.delivery()),
})
}
}
}
fn translate_broker(broker: CoreBroker) -> ClusterBroker {
let (id, host, port, rack, fenced) = broker.into_parts();
ClusterBroker {
id,
host,
port,
rack,
fenced,
}
}
const fn translate_delivery(delivery: CoreDeliveryStatus) -> DescribeClusterDeliveryStatus {
match delivery {
CoreDeliveryStatus::NotSent => DescribeClusterDeliveryStatus::NotSent,
CoreDeliveryStatus::PossiblySent => DescribeClusterDeliveryStatus::PossiblySent,
}
}