use super::super::controller::context::Context;
use super::CLUSTER_LABEL;
use crate::controller::{INSTANCE_LABEL, MANAGED_BY_LABEL, NAME_LABEL};
use crate::kanidm::crd::{CaBundleRef, Kanidm, MailSenderSpec, MailSenderStatus};
use crate::metrics::{
KANIDM_OP_CREATE, KANIDM_OP_DELETE, KANIDM_OP_DESTROY_API_TOKEN, KANIDM_OP_GENERATE_API_TOKEN,
KANIDM_OP_GET, KANIDM_OP_LIST_API_TOKENS, KANIDM_OP_REMOVE_MEMBERS, KANIDM_OP_SET_MEMBERS,
KANIDM_OP_UPDATE, KANIDM_OUTCOME_CHANGED, KANIDM_OUTCOME_ERROR, KANIDM_OUTCOME_UNCHANGED,
KANIDM_RESOURCE_MAIL_SENDER, record_kanidm_sdk_call,
};
use kaniop_backup_core::auth::{
build_ca_bundle_volume, build_ca_bundle_volume_mount, ca_bundle_path,
};
use kaniop_k8s_util::error::{Error, Result};
use kaniop_k8s_util::types::normalize_spn;
use std::collections::BTreeMap;
use std::sync::Arc;
use k8s_openapi::api::apps::v1::{Deployment, DeploymentSpec, DeploymentStrategy};
use k8s_openapi::api::core::v1::{
ConfigMap, Container, KeyToPath, PodSecurityContext, PodSpec, PodTemplateSpec, Secret,
SecretVolumeSource, Volume, VolumeMount,
};
use kanidm_client::{ClientError, KanidmClient};
use kanidm_proto::internal::OperationError;
use kube::api::{Api, DeleteParams};
use kube::{Resource, ResourceExt};
use tracing::{debug, info};
const MAIL_SENDER_LABEL: &str = "mail-sender";
const MAIL_SENDER_COMPONENT: &str = "kanidm-mail-sender";
const MESSAGE_SENDERS_GROUP: &str = "idm_message_senders";
const MAIL_SENDER_SERVICE_ACCOUNT_SUFFIX: &str = "mail-sender";
const MAIL_SENDER_TOKEN_SUFFIX: &str = "mail-sender-token";
const MAIL_SENDER_CONFIG_SUFFIX: &str = "mail-sender-config";
const MAIL_SENDER_DEPLOYMENT_SUFFIX: &str = "mail-sender";
const DEFAULT_QUEUE_POLL_INTERVAL: i32 = 5;
const DEFAULT_CONNECT_TIMEOUT: i32 = 15;
const CLIENT_CONFIG_KEY: &str = "client.toml";
const MAIL_CONFIG_KEY: &str = "mail-sender.toml";
const MAIL_SENDER_CA_HASH_ANNOTATION: &str = "kaniop.rs/mail-sender-ca-hash";
const ENTRY_MANAGED_BY: &str = "idm_admin";
pub fn mail_sender_service_account_name(kanidm_name: &str) -> String {
format!("{kanidm_name}-{MAIL_SENDER_SERVICE_ACCOUNT_SUFFIX}")
}
pub fn mail_sender_token_secret_name(kanidm_name: &str) -> String {
format!("{kanidm_name}-{MAIL_SENDER_TOKEN_SUFFIX}")
}
pub fn mail_sender_config_map_name(kanidm_name: &str) -> String {
format!("{kanidm_name}-{MAIL_SENDER_CONFIG_SUFFIX}")
}
pub fn mail_sender_deployment_name(kanidm_name: &str) -> String {
format!("{kanidm_name}-{MAIL_SENDER_DEPLOYMENT_SUFFIX}")
}
pub async fn reconcile_mail_sender(
kanidm: &Kanidm,
kanidm_client: Arc<KanidmClient>,
ctx: Arc<Context>,
) -> Result<(Option<MailSenderStatus>, bool)> {
let namespace = kanidm.namespace().unwrap();
let kanidm_name = kanidm.name_any();
if let Some(mail_sender_spec) = &kanidm.spec.mail_sender {
info!(namespace, kanidm_name, "reconciling mail sender");
let sa_name = mail_sender_service_account_name(&kanidm_name);
let config_secret_name = mail_sender_config_map_name(&kanidm_name);
let deployment_name = mail_sender_deployment_name(&kanidm_name);
let mut changed = false;
let ca_hash =
mail_sender_ca_hash(&ctx, &namespace, mail_sender_spec.ca_bundle_ref.as_ref()).await?;
let sa_changed = ensure_mail_sender_service_account(
&kanidm_client,
&sa_name,
&kanidm.spec.domain,
&ctx.kaniop_ctx.metrics,
)
.await?;
changed |= sa_changed;
let group_changed =
ensure_mail_sender_in_group(&kanidm_client, &sa_name, &ctx.kaniop_ctx.metrics).await?;
changed |= group_changed;
let current_token_id = kanidm
.status
.as_ref()
.and_then(|s| s.mail_sender.as_ref())
.and_then(|ms| ms.token_id.clone());
let (token, token_id, token_changed) = ensure_mail_sender_token(
&kanidm_client,
&ctx,
&namespace,
&config_secret_name,
&sa_name,
current_token_id,
&ctx.kaniop_ctx.metrics,
)
.await?;
changed |= token_changed;
let smtp_credentials = read_smtp_credentials(&ctx, mail_sender_spec, &namespace).await?;
let config_secret = create_config_secret(
kanidm,
&config_secret_name,
mail_sender_spec,
&token,
&smtp_credentials,
)?;
kanidm.patch(&ctx, config_secret).await?;
let deployment = create_deployment(
kanidm,
&deployment_name,
mail_sender_spec,
&config_secret_name,
ca_hash.as_deref(),
)?;
kanidm.patch(&ctx, deployment).await?;
let deployment_api: Api<Deployment> =
Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
let deployment_status = deployment_api
.get(&deployment_name)
.await
.map_err(|e| Error::kube_error("get", "deployment", &namespace, &deployment_name, e))?;
let ready = deployment_status
.status
.as_ref()
.is_some_and(|s| s.ready_replicas.unwrap_or(0) >= 1);
Ok((
Some(MailSenderStatus {
service_account_name: sa_name,
token_secret_name: config_secret_name.clone(),
deployment_name,
config_map_name: config_secret_name,
token_id: Some(token_id),
ready,
}),
changed,
))
} else {
debug!(
namespace,
kanidm_name, "mail sender not enabled, cleaning up resources"
);
let cleanup_changed = cleanup_mail_sender_resources(kanidm, &ctx).await?;
Ok((None, cleanup_changed))
}
}
async fn ensure_mail_sender_service_account(
kanidm_client: &KanidmClient,
name: &str,
domain: &str,
metrics: &crate::metrics::ControllerMetrics,
) -> Result<bool> {
debug!(name, "ensuring mail sender service account exists");
let display_name = format!("Mail Sender ({domain})");
let start = tokio::time::Instant::now();
let create_result = kanidm_client
.idm_service_account_create(name, &display_name, ENTRY_MANAGED_BY)
.await;
match create_result {
Ok(_) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_CREATE,
KANIDM_OUTCOME_CHANGED,
start.elapsed(),
);
Ok(true)
}
Err(e) if is_already_exists_error(&e) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_CREATE,
KANIDM_OUTCOME_UNCHANGED,
start.elapsed(),
);
debug!(name, "service account already exists, updating");
let start = tokio::time::Instant::now();
kanidm_client
.idm_service_account_update(name, None, Some(&display_name), None, None)
.await
.map_err(|e| {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_UPDATE,
KANIDM_OUTCOME_ERROR,
start.elapsed(),
);
Error::KanidmClientError(
format!("failed to update service account {name}"),
Box::new(e),
)
})?;
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_UPDATE,
KANIDM_OUTCOME_UNCHANGED,
start.elapsed(),
);
Ok(false)
}
Err(e) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_CREATE,
KANIDM_OUTCOME_ERROR,
start.elapsed(),
);
Err(Error::KanidmClientError(
format!("failed to create service account {name}"),
Box::new(e),
))
}
}
}
fn group_contains_member(members: &[String], name: &str) -> bool {
members
.iter()
.any(|m| normalize_spn(m) == normalize_spn(name))
}
async fn ensure_mail_sender_in_group(
kanidm_client: &KanidmClient,
name: &str,
metrics: &crate::metrics::ControllerMetrics,
) -> Result<bool> {
debug!(name, "ensuring mail sender is in message_senders group");
let start = tokio::time::Instant::now();
let members_result = kanidm_client
.idm_group_get_members(MESSAGE_SENDERS_GROUP)
.await;
let current_members = match members_result {
Ok(Some(members)) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_GET,
KANIDM_OUTCOME_UNCHANGED,
start.elapsed(),
);
members
}
Ok(None) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_GET,
KANIDM_OUTCOME_UNCHANGED,
start.elapsed(),
);
vec![]
}
Err(e) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_GET,
KANIDM_OUTCOME_ERROR,
start.elapsed(),
);
return Err(Error::KanidmClientError(
format!("failed to get members of {MESSAGE_SENDERS_GROUP}"),
Box::new(e),
));
}
};
if group_contains_member(¤t_members, name) {
debug!(name, "service account already in group");
return Ok(false);
}
let start = tokio::time::Instant::now();
let add_result = kanidm_client
.idm_group_add_members(MESSAGE_SENDERS_GROUP, &[name])
.await;
match add_result {
Ok(_) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_SET_MEMBERS,
KANIDM_OUTCOME_CHANGED,
start.elapsed(),
);
Ok(true)
}
Err(e) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_SET_MEMBERS,
KANIDM_OUTCOME_ERROR,
start.elapsed(),
);
Err(Error::KanidmClientError(
format!("failed to add {name} to {MESSAGE_SENDERS_GROUP}"),
Box::new(e),
))
}
}
}
async fn ensure_mail_sender_token(
kanidm_client: &KanidmClient,
ctx: &Context,
namespace: &str,
config_secret_name: &str,
name: &str,
current_token_id: Option<String>,
metrics: &crate::metrics::ControllerMetrics,
) -> Result<(String, String, bool)> {
debug!(name, current_token_id = ?current_token_id, "ensuring mail sender API token exists");
let start = tokio::time::Instant::now();
let existing_tokens_result = kanidm_client.idm_service_account_list_api_token(name).await;
let existing_tokens = match existing_tokens_result {
Ok(tokens) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_LIST_API_TOKENS,
KANIDM_OUTCOME_UNCHANGED,
start.elapsed(),
);
tokens
}
Err(ClientError::Http(status, _, _)) if status == 404 => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_LIST_API_TOKENS,
KANIDM_OUTCOME_UNCHANGED,
start.elapsed(),
);
vec![]
}
Err(e) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_LIST_API_TOKENS,
KANIDM_OUTCOME_ERROR,
start.elapsed(),
);
return Err(Error::KanidmClientError(
format!("failed to list API tokens for {name}"),
Box::new(e),
));
}
};
let existing_mail_sender_tokens: Vec<_> = existing_tokens
.iter()
.filter(|t| t.label == MAIL_SENDER_COMPONENT)
.collect();
if let Some(token) = existing_mail_sender_tokens.first() {
if current_token_id.as_ref() == Some(&token.token_id.to_string()) {
debug!(name, token_id = %token.token_id, "mail sender token already exists with matching token_id, reading from existing secret");
if let Some(existing_token_value) =
read_token_from_config_secret(ctx, namespace, config_secret_name).await?
{
return Ok((existing_token_value, token.token_id.to_string(), false));
}
debug!(name, token_id = %token.token_id, "existing token value not found in secret, destroying all tokens and regenerating");
} else {
debug!(name, old_token_id = %token.token_id, expected_token_id = ?current_token_id, "mail sender token exists but token_id mismatch, destroying all tokens and regenerating");
}
for token in existing_mail_sender_tokens {
record_kanidm_sdk_call(
metrics,
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_DESTROY_API_TOKEN,
KANIDM_OUTCOME_CHANGED,
kanidm_client.idm_service_account_destroy_api_token(name, token.token_id),
)
.await
.map_err(|e| {
Error::KanidmClientError(
format!("failed to destroy API token {} for {name}", token.token_id),
Box::new(e),
)
})?;
}
}
debug!(name, "generating new read-write API token for mail sender");
let token_value = record_kanidm_sdk_call(
metrics,
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_GENERATE_API_TOKEN,
KANIDM_OUTCOME_CHANGED,
kanidm_client.idm_service_account_generate_api_token(
name,
MAIL_SENDER_COMPONENT,
None,
true,
false,
),
)
.await
.map_err(|e| {
Error::KanidmClientError(
format!("failed to generate API token for {name}"),
Box::new(e),
)
})?;
let new_tokens = record_kanidm_sdk_call(
metrics,
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_LIST_API_TOKENS,
KANIDM_OUTCOME_UNCHANGED,
kanidm_client.idm_service_account_list_api_token(name),
)
.await
.map_err(|e| {
Error::KanidmClientError(
format!("failed to list API tokens for {name} after generation"),
Box::new(e),
)
})?;
let new_token = new_tokens
.iter()
.find(|t| t.label == MAIL_SENDER_COMPONENT)
.ok_or_else(|| {
Error::MissingData(format!(
"generated token with label {MAIL_SENDER_COMPONENT} not found for {name}"
))
})?;
Ok((token_value, new_token.token_id.to_string(), true))
}
async fn read_token_from_config_secret(
ctx: &Context,
namespace: &str,
name: &str,
) -> Result<Option<String>> {
let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
let secret = match secret_api.get(name).await {
Ok(s) => s,
Err(kube::Error::Api(e)) if e.code == 404 => {
debug!(
name,
"mail sender config secret not found, will regenerate token"
);
return Ok(None);
}
Err(e) => {
return Err(Error::kube_error(
"get",
"mail sender config secret",
namespace,
name,
e,
));
}
};
let mail_config = secret
.string_data
.as_ref()
.and_then(|d| d.get(MAIL_CONFIG_KEY).cloned())
.or_else(|| {
secret
.data
.as_ref()
.and_then(|d| d.get(MAIL_CONFIG_KEY))
.map(|v| String::from_utf8_lossy(&v.0).to_string())
});
match mail_config {
Some(config) => {
let token = config
.lines()
.find(|line| line.starts_with("token = "))
.and_then(|line| line.strip_prefix("token = "))
.and_then(|value| value.strip_prefix('"').and_then(|v| v.strip_suffix('"')))
.map(|s| s.to_string());
Ok(token)
}
None => {
debug!(
name,
"mail sender config secret missing mail-sender.toml key, will regenerate token"
);
Ok(None)
}
}
}
fn ca_bundle_digest(bytes: &[u8]) -> String {
openssl::sha::sha256(bytes)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
fn validate_ca_bundle_ref(ca_ref: &CaBundleRef) -> Result<()> {
if ca_ref.name.trim().is_empty() || ca_ref.key.trim().is_empty() {
return Err(Error::MissingData(
"spec.mailSender.caBundleRef requires a non-empty ConfigMap name and key".to_string(),
));
}
Ok(())
}
fn ca_bundle_bytes<'a>(ca_ref: &CaBundleRef, config_map: &'a ConfigMap) -> Result<&'a [u8]> {
let bytes = config_map
.data
.as_ref()
.and_then(|data| data.get(&ca_ref.key).map(|pem| pem.as_bytes()))
.or_else(|| {
config_map
.binary_data
.as_ref()
.and_then(|data| data.get(&ca_ref.key).map(|pem| pem.0.as_slice()))
})
.filter(|pem| !pem.is_empty())
.ok_or_else(|| {
Error::MissingData(format!(
"mail sender CA ConfigMap {} has no non-empty key {}",
ca_ref.name, ca_ref.key
))
})?;
if openssl::x509::X509::stack_from_pem(bytes)
.map_or(true, |certificates| certificates.is_empty())
{
return Err(Error::MissingData(format!(
"mail sender CA ConfigMap {} key {} must contain PEM certificates",
ca_ref.name, ca_ref.key
)));
}
Ok(bytes)
}
async fn mail_sender_ca_hash(
ctx: &Context,
namespace: &str,
ca_ref: Option<&CaBundleRef>,
) -> Result<Option<String>> {
let Some(ca_ref) = ca_ref else {
return Ok(None);
};
validate_ca_bundle_ref(ca_ref)?;
let config_map_api: Api<ConfigMap> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
let cm = config_map_api.get(&ca_ref.name).await.map_err(|e| {
Error::kube_error(
"get",
"mail sender CA ConfigMap",
namespace,
&ca_ref.name,
e,
)
})?;
Ok(Some(ca_bundle_digest(ca_bundle_bytes(ca_ref, &cm)?)))
}
fn create_config_secret(
kanidm: &Kanidm,
name: &str,
spec: &MailSenderSpec,
token: &str,
smtp_credentials: &SmtpCredentials,
) -> Result<Secret> {
debug!(name, "creating config secret");
let domain = &kanidm.spec.domain;
let default_origin = format!("https://{domain}");
let origin = kanidm.spec.origin.as_ref().unwrap_or(&default_origin);
let default_display_name = format!("Kanidm {domain}");
let display_name = kanidm
.spec
.domain_appearance
.as_ref()
.and_then(|da| da.display_name.as_ref())
.unwrap_or(&default_display_name);
let poll_interval = spec
.queue_poll_interval_seconds
.unwrap_or(DEFAULT_QUEUE_POLL_INTERVAL);
let connect_timeout = spec
.connect_timeout_seconds
.unwrap_or(DEFAULT_CONNECT_TIMEOUT);
let mut client_config = format!("uri = {}", toml_basic_string(origin));
if spec.ca_bundle_ref.is_some() {
client_config.push_str(&format!(
"\nca_path = {}",
toml_basic_string(&ca_bundle_path())
));
}
let reply_to = spec
.reply_to_address
.as_deref()
.unwrap_or(&spec.from_address);
let token = toml_basic_string(token);
let display_name = toml_basic_string(display_name);
let origin = toml_basic_string(origin);
let from_address = toml_basic_string(&spec.from_address);
let reply_to = toml_basic_string(reply_to);
let relay_host = toml_basic_string(&spec.relay);
let username = toml_basic_string(&smtp_credentials.username);
let password = toml_basic_string(&smtp_credentials.password);
let schedule = toml_basic_string(&format!("*/{poll_interval} * * * * * *"));
let mail_config = format!(
r#"token = {token}
instance_display_name = {display_name}
instance_url = {origin}
mail_from_address = {from_address}
mail_reply_to_address = {reply_to}
mail_relay = {relay_host}
mail_username = {username}
mail_password = {password}
mail_connect_timeout_seconds = {connect_timeout}
schedule = {schedule}
"#
);
let extended_labels = generate_extended_mail_sender_labels(kanidm);
Ok(Secret {
metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
name: Some(name.to_string()),
namespace: Some(kanidm.namespace().unwrap()),
owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
labels: Some(extended_labels),
..Default::default()
},
string_data: Some(BTreeMap::from([
(CLIENT_CONFIG_KEY.to_string(), client_config),
(MAIL_CONFIG_KEY.to_string(), mail_config),
])),
type_: Some("Opaque".to_string()),
..Default::default()
})
}
fn default_mail_sender_image(server_image: &str) -> Result<String> {
let tag = match kaniop_k8s_util::resources::get_image_tag(server_image) {
Some(tag) => tag,
None if !server_image.contains('@') => "latest".to_string(),
None => {
return Err(Error::MissingData(
"Cannot infer a mail sender image tag from the Kanidm server image; set spec.mailSender.image explicitly".to_string(),
));
}
};
Ok(format!("kanidm/tools:{tag}"))
}
fn create_deployment(
kanidm: &Kanidm,
name: &str,
spec: &MailSenderSpec,
config_secret_name: &str,
ca_hash: Option<&str>,
) -> Result<Deployment> {
debug!(name, "creating deployment");
let namespace = kanidm.namespace().unwrap();
let image = match &spec.image {
Some(image) => image.clone(),
None => default_mail_sender_image(&kanidm.spec.image)?,
};
let extended_labels = generate_extended_mail_sender_labels(kanidm);
let mut container = Container {
name: MAIL_SENDER_COMPONENT.to_string(),
image: Some(image),
image_pull_policy: kanidm.spec.image_pull_policy.clone(),
command: Some(vec![
"/sbin/kanidm-mail-sender".to_string(),
"-c".to_string(),
format!("/data/config/{CLIENT_CONFIG_KEY}"),
"-m".to_string(),
format!("/data/config/{MAIL_CONFIG_KEY}"),
]),
resources: spec.resources.clone(),
volume_mounts: Some(vec![VolumeMount {
name: "config".to_string(),
mount_path: "/data/config".to_string(),
read_only: Some(true),
..Default::default()
}]),
..Default::default()
};
if spec.ca_bundle_ref.is_some() {
container
.volume_mounts
.get_or_insert_with(Vec::new)
.push(build_ca_bundle_volume_mount());
}
let mut pod_spec = PodSpec {
containers: vec![container],
security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
PodSecurityContext {
run_as_non_root: Some(true),
run_as_user: Some(65534),
..Default::default()
}
})),
volumes: Some(vec![Volume {
name: "config".to_string(),
secret: Some(SecretVolumeSource {
secret_name: Some(config_secret_name.to_string()),
items: Some(vec![
KeyToPath {
key: CLIENT_CONFIG_KEY.to_string(),
path: CLIENT_CONFIG_KEY.to_string(),
..Default::default()
},
KeyToPath {
key: MAIL_CONFIG_KEY.to_string(),
path: MAIL_CONFIG_KEY.to_string(),
..Default::default()
},
]),
..Default::default()
}),
..Default::default()
}]),
node_selector: spec.node_selector.clone(),
affinity: spec.affinity.clone(),
tolerations: spec.tolerations.clone(),
automount_service_account_token: Some(false),
..Default::default()
};
if let Some(ca_bundle_ref) = &spec.ca_bundle_ref {
pod_spec
.volumes
.get_or_insert_with(Vec::new)
.push(build_ca_bundle_volume(ca_bundle_ref));
}
let pod_template = PodTemplateSpec {
metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
labels: Some(extended_labels.clone()),
annotations: ca_hash.map(|hash| {
BTreeMap::from([(MAIL_SENDER_CA_HASH_ANNOTATION.to_string(), hash.to_string())])
}),
..Default::default()
}),
spec: Some(pod_spec),
};
Ok(Deployment {
metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
name: Some(name.to_string()),
namespace: Some(namespace),
owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
labels: Some(extended_labels.clone()),
..Default::default()
},
spec: Some(DeploymentSpec {
replicas: Some(1),
selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
match_labels: Some(extended_labels),
..Default::default()
},
template: pod_template,
strategy: Some(DeploymentStrategy {
type_: Some("Recreate".to_string()),
..Default::default()
}),
..Default::default()
}),
..Default::default()
})
}
struct SmtpCredentials {
username: String,
password: String,
}
async fn read_smtp_credentials(
ctx: &Context,
spec: &MailSenderSpec,
namespace: &str,
) -> Result<SmtpCredentials> {
let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
let secret = secret_api
.get(&spec.credentials_secret.name)
.await
.map_err(|e| {
Error::kube_error(
"get",
"SMTP credentials secret",
namespace,
&spec.credentials_secret.name,
e,
)
})?;
let username_key = &spec.credentials_secret.username_key;
let password_key = &spec.credentials_secret.password_key;
let get_string = |key: &str| -> Result<String> {
secret
.string_data
.as_ref()
.and_then(|d| d.get(key).cloned())
.or_else(|| {
secret
.data
.as_ref()
.and_then(|d| d.get(key))
.map(|v| String::from_utf8_lossy(&v.0).to_string())
})
.ok_or_else(|| {
Error::MissingData(format!(
"SMTP credentials secret {} missing key {}",
spec.credentials_secret.name, key
))
})
};
Ok(SmtpCredentials {
username: get_string(username_key)?,
password: get_string(password_key)?,
})
}
pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<bool> {
let namespace = kanidm.namespace().unwrap();
let kanidm_name = kanidm.name_any();
let mut changed = false;
let deployment_name = mail_sender_deployment_name(&kanidm_name);
let config_secret_name = mail_sender_config_map_name(&kanidm_name);
let deployment_api: Api<Deployment> =
Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
let dp = DeleteParams::default();
match deployment_api.delete(&deployment_name, &dp).await {
Ok(_) => {
changed = true;
}
Err(kube::Error::Api(e)) if e.code == 404 => {
debug!(deployment_name, "mail sender deployment already absent");
}
Err(e) => {
return Err(Error::kube_error(
"delete",
"deployment",
&namespace,
&deployment_name,
e,
));
}
}
match secret_api.delete(&config_secret_name, &dp).await {
Ok(_) => {
changed = true;
}
Err(kube::Error::Api(e)) if e.code == 404 => {
debug!(
config_secret_name,
"mail sender config secret already absent"
);
}
Err(e) => {
return Err(Error::kube_error(
"delete",
"secret",
&namespace,
&config_secret_name,
e,
));
}
}
Ok(changed)
}
pub async fn cleanup_mail_sender_in_kanidm(
kanidm_client: &KanidmClient,
kanidm_name: &str,
metrics: &crate::metrics::ControllerMetrics,
) -> Result<bool> {
let sa_name = mail_sender_service_account_name(kanidm_name);
let mut changed = false;
debug!(sa_name, "removing mail sender from message_senders group");
let start = tokio::time::Instant::now();
let remove_result = kanidm_client
.idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
.await;
match remove_result {
Ok(()) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_REMOVE_MEMBERS,
KANIDM_OUTCOME_CHANGED,
start.elapsed(),
);
changed = true;
}
Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
debug!(sa_name, "mail sender group membership already absent");
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_REMOVE_MEMBERS,
KANIDM_OUTCOME_UNCHANGED,
start.elapsed(),
);
}
Err(e) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_REMOVE_MEMBERS,
KANIDM_OUTCOME_ERROR,
start.elapsed(),
);
return Err(Error::KanidmClientError(
format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
Box::new(e),
));
}
}
debug!(sa_name, "deleting mail sender service account");
let start = tokio::time::Instant::now();
let delete_result = kanidm_client.idm_service_account_delete(&sa_name).await;
match delete_result {
Ok(()) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_DELETE,
KANIDM_OUTCOME_CHANGED,
start.elapsed(),
);
changed = true;
}
Err(e) if is_not_found_error(&e) => {
debug!(sa_name, "mail sender service account already absent");
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_DELETE,
KANIDM_OUTCOME_UNCHANGED,
start.elapsed(),
);
}
Err(e) => {
metrics.record_kanidm_sdk_outcome(
KANIDM_RESOURCE_MAIL_SENDER,
KANIDM_OP_DELETE,
KANIDM_OUTCOME_ERROR,
start.elapsed(),
);
return Err(Error::KanidmClientError(
format!("failed to delete service account {sa_name}"),
Box::new(e),
));
}
}
Ok(changed)
}
fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
match e {
kanidm_client::ClientError::Http(status, _, body) => {
status.as_u16() == 409
|| body.contains("already exists")
|| body.contains("conflicting_with")
|| body.contains("AttributeUniqueness")
}
_ => false,
}
}
fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
match e {
ClientError::Http(status, operation_error, body) => {
status.as_u16() == 404
|| operation_error == &Some(OperationError::NoMatchingEntries)
|| body.contains("NoMatchingEntries")
|| body.contains("not found")
|| body.contains("does not exist")
}
_ => false,
}
}
fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
match e {
ClientError::Http(_, _, body) => body.contains("not a member"),
_ => false,
}
}
fn toml_basic_string(value: &str) -> String {
let mut output = String::with_capacity(value.len() + 2);
output.push('"');
for c in value.chars() {
match c {
'\u{08}' => output.push_str("\\b"),
'\t' => output.push_str("\\t"),
'\n' => output.push_str("\\n"),
'\u{0c}' => output.push_str("\\f"),
'\r' => output.push_str("\\r"),
'"' => output.push_str("\\\""),
'\\' => output.push_str("\\\\"),
c if c.is_control() => {
let code = c as u32;
if code <= 0xffff {
output.push_str(&format!("\\u{code:04X}"));
} else {
output.push_str(&format!("\\U{code:08X}"));
}
}
c => output.push(c),
}
}
output.push('"');
output
}
fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
BTreeMap::from([
(NAME_LABEL.to_string(), "kanidm".to_string()),
(
MANAGED_BY_LABEL.to_string(),
format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
),
(INSTANCE_LABEL.to_string(), kanidm.name_any()),
(CLUSTER_LABEL.to_string(), kanidm.name_any()),
])
}
fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
generate_mail_sender_labels(kanidm)
.into_iter()
.chain([
(MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
(NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
])
.collect()
}
#[cfg(test)]
mod tests {
use super::{
create_deployment, default_mail_sender_image, group_contains_member, toml_basic_string,
};
use crate::kanidm::crd::{CaBundleRef, Kanidm, MailSenderSpec};
use k8s_openapi::api::core::v1::ConfigMap;
use kanidm_client::KanidmClientBuilder;
use openssl::asn1::Asn1Time;
use openssl::bn::BigNum;
use openssl::hash::MessageDigest;
use openssl::pkey::{PKey, Private};
use openssl::rsa::Rsa;
use openssl::ssl::{SslAcceptor, SslMethod};
use openssl::x509::extension::{BasicConstraints, KeyUsage, SubjectAlternativeName};
use openssl::x509::{X509, X509NameBuilder};
use serde_json::json;
use std::io::{Read, Write};
use std::net::TcpListener;
fn tls_test_certificates() -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let ca_key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
let mut ca_name = X509NameBuilder::new().unwrap();
ca_name
.append_entry_by_text("CN", "Kaniop Test CA")
.unwrap();
let ca_name = ca_name.build();
let mut ca_builder = X509::builder().unwrap();
ca_builder.set_version(2).unwrap();
let serial = BigNum::from_u32(1).unwrap().to_asn1_integer().unwrap();
ca_builder.set_serial_number(&serial).unwrap();
ca_builder.set_subject_name(&ca_name).unwrap();
ca_builder.set_issuer_name(&ca_name).unwrap();
ca_builder.set_pubkey(&ca_key).unwrap();
ca_builder
.set_not_before(&Asn1Time::days_from_now(0).unwrap())
.unwrap();
ca_builder
.set_not_after(&Asn1Time::days_from_now(2).unwrap())
.unwrap();
ca_builder
.append_extension(BasicConstraints::new().critical().ca().build().unwrap())
.unwrap();
ca_builder
.append_extension(
KeyUsage::new()
.critical()
.key_cert_sign()
.crl_sign()
.build()
.unwrap(),
)
.unwrap();
ca_builder.sign(&ca_key, MessageDigest::sha256()).unwrap();
let ca = ca_builder.build();
let leaf_key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
let mut leaf_name = X509NameBuilder::new().unwrap();
leaf_name.append_entry_by_text("CN", "localhost").unwrap();
let leaf_name = leaf_name.build();
let mut leaf_builder = X509::builder().unwrap();
leaf_builder.set_version(2).unwrap();
let serial = BigNum::from_u32(2).unwrap().to_asn1_integer().unwrap();
leaf_builder.set_serial_number(&serial).unwrap();
leaf_builder.set_subject_name(&leaf_name).unwrap();
leaf_builder.set_issuer_name(ca.subject_name()).unwrap();
leaf_builder.set_pubkey(&leaf_key).unwrap();
leaf_builder
.set_not_before(&Asn1Time::days_from_now(0).unwrap())
.unwrap();
leaf_builder
.set_not_after(&Asn1Time::days_from_now(2).unwrap())
.unwrap();
leaf_builder
.append_extension(BasicConstraints::new().critical().build().unwrap())
.unwrap();
leaf_builder
.append_extension(
KeyUsage::new()
.critical()
.digital_signature()
.key_encipherment()
.build()
.unwrap(),
)
.unwrap();
let san = SubjectAlternativeName::new()
.dns("localhost")
.build(&leaf_builder.x509v3_context(Some(&ca), None))
.unwrap();
leaf_builder.append_extension(san).unwrap();
leaf_builder.sign(&ca_key, MessageDigest::sha256()).unwrap();
(
ca.to_pem().unwrap(),
leaf_builder.build().to_pem().unwrap(),
leaf_key.private_key_to_pem_pkcs8().unwrap(),
)
}
#[test]
fn ca_rotation_changes_pod_template_hash_only_for_selected_key() {
let (ca_pem, _, _) = tls_test_certificates();
let (other_ca_pem, _, _) = tls_test_certificates();
let ca_ref = CaBundleRef {
name: "private-pki".into(),
key: "ca.crt".into(),
};
let mut cm = ConfigMap {
data: Some(
[
("ca.crt".to_string(), String::from_utf8(ca_pem).unwrap()),
("other".to_string(), "original".to_string()),
]
.into(),
),
..Default::default()
};
let first_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
cm.data
.as_mut()
.unwrap()
.insert("other".into(), "updated".into());
let same_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
assert_eq!(first_hash, same_hash);
cm.data
.as_mut()
.unwrap()
.insert("ca.crt".into(), String::from_utf8(other_ca_pem).unwrap());
let new_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
assert_ne!(first_hash, new_hash);
let kanidm: Kanidm = serde_json::from_value(json!({
"apiVersion": "kaniop.rs/v1beta1", "kind": "Kanidm",
"metadata": {"name": "idm", "namespace": "default"},
"spec": {"domain": "idm.example.com",
"replicaGroups": [{"name": "default", "replicas": 1}]}
}))
.unwrap();
let spec: MailSenderSpec = serde_json::from_value(json!({
"relay": "smtps://smtp.example.com",
"credentialsSecret": {"name": "smtp-credentials"},
"fromAddress": "kanidm@example.com",
"caBundleRef": {"name": "private-pki", "key": "ca.crt"}
}))
.unwrap();
let template_hash = |hash: &str| {
let deployment = create_deployment(
&kanidm,
"idm-mail-sender",
&spec,
"idm-mail-sender-config",
Some(hash),
)
.unwrap();
deployment
.spec
.unwrap()
.template
.metadata
.unwrap()
.annotations
.unwrap()[super::MAIL_SENDER_CA_HASH_ANNOTATION]
.clone()
};
assert_eq!(template_hash(&first_hash), template_hash(&same_hash));
assert_ne!(template_hash(&first_hash), template_hash(&new_hash));
}
#[test]
fn invalid_ca_reference_and_missing_key_are_rejected() {
for (name, key) in [("", "ca.crt"), ("private-pki", ""), (" ", " ")] {
assert!(
super::validate_ca_bundle_ref(&CaBundleRef {
name: name.to_string(),
key: key.to_string(),
})
.is_err()
);
}
let ca_ref = CaBundleRef {
name: "private-pki".into(),
key: "ca.crt".into(),
};
let empty = ConfigMap::default();
assert!(super::ca_bundle_bytes(&ca_ref, &empty).is_err());
let invalid = ConfigMap {
data: Some([("ca.crt".into(), "not a PEM".into())].into()),
..Default::default()
};
assert!(super::ca_bundle_bytes(&ca_ref, &invalid).is_err());
}
#[tokio::test]
async fn private_ca_allows_verified_https_from_generated_client_config() {
let (ca_pem, server_cert, server_key) = tls_test_certificates();
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let url = format!(
"https://localhost:{}",
listener.local_addr().unwrap().port()
);
let server =
std::thread::spawn(move || {
let key = PKey::<Private>::private_key_from_pem(&server_key).unwrap();
let cert = X509::from_pem(&server_cert).unwrap();
let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
acceptor.set_private_key(&key).unwrap();
acceptor.set_certificate(&cert).unwrap();
acceptor.check_private_key().unwrap();
let acceptor = acceptor.build();
for _ in 0..2 {
let (stream, _) = listener.accept().unwrap();
stream
.set_read_timeout(Some(std::time::Duration::from_secs(5)))
.unwrap();
if let Ok(mut connection) = acceptor.accept(stream) {
let mut request = [0u8; 2048];
let _ = connection.read(&mut request);
connection.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nOK",
).unwrap();
}
}
});
let tmp = tempfile::tempdir().unwrap();
let ca_file = tmp.path().join("ca.pem");
std::fs::write(&ca_file, ca_pem).unwrap();
let config_file = tmp.path().join("client.toml");
let mut kanidm: Kanidm = serde_json::from_value(json!({
"apiVersion": "kaniop.rs/v1beta1", "kind": "Kanidm",
"metadata": {"name": "idm", "namespace": "default"},
"spec": {"domain": "idm.example.com",
"replicaGroups": [{"name": "default", "replicas": 1}]}
}))
.unwrap();
kanidm.spec.origin = Some(url.clone());
let mut spec: MailSenderSpec = serde_json::from_value(json!({
"relay": "smtps://smtp.example.com",
"credentialsSecret": {"name": "smtp-credentials"},
"fromAddress": "kanidm@example.com"
}))
.unwrap();
let credentials = super::SmtpCredentials {
username: "smtp-user".into(),
password: "smtp-password".into(),
};
let generated = |spec: &MailSenderSpec| {
super::create_config_secret(
&kanidm,
"idm-mail-sender-config",
spec,
"token",
&credentials,
)
.unwrap()
.string_data
.unwrap()[super::CLIENT_CONFIG_KEY]
.clone()
};
std::fs::write(&config_file, generated(&spec)).unwrap();
let untrusted = KanidmClientBuilder::new()
.no_proxy()
.read_options_from_optional_config(&config_file)
.unwrap()
.build()
.unwrap();
assert!(
untrusted.client().get(&url).send().await.is_err(),
"untrusted CA must fail verification"
);
spec.ca_bundle_ref = Some(CaBundleRef {
name: "private-pki".into(),
key: "ca.crt".into(),
});
let config = generated(&spec).replace(
kaniop_backup_core::auth::CA_BUNDLE_MOUNT_PATH,
ca_file.to_str().unwrap(),
);
assert!(config.contains("ca_path = "));
std::fs::write(&config_file, config).unwrap();
let trusted = KanidmClientBuilder::new()
.no_proxy()
.read_options_from_optional_config(&config_file)
.unwrap()
.build()
.unwrap();
let response = trusted.client().get(&url).send().await.unwrap();
assert!(response.status().is_success());
server.join().unwrap();
}
#[test]
fn custom_ca_bundle_configures_mail_sender_client_and_pod() {
let kanidm: Kanidm = serde_json::from_value(json!({
"apiVersion": "kaniop.rs/v1beta1",
"kind": "Kanidm",
"metadata": {"name": "idm", "namespace": "default"},
"spec": {
"domain": "idm.example.com",
"replicaGroups": [{"name": "default", "replicas": 1}]
}
}))
.unwrap();
let mut spec: MailSenderSpec = serde_json::from_value(json!({
"relay": "smtps://smtp.example.com",
"credentialsSecret": {"name": "smtp-credentials"},
"fromAddress": "kanidm@example.com",
"caBundleRef": {"name": "private-pki", "key": "ca.crt"}
}))
.unwrap();
let credentials = super::SmtpCredentials {
username: "smtp-user".to_string(),
password: "smtp-password".to_string(),
};
let secret = super::create_config_secret(
&kanidm,
"idm-mail-sender-config",
&spec,
"token",
&credentials,
)
.unwrap();
let config = secret.string_data.unwrap();
assert_eq!(
config[super::CLIENT_CONFIG_KEY],
format!(
"uri = \"https://idm.example.com\"\nca_path = \"{}\"",
kaniop_backup_core::auth::CA_BUNDLE_MOUNT_PATH
)
);
let deployment = create_deployment(
&kanidm,
"idm-mail-sender",
&spec,
"idm-mail-sender-config",
None,
)
.unwrap();
let pod = deployment.spec.unwrap().template.spec.unwrap();
let volume = pod
.volumes
.as_ref()
.unwrap()
.iter()
.find(|volume| volume.name == kaniop_backup_core::auth::CA_BUNDLE_VOLUME_NAME)
.unwrap();
let cm = volume.config_map.as_ref().unwrap();
assert_eq!(cm.name, "private-pki");
assert_eq!(cm.items.as_ref().unwrap()[0].key, "ca.crt");
assert_eq!(
cm.items.as_ref().unwrap()[0].path,
kaniop_backup_core::auth::CA_BUNDLE_FILE_NAME
);
let mount = pod.containers[0]
.volume_mounts
.as_ref()
.unwrap()
.iter()
.find(|mount| mount.name == kaniop_backup_core::auth::CA_BUNDLE_VOLUME_NAME)
.unwrap();
assert_eq!(
mount.mount_path,
kaniop_backup_core::auth::CA_BUNDLE_MOUNT_DIR
);
assert_eq!(mount.read_only, Some(true));
assert_eq!(pod.volumes.as_ref().unwrap().len(), 2);
spec.ca_bundle_ref = None;
let secret = super::create_config_secret(
&kanidm,
"idm-mail-sender-config",
&spec,
"token",
&credentials,
)
.unwrap();
assert_eq!(
secret.string_data.unwrap()[super::CLIENT_CONFIG_KEY],
"uri = \"https://idm.example.com\""
);
let deployment = create_deployment(
&kanidm,
"idm-mail-sender",
&spec,
"idm-mail-sender-config",
None,
)
.unwrap();
let pod = deployment.spec.unwrap().template.spec.unwrap();
assert_eq!(pod.volumes.as_ref().unwrap().len(), 1);
assert_eq!(pod.containers[0].volume_mounts.as_ref().unwrap().len(), 1);
}
#[test]
fn ca_bundle_ref_requires_a_configmap_name_and_key() {
assert!(
serde_json::from_value::<MailSenderSpec>(json!({
"relay": "smtps://smtp.example.com",
"credentialsSecret": {"name": "smtp-credentials"},
"fromAddress": "kanidm@example.com",
"caBundleRef": {"name": "private-pki"}
}))
.is_err()
);
}
#[test]
fn digest_pinned_server_image_creates_pullable_mail_sender_deployment() {
let kanidm: Kanidm = serde_json::from_value(json!({
"apiVersion": "kaniop.rs/v1beta1",
"kind": "Kanidm",
"metadata": {"name": "idm", "namespace": "default"},
"spec": {
"domain": "idm.example.com",
"image": "kanidm/server:1.11.2@sha256:deadbeef",
"replicaGroups": [{"name": "default", "replicas": 1}]
}
}))
.unwrap();
let mail_sender_spec: MailSenderSpec = serde_json::from_value(json!({
"relay": "smtps://smtp.example.com",
"credentialsSecret": {"name": "smtp-credentials"},
"fromAddress": "kanidm@example.com"
}))
.unwrap();
let deployment = create_deployment(
&kanidm,
"idm-mail-sender",
&mail_sender_spec,
"idm-mail-sender-config",
None,
)
.unwrap();
let image = deployment.spec.unwrap().template.spec.unwrap().containers[0]
.image
.clone();
assert_eq!(image.as_deref(), Some("kanidm/tools:1.11.2"));
assert!(!image.unwrap().contains("@sha256:"));
let override_image = "mirror.example.org/custom/mail-sender:custom@sha256:abcdef";
let mut overridden = mail_sender_spec;
overridden.image = Some(override_image.to_string());
let deployment = create_deployment(
&kanidm,
"idm-mail-sender",
&overridden,
"idm-mail-sender-config",
None,
)
.unwrap();
assert_eq!(
deployment.spec.unwrap().template.spec.unwrap().containers[0]
.image
.as_deref(),
Some(override_image),
);
let mut digest_only_server = kanidm;
digest_only_server.spec.image = "kanidm/server@sha256:deadbeef".to_string();
let deployment = create_deployment(
&digest_only_server,
"idm-mail-sender",
&overridden,
"idm-mail-sender-config",
None,
)
.unwrap();
assert_eq!(
deployment.spec.unwrap().template.spec.unwrap().containers[0]
.image
.as_deref(),
Some(override_image),
);
}
#[test]
fn default_mail_sender_image_uses_docker_hub_versioned_tools() {
for (server, expected) in [
("kanidm/server:1.11.2", "kanidm/tools:1.11.2"),
("kanidm/server:latest", "kanidm/tools:latest"),
("kanidm/server", "kanidm/tools:latest"),
(
"kanidm/server:1.11.2@sha256:deadbeef",
"kanidm/tools:1.11.2",
),
] {
assert_eq!(default_mail_sender_image(server).unwrap(), expected);
}
}
#[test]
fn digest_only_server_image_requires_explicit_mail_sender_image() {
assert!(default_mail_sender_image("kanidm/server@sha256:deadbeef").is_err());
}
#[test]
fn toml_basic_string_escapes_config_values() {
assert_eq!(
toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
r#""quoted \"value\" with \\ slash\nand tab\t""#
);
}
#[test]
fn group_contains_member_matches_bare_name_against_spn() {
let members = vec![
"other-user".to_string(),
"my-sa@idm.example.com".to_string(),
];
assert!(group_contains_member(&members, "my-sa"));
}
#[test]
fn group_contains_member_is_case_insensitive() {
let members = vec!["My-SA@idm.example.com".to_string()];
assert!(group_contains_member(&members, "my-sa"));
}
#[test]
fn group_contains_member_returns_false_for_empty() {
let members: Vec<String> = vec![];
assert!(!group_contains_member(&members, "my-sa"));
}
#[test]
fn group_contains_member_returns_false_when_no_match() {
let members = vec![
"other-user".to_string(),
"another-sa@idm.example.com".to_string(),
];
assert!(!group_contains_member(&members, "my-sa"));
}
}