use core::fmt;
use kafka_client_core::{
AlterUserScramCredentialChange as CoreChange, AlterUserScramCredentialsPlan as CorePlan,
AlterUserScramCredentialsPlanError as CorePlanError,
};
use zeroize::Zeroize;
pub(crate) enum AlterUserScramCredentialsPlanFailure {
Invalid,
RetainedBytes,
}
pub enum AlterUserScramCredential {
Delete {
user: String,
mechanism: i8,
},
Upsert {
user: String,
mechanism: i8,
iterations: u32,
password: Vec<u8>,
salt: Option<Vec<u8>>,
},
}
impl AlterUserScramCredential {
pub fn delete(user: String, mechanism: i8) -> Self {
Self::Delete { user, mechanism }
}
pub fn upsert(user: String, mechanism: i8, iterations: u32, password: Vec<u8>) -> Self {
Self::Upsert {
user,
mechanism,
iterations,
password,
salt: None,
}
}
pub fn upsert_with_salt(
user: String,
mechanism: i8,
iterations: u32,
password: Vec<u8>,
salt: Vec<u8>,
) -> Self {
Self::Upsert {
user,
mechanism,
iterations,
password,
salt: Some(salt),
}
}
pub fn user(&self) -> &str {
match self {
Self::Delete { user, .. } | Self::Upsert { user, .. } => user,
}
}
pub const fn mechanism(&self) -> i8 {
match self {
Self::Delete { mechanism, .. } | Self::Upsert { mechanism, .. } => *mechanism,
}
}
pub const fn iterations(&self) -> Option<u32> {
match self {
Self::Delete { .. } => None,
Self::Upsert { iterations, .. } => Some(*iterations),
}
}
pub fn password_len(&self) -> Option<usize> {
match self {
Self::Delete { .. } => None,
Self::Upsert { password, .. } => Some(password.len()),
}
}
pub fn salt_len(&self) -> Option<usize> {
match self {
Self::Delete { .. } => None,
Self::Upsert { salt, .. } => salt.as_ref().map(Vec::len),
}
}
pub(crate) fn to_core_change(&self) -> CoreChange {
match self {
Self::Delete { user, mechanism } => {
CoreChange::deletion(canonical_string(user), *mechanism)
}
Self::Upsert {
user,
mechanism,
iterations,
..
} => CoreChange::upsertion(canonical_string(user), *mechanism, *iterations),
}
}
fn zeroize_secrets(&mut self) {
if let Self::Upsert { password, salt, .. } = self {
password.zeroize();
if let Some(salt) = salt {
salt.zeroize();
}
}
}
#[cfg(test)]
pub(super) fn zeroize_secrets_for_test(&mut self) {
self.zeroize_secrets();
}
}
impl Drop for AlterUserScramCredential {
fn drop(&mut self) {
self.zeroize_secrets();
}
}
impl fmt::Debug for AlterUserScramCredential {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Delete { user, mechanism } => formatter
.debug_struct("Delete")
.field("user", user)
.field("mechanism", mechanism)
.finish(),
Self::Upsert {
user,
mechanism,
iterations,
password,
salt,
} => formatter
.debug_struct("Upsert")
.field("user", user)
.field("mechanism", mechanism)
.field("iterations", iterations)
.field("password_len", &password.len())
.field("salt_len", &salt.as_ref().map(Vec::len))
.finish(),
}
}
}
pub struct AlterUserScramCredentialsRequest {
alterations: Vec<AlterUserScramCredential>,
}
impl AlterUserScramCredentialsRequest {
pub const fn new(alterations: Vec<AlterUserScramCredential>) -> Self {
Self { alterations }
}
pub fn alterations(&self) -> &[AlterUserScramCredential] {
&self.alterations
}
pub(crate) fn plan(&self) -> Result<CorePlan, AlterUserScramCredentialsPlanFailure> {
let mut changes = Vec::new();
changes
.try_reserve_exact(self.alterations.len())
.map_err(|_| AlterUserScramCredentialsPlanFailure::RetainedBytes)?;
changes.extend(
self.alterations
.iter()
.map(AlterUserScramCredential::to_core_change),
);
CorePlan::new(changes)
.map_err(|_error: CorePlanError| AlterUserScramCredentialsPlanFailure::Invalid)
}
}
impl fmt::Debug for AlterUserScramCredentialsRequest {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("AlterUserScramCredentialsRequest")
.field("alterations", &self.alterations)
.finish()
}
}
fn canonical_string(source: &str) -> String {
source.to_owned().into_boxed_str().into_string()
}