Skip to main content

kaniop_operator/kanidm/reconcile/
mail_sender.rs

1use super::super::controller::context::Context;
2use super::CLUSTER_LABEL;
3use crate::controller::{INSTANCE_LABEL, MANAGED_BY_LABEL, NAME_LABEL};
4use crate::kanidm::crd::{Kanidm, MailSenderSpec, MailSenderStatus};
5use crate::metrics::{
6    KANIDM_OP_CREATE, KANIDM_OP_DELETE, KANIDM_OP_DESTROY_API_TOKEN, KANIDM_OP_GENERATE_API_TOKEN,
7    KANIDM_OP_GET, KANIDM_OP_LIST_API_TOKENS, KANIDM_OP_REMOVE_MEMBERS, KANIDM_OP_SET_MEMBERS,
8    KANIDM_OP_UPDATE, KANIDM_OUTCOME_CHANGED, KANIDM_OUTCOME_ERROR, KANIDM_OUTCOME_UNCHANGED,
9    KANIDM_RESOURCE_MAIL_SENDER, record_kanidm_sdk_call,
10};
11use kaniop_k8s_util::error::{Error, Result};
12use kaniop_k8s_util::types::normalize_spn;
13
14use std::collections::BTreeMap;
15use std::sync::Arc;
16
17use k8s_openapi::api::apps::v1::{Deployment, DeploymentSpec, DeploymentStrategy};
18use k8s_openapi::api::core::v1::{
19    Container, KeyToPath, PodSecurityContext, PodSpec, PodTemplateSpec, Secret, SecretVolumeSource,
20    Volume, VolumeMount,
21};
22use kanidm_client::{ClientError, KanidmClient};
23use kanidm_proto::internal::OperationError;
24use kube::api::{Api, DeleteParams};
25use kube::{Resource, ResourceExt};
26use tracing::{debug, info};
27
28const MAIL_SENDER_LABEL: &str = "mail-sender";
29const MAIL_SENDER_COMPONENT: &str = "kanidm-mail-sender";
30const MESSAGE_SENDERS_GROUP: &str = "idm_message_senders";
31const MAIL_SENDER_SERVICE_ACCOUNT_SUFFIX: &str = "mail-sender";
32const MAIL_SENDER_TOKEN_SUFFIX: &str = "mail-sender-token";
33const MAIL_SENDER_CONFIG_SUFFIX: &str = "mail-sender-config";
34const MAIL_SENDER_DEPLOYMENT_SUFFIX: &str = "mail-sender";
35const DEFAULT_QUEUE_POLL_INTERVAL: i32 = 5;
36const DEFAULT_CONNECT_TIMEOUT: i32 = 15;
37const CLIENT_CONFIG_KEY: &str = "client.toml";
38const MAIL_CONFIG_KEY: &str = "mail-sender.toml";
39const ENTRY_MANAGED_BY: &str = "idm_admin";
40
41pub fn mail_sender_service_account_name(kanidm_name: &str) -> String {
42    format!("{kanidm_name}-{MAIL_SENDER_SERVICE_ACCOUNT_SUFFIX}")
43}
44
45pub fn mail_sender_token_secret_name(kanidm_name: &str) -> String {
46    format!("{kanidm_name}-{MAIL_SENDER_TOKEN_SUFFIX}")
47}
48
49pub fn mail_sender_config_map_name(kanidm_name: &str) -> String {
50    format!("{kanidm_name}-{MAIL_SENDER_CONFIG_SUFFIX}")
51}
52
53pub fn mail_sender_deployment_name(kanidm_name: &str) -> String {
54    format!("{kanidm_name}-{MAIL_SENDER_DEPLOYMENT_SUFFIX}")
55}
56
57pub async fn reconcile_mail_sender(
58    kanidm: &Kanidm,
59    kanidm_client: Arc<KanidmClient>,
60    ctx: Arc<Context>,
61) -> Result<(Option<MailSenderStatus>, bool)> {
62    let namespace = kanidm.namespace().unwrap();
63    let kanidm_name = kanidm.name_any();
64
65    if let Some(mail_sender_spec) = &kanidm.spec.mail_sender {
66        info!(namespace, kanidm_name, "reconciling mail sender");
67
68        let sa_name = mail_sender_service_account_name(&kanidm_name);
69        let config_secret_name = mail_sender_config_map_name(&kanidm_name);
70        let deployment_name = mail_sender_deployment_name(&kanidm_name);
71
72        let mut changed = false;
73
74        let sa_changed = ensure_mail_sender_service_account(
75            &kanidm_client,
76            &sa_name,
77            &kanidm.spec.domain,
78            &ctx.kaniop_ctx.metrics,
79        )
80        .await?;
81        changed |= sa_changed;
82
83        let group_changed =
84            ensure_mail_sender_in_group(&kanidm_client, &sa_name, &ctx.kaniop_ctx.metrics).await?;
85        changed |= group_changed;
86
87        let current_token_id = kanidm
88            .status
89            .as_ref()
90            .and_then(|s| s.mail_sender.as_ref())
91            .and_then(|ms| ms.token_id.clone());
92
93        let (token, token_id, token_changed) = ensure_mail_sender_token(
94            &kanidm_client,
95            &ctx,
96            &namespace,
97            &config_secret_name,
98            &sa_name,
99            current_token_id,
100            &ctx.kaniop_ctx.metrics,
101        )
102        .await?;
103        changed |= token_changed;
104
105        let smtp_credentials = read_smtp_credentials(&ctx, mail_sender_spec, &namespace).await?;
106
107        let config_secret = create_config_secret(
108            kanidm,
109            &config_secret_name,
110            mail_sender_spec,
111            &token,
112            &smtp_credentials,
113        )?;
114        kanidm.patch(&ctx, config_secret).await?;
115
116        let deployment = create_deployment(
117            kanidm,
118            &deployment_name,
119            mail_sender_spec,
120            &config_secret_name,
121        )?;
122        kanidm.patch(&ctx, deployment).await?;
123
124        let deployment_api: Api<Deployment> =
125            Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
126        let deployment_status = deployment_api
127            .get(&deployment_name)
128            .await
129            .map_err(|e| Error::kube_error("get", "deployment", &namespace, &deployment_name, e))?;
130
131        let ready = deployment_status
132            .status
133            .as_ref()
134            .is_some_and(|s| s.ready_replicas.unwrap_or(0) >= 1);
135
136        Ok((
137            Some(MailSenderStatus {
138                service_account_name: sa_name,
139                token_secret_name: config_secret_name.clone(),
140                deployment_name,
141                config_map_name: config_secret_name,
142                token_id: Some(token_id),
143                ready,
144            }),
145            changed,
146        ))
147    } else {
148        debug!(
149            namespace,
150            kanidm_name, "mail sender not enabled, cleaning up resources"
151        );
152        let cleanup_changed = cleanup_mail_sender_resources(kanidm, &ctx).await?;
153        Ok((None, cleanup_changed))
154    }
155}
156
157async fn ensure_mail_sender_service_account(
158    kanidm_client: &KanidmClient,
159    name: &str,
160    domain: &str,
161    metrics: &crate::metrics::ControllerMetrics,
162) -> Result<bool> {
163    debug!(name, "ensuring mail sender service account exists");
164
165    let display_name = format!("Mail Sender ({domain})");
166
167    let start = tokio::time::Instant::now();
168    let create_result = kanidm_client
169        .idm_service_account_create(name, &display_name, ENTRY_MANAGED_BY)
170        .await;
171
172    match create_result {
173        Ok(_) => {
174            metrics.record_kanidm_sdk_outcome(
175                KANIDM_RESOURCE_MAIL_SENDER,
176                KANIDM_OP_CREATE,
177                KANIDM_OUTCOME_CHANGED,
178                start.elapsed(),
179            );
180            Ok(true)
181        }
182        Err(e) if is_already_exists_error(&e) => {
183            metrics.record_kanidm_sdk_outcome(
184                KANIDM_RESOURCE_MAIL_SENDER,
185                KANIDM_OP_CREATE,
186                KANIDM_OUTCOME_UNCHANGED,
187                start.elapsed(),
188            );
189            debug!(name, "service account already exists, updating");
190            let start = tokio::time::Instant::now();
191            kanidm_client
192                .idm_service_account_update(name, None, Some(&display_name), None, None)
193                .await
194                .map_err(|e| {
195                    metrics.record_kanidm_sdk_outcome(
196                        KANIDM_RESOURCE_MAIL_SENDER,
197                        KANIDM_OP_UPDATE,
198                        KANIDM_OUTCOME_ERROR,
199                        start.elapsed(),
200                    );
201                    Error::KanidmClientError(
202                        format!("failed to update service account {name}"),
203                        Box::new(e),
204                    )
205                })?;
206            metrics.record_kanidm_sdk_outcome(
207                KANIDM_RESOURCE_MAIL_SENDER,
208                KANIDM_OP_UPDATE,
209                KANIDM_OUTCOME_UNCHANGED,
210                start.elapsed(),
211            );
212            Ok(false)
213        }
214        Err(e) => {
215            metrics.record_kanidm_sdk_outcome(
216                KANIDM_RESOURCE_MAIL_SENDER,
217                KANIDM_OP_CREATE,
218                KANIDM_OUTCOME_ERROR,
219                start.elapsed(),
220            );
221            Err(Error::KanidmClientError(
222                format!("failed to create service account {name}"),
223                Box::new(e),
224            ))
225        }
226    }
227}
228
229fn group_contains_member(members: &[String], name: &str) -> bool {
230    members
231        .iter()
232        .any(|m| normalize_spn(m) == normalize_spn(name))
233}
234
235async fn ensure_mail_sender_in_group(
236    kanidm_client: &KanidmClient,
237    name: &str,
238    metrics: &crate::metrics::ControllerMetrics,
239) -> Result<bool> {
240    debug!(name, "ensuring mail sender is in message_senders group");
241
242    let start = tokio::time::Instant::now();
243    let members_result = kanidm_client
244        .idm_group_get_members(MESSAGE_SENDERS_GROUP)
245        .await;
246
247    let current_members = match members_result {
248        Ok(Some(members)) => {
249            metrics.record_kanidm_sdk_outcome(
250                KANIDM_RESOURCE_MAIL_SENDER,
251                KANIDM_OP_GET,
252                KANIDM_OUTCOME_UNCHANGED,
253                start.elapsed(),
254            );
255            members
256        }
257        Ok(None) => {
258            metrics.record_kanidm_sdk_outcome(
259                KANIDM_RESOURCE_MAIL_SENDER,
260                KANIDM_OP_GET,
261                KANIDM_OUTCOME_UNCHANGED,
262                start.elapsed(),
263            );
264            vec![]
265        }
266        Err(e) => {
267            metrics.record_kanidm_sdk_outcome(
268                KANIDM_RESOURCE_MAIL_SENDER,
269                KANIDM_OP_GET,
270                KANIDM_OUTCOME_ERROR,
271                start.elapsed(),
272            );
273            return Err(Error::KanidmClientError(
274                format!("failed to get members of {MESSAGE_SENDERS_GROUP}"),
275                Box::new(e),
276            ));
277        }
278    };
279
280    if group_contains_member(&current_members, name) {
281        debug!(name, "service account already in group");
282        return Ok(false);
283    }
284
285    let start = tokio::time::Instant::now();
286    let add_result = kanidm_client
287        .idm_group_add_members(MESSAGE_SENDERS_GROUP, &[name])
288        .await;
289
290    match add_result {
291        Ok(_) => {
292            metrics.record_kanidm_sdk_outcome(
293                KANIDM_RESOURCE_MAIL_SENDER,
294                KANIDM_OP_SET_MEMBERS,
295                KANIDM_OUTCOME_CHANGED,
296                start.elapsed(),
297            );
298            Ok(true)
299        }
300        Err(e) => {
301            metrics.record_kanidm_sdk_outcome(
302                KANIDM_RESOURCE_MAIL_SENDER,
303                KANIDM_OP_SET_MEMBERS,
304                KANIDM_OUTCOME_ERROR,
305                start.elapsed(),
306            );
307            Err(Error::KanidmClientError(
308                format!("failed to add {name} to {MESSAGE_SENDERS_GROUP}"),
309                Box::new(e),
310            ))
311        }
312    }
313}
314
315async fn ensure_mail_sender_token(
316    kanidm_client: &KanidmClient,
317    ctx: &Context,
318    namespace: &str,
319    config_secret_name: &str,
320    name: &str,
321    current_token_id: Option<String>,
322    metrics: &crate::metrics::ControllerMetrics,
323) -> Result<(String, String, bool)> {
324    debug!(name, current_token_id = ?current_token_id, "ensuring mail sender API token exists");
325
326    let start = tokio::time::Instant::now();
327    let existing_tokens_result = kanidm_client.idm_service_account_list_api_token(name).await;
328    let existing_tokens = match existing_tokens_result {
329        Ok(tokens) => {
330            metrics.record_kanidm_sdk_outcome(
331                KANIDM_RESOURCE_MAIL_SENDER,
332                KANIDM_OP_LIST_API_TOKENS,
333                KANIDM_OUTCOME_UNCHANGED,
334                start.elapsed(),
335            );
336            tokens
337        }
338        Err(ClientError::Http(status, _, _)) if status == 404 => {
339            metrics.record_kanidm_sdk_outcome(
340                KANIDM_RESOURCE_MAIL_SENDER,
341                KANIDM_OP_LIST_API_TOKENS,
342                KANIDM_OUTCOME_UNCHANGED,
343                start.elapsed(),
344            );
345            vec![]
346        }
347        Err(e) => {
348            metrics.record_kanidm_sdk_outcome(
349                KANIDM_RESOURCE_MAIL_SENDER,
350                KANIDM_OP_LIST_API_TOKENS,
351                KANIDM_OUTCOME_ERROR,
352                start.elapsed(),
353            );
354            return Err(Error::KanidmClientError(
355                format!("failed to list API tokens for {name}"),
356                Box::new(e),
357            ));
358        }
359    };
360
361    let existing_mail_sender_tokens: Vec<_> = existing_tokens
362        .iter()
363        .filter(|t| t.label == MAIL_SENDER_COMPONENT)
364        .collect();
365
366    if let Some(token) = existing_mail_sender_tokens.first() {
367        if current_token_id.as_ref() == Some(&token.token_id.to_string()) {
368            debug!(name, token_id = %token.token_id, "mail sender token already exists with matching token_id, reading from existing secret");
369            if let Some(existing_token_value) =
370                read_token_from_config_secret(ctx, namespace, config_secret_name).await?
371            {
372                return Ok((existing_token_value, token.token_id.to_string(), false));
373            }
374            debug!(name, token_id = %token.token_id, "existing token value not found in secret, destroying all tokens and regenerating");
375        } else {
376            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");
377        }
378
379        for token in existing_mail_sender_tokens {
380            record_kanidm_sdk_call(
381                metrics,
382                KANIDM_RESOURCE_MAIL_SENDER,
383                KANIDM_OP_DESTROY_API_TOKEN,
384                KANIDM_OUTCOME_CHANGED,
385                kanidm_client.idm_service_account_destroy_api_token(name, token.token_id),
386            )
387            .await
388            .map_err(|e| {
389                Error::KanidmClientError(
390                    format!("failed to destroy API token {} for {name}", token.token_id),
391                    Box::new(e),
392                )
393            })?;
394        }
395    }
396
397    debug!(name, "generating new read-write API token for mail sender");
398
399    let token_value = record_kanidm_sdk_call(
400        metrics,
401        KANIDM_RESOURCE_MAIL_SENDER,
402        KANIDM_OP_GENERATE_API_TOKEN,
403        KANIDM_OUTCOME_CHANGED,
404        kanidm_client.idm_service_account_generate_api_token(
405            name,
406            MAIL_SENDER_COMPONENT,
407            None,
408            true,
409            false,
410        ),
411    )
412    .await
413    .map_err(|e| {
414        Error::KanidmClientError(
415            format!("failed to generate API token for {name}"),
416            Box::new(e),
417        )
418    })?;
419
420    let new_tokens = record_kanidm_sdk_call(
421        metrics,
422        KANIDM_RESOURCE_MAIL_SENDER,
423        KANIDM_OP_LIST_API_TOKENS,
424        KANIDM_OUTCOME_UNCHANGED,
425        kanidm_client.idm_service_account_list_api_token(name),
426    )
427    .await
428    .map_err(|e| {
429        Error::KanidmClientError(
430            format!("failed to list API tokens for {name} after generation"),
431            Box::new(e),
432        )
433    })?;
434
435    let new_token = new_tokens
436        .iter()
437        .find(|t| t.label == MAIL_SENDER_COMPONENT)
438        .ok_or_else(|| {
439            Error::MissingData(format!(
440                "generated token with label {MAIL_SENDER_COMPONENT} not found for {name}"
441            ))
442        })?;
443
444    Ok((token_value, new_token.token_id.to_string(), true))
445}
446
447async fn read_token_from_config_secret(
448    ctx: &Context,
449    namespace: &str,
450    name: &str,
451) -> Result<Option<String>> {
452    let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
453    let secret = match secret_api.get(name).await {
454        Ok(s) => s,
455        Err(kube::Error::Api(e)) if e.code == 404 => {
456            debug!(
457                name,
458                "mail sender config secret not found, will regenerate token"
459            );
460            return Ok(None);
461        }
462        Err(e) => {
463            return Err(Error::kube_error(
464                "get",
465                "mail sender config secret",
466                namespace,
467                name,
468                e,
469            ));
470        }
471    };
472
473    let mail_config = secret
474        .string_data
475        .as_ref()
476        .and_then(|d| d.get(MAIL_CONFIG_KEY).cloned())
477        .or_else(|| {
478            secret
479                .data
480                .as_ref()
481                .and_then(|d| d.get(MAIL_CONFIG_KEY))
482                .map(|v| String::from_utf8_lossy(&v.0).to_string())
483        });
484
485    match mail_config {
486        Some(config) => {
487            let token = config
488                .lines()
489                .find(|line| line.starts_with("token = "))
490                .and_then(|line| line.strip_prefix("token = "))
491                .and_then(|value| value.strip_prefix('"').and_then(|v| v.strip_suffix('"')))
492                .map(|s| s.to_string());
493            Ok(token)
494        }
495        None => {
496            debug!(
497                name,
498                "mail sender config secret missing mail-sender.toml key, will regenerate token"
499            );
500            Ok(None)
501        }
502    }
503}
504
505fn create_config_secret(
506    kanidm: &Kanidm,
507    name: &str,
508    spec: &MailSenderSpec,
509    token: &str,
510    smtp_credentials: &SmtpCredentials,
511) -> Result<Secret> {
512    debug!(name, "creating config secret");
513
514    let domain = &kanidm.spec.domain;
515    let default_origin = format!("https://{domain}");
516    let origin = kanidm.spec.origin.as_ref().unwrap_or(&default_origin);
517    let default_display_name = format!("Kanidm {domain}");
518    let display_name = kanidm
519        .spec
520        .domain_appearance
521        .as_ref()
522        .and_then(|da| da.display_name.as_ref())
523        .unwrap_or(&default_display_name);
524    let poll_interval = spec
525        .queue_poll_interval_seconds
526        .unwrap_or(DEFAULT_QUEUE_POLL_INTERVAL);
527    let connect_timeout = spec
528        .connect_timeout_seconds
529        .unwrap_or(DEFAULT_CONNECT_TIMEOUT);
530
531    let client_config = format!("uri = {}", toml_basic_string(origin));
532
533    let reply_to = spec
534        .reply_to_address
535        .as_deref()
536        .unwrap_or(&spec.from_address);
537
538    let token = toml_basic_string(token);
539    let display_name = toml_basic_string(display_name);
540    let origin = toml_basic_string(origin);
541    let from_address = toml_basic_string(&spec.from_address);
542    let reply_to = toml_basic_string(reply_to);
543    let relay_host = toml_basic_string(&spec.relay);
544    let username = toml_basic_string(&smtp_credentials.username);
545    let password = toml_basic_string(&smtp_credentials.password);
546    let schedule = toml_basic_string(&format!("*/{poll_interval} * * * * * *"));
547
548    let mail_config = format!(
549        r#"token = {token}
550instance_display_name = {display_name}
551instance_url = {origin}
552mail_from_address = {from_address}
553mail_reply_to_address = {reply_to}
554mail_relay = {relay_host}
555mail_username = {username}
556mail_password = {password}
557mail_connect_timeout_seconds = {connect_timeout}
558schedule = {schedule}
559"#
560    );
561
562    let extended_labels = generate_extended_mail_sender_labels(kanidm);
563
564    Ok(Secret {
565        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
566            name: Some(name.to_string()),
567            namespace: Some(kanidm.namespace().unwrap()),
568            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
569            labels: Some(extended_labels),
570            ..Default::default()
571        },
572        string_data: Some(BTreeMap::from([
573            (CLIENT_CONFIG_KEY.to_string(), client_config),
574            (MAIL_CONFIG_KEY.to_string(), mail_config),
575        ])),
576        type_: Some("Opaque".to_string()),
577        ..Default::default()
578    })
579}
580
581// Follow Kanidm's Docker Hub release convention: server:<tag> -> tools:<tag>.
582// Image digests identify individual artifacts and must never be carried from
583// the server image into the separate tools image. The explicit mailSender.image
584// always takes precedence over this default.
585fn default_mail_sender_image(server_image: &str) -> Result<String> {
586    let tag = match kaniop_k8s_util::resources::get_image_tag(server_image) {
587        Some(tag) => tag,
588        None if !server_image.contains('@') => "latest".to_string(),
589        None => {
590            return Err(Error::MissingData(
591                "Cannot infer a mail sender image tag from the Kanidm server image; set spec.mailSender.image explicitly".to_string(),
592            ));
593        }
594    };
595
596    Ok(format!("kanidm/tools:{tag}"))
597}
598
599fn create_deployment(
600    kanidm: &Kanidm,
601    name: &str,
602    spec: &MailSenderSpec,
603    config_secret_name: &str,
604) -> Result<Deployment> {
605    debug!(name, "creating deployment");
606
607    let namespace = kanidm.namespace().unwrap();
608    let image = match &spec.image {
609        Some(image) => image.clone(),
610        None => default_mail_sender_image(&kanidm.spec.image)?,
611    };
612
613    let extended_labels = generate_extended_mail_sender_labels(kanidm);
614
615    let container = Container {
616        name: MAIL_SENDER_COMPONENT.to_string(),
617        image: Some(image),
618        image_pull_policy: kanidm.spec.image_pull_policy.clone(),
619        command: Some(vec![
620            "/sbin/kanidm-mail-sender".to_string(),
621            "-c".to_string(),
622            format!("/data/config/{CLIENT_CONFIG_KEY}"),
623            "-m".to_string(),
624            format!("/data/config/{MAIL_CONFIG_KEY}"),
625        ]),
626        resources: spec.resources.clone(),
627        volume_mounts: Some(vec![VolumeMount {
628            name: "config".to_string(),
629            mount_path: "/data/config".to_string(),
630            read_only: Some(true),
631            ..Default::default()
632        }]),
633        ..Default::default()
634    };
635
636    let pod_spec = PodSpec {
637        containers: vec![container],
638        security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
639            PodSecurityContext {
640                run_as_non_root: Some(true),
641                run_as_user: Some(65534),
642                ..Default::default()
643            }
644        })),
645        volumes: Some(vec![Volume {
646            name: "config".to_string(),
647            secret: Some(SecretVolumeSource {
648                secret_name: Some(config_secret_name.to_string()),
649                items: Some(vec![
650                    KeyToPath {
651                        key: CLIENT_CONFIG_KEY.to_string(),
652                        path: CLIENT_CONFIG_KEY.to_string(),
653                        ..Default::default()
654                    },
655                    KeyToPath {
656                        key: MAIL_CONFIG_KEY.to_string(),
657                        path: MAIL_CONFIG_KEY.to_string(),
658                        ..Default::default()
659                    },
660                ]),
661                ..Default::default()
662            }),
663            ..Default::default()
664        }]),
665        node_selector: spec.node_selector.clone(),
666        affinity: spec.affinity.clone(),
667        tolerations: spec.tolerations.clone(),
668        automount_service_account_token: Some(false),
669        ..Default::default()
670    };
671
672    let pod_template = PodTemplateSpec {
673        metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
674            labels: Some(extended_labels.clone()),
675            ..Default::default()
676        }),
677        spec: Some(pod_spec),
678    };
679
680    Ok(Deployment {
681        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
682            name: Some(name.to_string()),
683            namespace: Some(namespace),
684            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
685            labels: Some(extended_labels.clone()),
686            ..Default::default()
687        },
688        spec: Some(DeploymentSpec {
689            replicas: Some(1),
690            selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
691                match_labels: Some(extended_labels),
692                ..Default::default()
693            },
694            template: pod_template,
695            strategy: Some(DeploymentStrategy {
696                type_: Some("Recreate".to_string()),
697                ..Default::default()
698            }),
699            ..Default::default()
700        }),
701        ..Default::default()
702    })
703}
704
705struct SmtpCredentials {
706    username: String,
707    password: String,
708}
709
710async fn read_smtp_credentials(
711    ctx: &Context,
712    spec: &MailSenderSpec,
713    namespace: &str,
714) -> Result<SmtpCredentials> {
715    let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
716    let secret = secret_api
717        .get(&spec.credentials_secret.name)
718        .await
719        .map_err(|e| {
720            Error::kube_error(
721                "get",
722                "SMTP credentials secret",
723                namespace,
724                &spec.credentials_secret.name,
725                e,
726            )
727        })?;
728
729    let username_key = &spec.credentials_secret.username_key;
730    let password_key = &spec.credentials_secret.password_key;
731
732    let get_string = |key: &str| -> Result<String> {
733        secret
734            .string_data
735            .as_ref()
736            .and_then(|d| d.get(key).cloned())
737            .or_else(|| {
738                secret
739                    .data
740                    .as_ref()
741                    .and_then(|d| d.get(key))
742                    .map(|v| String::from_utf8_lossy(&v.0).to_string())
743            })
744            .ok_or_else(|| {
745                Error::MissingData(format!(
746                    "SMTP credentials secret {} missing key {}",
747                    spec.credentials_secret.name, key
748                ))
749            })
750    };
751
752    Ok(SmtpCredentials {
753        username: get_string(username_key)?,
754        password: get_string(password_key)?,
755    })
756}
757
758pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<bool> {
759    let namespace = kanidm.namespace().unwrap();
760    let kanidm_name = kanidm.name_any();
761    let mut changed = false;
762
763    let deployment_name = mail_sender_deployment_name(&kanidm_name);
764    let config_secret_name = mail_sender_config_map_name(&kanidm_name);
765
766    let deployment_api: Api<Deployment> =
767        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
768    let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
769        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
770
771    let dp = DeleteParams::default();
772
773    match deployment_api.delete(&deployment_name, &dp).await {
774        Ok(_) => {
775            changed = true;
776        }
777        Err(kube::Error::Api(e)) if e.code == 404 => {
778            debug!(deployment_name, "mail sender deployment already absent");
779        }
780        Err(e) => {
781            return Err(Error::kube_error(
782                "delete",
783                "deployment",
784                &namespace,
785                &deployment_name,
786                e,
787            ));
788        }
789    }
790
791    match secret_api.delete(&config_secret_name, &dp).await {
792        Ok(_) => {
793            changed = true;
794        }
795        Err(kube::Error::Api(e)) if e.code == 404 => {
796            debug!(
797                config_secret_name,
798                "mail sender config secret already absent"
799            );
800        }
801        Err(e) => {
802            return Err(Error::kube_error(
803                "delete",
804                "secret",
805                &namespace,
806                &config_secret_name,
807                e,
808            ));
809        }
810    }
811
812    Ok(changed)
813}
814
815pub async fn cleanup_mail_sender_in_kanidm(
816    kanidm_client: &KanidmClient,
817    kanidm_name: &str,
818    metrics: &crate::metrics::ControllerMetrics,
819) -> Result<bool> {
820    let sa_name = mail_sender_service_account_name(kanidm_name);
821    let mut changed = false;
822
823    debug!(sa_name, "removing mail sender from message_senders group");
824    let start = tokio::time::Instant::now();
825    let remove_result = kanidm_client
826        .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
827        .await;
828    match remove_result {
829        Ok(()) => {
830            metrics.record_kanidm_sdk_outcome(
831                KANIDM_RESOURCE_MAIL_SENDER,
832                KANIDM_OP_REMOVE_MEMBERS,
833                KANIDM_OUTCOME_CHANGED,
834                start.elapsed(),
835            );
836            changed = true;
837        }
838        Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
839            debug!(sa_name, "mail sender group membership already absent");
840            metrics.record_kanidm_sdk_outcome(
841                KANIDM_RESOURCE_MAIL_SENDER,
842                KANIDM_OP_REMOVE_MEMBERS,
843                KANIDM_OUTCOME_UNCHANGED,
844                start.elapsed(),
845            );
846        }
847        Err(e) => {
848            metrics.record_kanidm_sdk_outcome(
849                KANIDM_RESOURCE_MAIL_SENDER,
850                KANIDM_OP_REMOVE_MEMBERS,
851                KANIDM_OUTCOME_ERROR,
852                start.elapsed(),
853            );
854            return Err(Error::KanidmClientError(
855                format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
856                Box::new(e),
857            ));
858        }
859    }
860
861    debug!(sa_name, "deleting mail sender service account");
862    let start = tokio::time::Instant::now();
863    let delete_result = kanidm_client.idm_service_account_delete(&sa_name).await;
864    match delete_result {
865        Ok(()) => {
866            metrics.record_kanidm_sdk_outcome(
867                KANIDM_RESOURCE_MAIL_SENDER,
868                KANIDM_OP_DELETE,
869                KANIDM_OUTCOME_CHANGED,
870                start.elapsed(),
871            );
872            changed = true;
873        }
874        Err(e) if is_not_found_error(&e) => {
875            debug!(sa_name, "mail sender service account already absent");
876            metrics.record_kanidm_sdk_outcome(
877                KANIDM_RESOURCE_MAIL_SENDER,
878                KANIDM_OP_DELETE,
879                KANIDM_OUTCOME_UNCHANGED,
880                start.elapsed(),
881            );
882        }
883        Err(e) => {
884            metrics.record_kanidm_sdk_outcome(
885                KANIDM_RESOURCE_MAIL_SENDER,
886                KANIDM_OP_DELETE,
887                KANIDM_OUTCOME_ERROR,
888                start.elapsed(),
889            );
890            return Err(Error::KanidmClientError(
891                format!("failed to delete service account {sa_name}"),
892                Box::new(e),
893            ));
894        }
895    }
896
897    Ok(changed)
898}
899
900fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
901    match e {
902        kanidm_client::ClientError::Http(status, _, body) => {
903            status.as_u16() == 409
904                || body.contains("already exists")
905                || body.contains("conflicting_with")
906                || body.contains("AttributeUniqueness")
907        }
908        _ => false,
909    }
910}
911
912fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
913    match e {
914        ClientError::Http(status, operation_error, body) => {
915            status.as_u16() == 404
916                || operation_error == &Some(OperationError::NoMatchingEntries)
917                || body.contains("NoMatchingEntries")
918                || body.contains("not found")
919                || body.contains("does not exist")
920        }
921        _ => false,
922    }
923}
924
925fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
926    match e {
927        ClientError::Http(_, _, body) => body.contains("not a member"),
928        _ => false,
929    }
930}
931
932fn toml_basic_string(value: &str) -> String {
933    let mut output = String::with_capacity(value.len() + 2);
934    output.push('"');
935    for c in value.chars() {
936        match c {
937            '\u{08}' => output.push_str("\\b"),
938            '\t' => output.push_str("\\t"),
939            '\n' => output.push_str("\\n"),
940            '\u{0c}' => output.push_str("\\f"),
941            '\r' => output.push_str("\\r"),
942            '"' => output.push_str("\\\""),
943            '\\' => output.push_str("\\\\"),
944            c if c.is_control() => {
945                let code = c as u32;
946                if code <= 0xffff {
947                    output.push_str(&format!("\\u{code:04X}"));
948                } else {
949                    output.push_str(&format!("\\U{code:08X}"));
950                }
951            }
952            c => output.push(c),
953        }
954    }
955    output.push('"');
956    output
957}
958
959fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
960    BTreeMap::from([
961        (NAME_LABEL.to_string(), "kanidm".to_string()),
962        (
963            MANAGED_BY_LABEL.to_string(),
964            format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
965        ),
966        (INSTANCE_LABEL.to_string(), kanidm.name_any()),
967        (CLUSTER_LABEL.to_string(), kanidm.name_any()),
968    ])
969}
970
971fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
972    generate_mail_sender_labels(kanidm)
973        .into_iter()
974        .chain([
975            (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
976            (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
977        ])
978        .collect()
979}
980
981#[cfg(test)]
982mod tests {
983    use super::{
984        create_deployment, default_mail_sender_image, group_contains_member, toml_basic_string,
985    };
986    use crate::kanidm::crd::{Kanidm, MailSenderSpec};
987    use serde_json::json;
988
989    #[test]
990    fn digest_pinned_server_image_creates_pullable_mail_sender_deployment() {
991        // Use the exact tagged-and-digest-pinned input shape from issue #1110.
992        let kanidm: Kanidm = serde_json::from_value(json!({
993            "apiVersion": "kaniop.rs/v1beta1",
994            "kind": "Kanidm",
995            "metadata": {"name": "idm", "namespace": "default"},
996            "spec": {
997                "domain": "idm.example.com",
998                "image": "kanidm/server:1.11.2@sha256:deadbeef",
999                "replicaGroups": [{"name": "default", "replicas": 1}]
1000            }
1001        }))
1002        .unwrap();
1003        let mail_sender_spec: MailSenderSpec = serde_json::from_value(json!({
1004            "relay": "smtps://smtp.example.com",
1005            "credentialsSecret": {"name": "smtp-credentials"},
1006            "fromAddress": "kanidm@example.com"
1007        }))
1008        .unwrap();
1009
1010        let deployment = create_deployment(
1011            &kanidm,
1012            "idm-mail-sender",
1013            &mail_sender_spec,
1014            "idm-mail-sender-config",
1015        )
1016        .unwrap();
1017
1018        let image = deployment.spec.unwrap().template.spec.unwrap().containers[0]
1019            .image
1020            .clone();
1021        assert_eq!(image.as_deref(), Some("kanidm/tools:1.11.2"));
1022        assert!(!image.unwrap().contains("@sha256:"));
1023
1024        // An override is an exact image reference, including its own digest.
1025        // It must not be parsed, rewritten or constrained by the server image.
1026        let override_image = "mirror.example.org/custom/mail-sender:custom@sha256:abcdef";
1027        let mut overridden = mail_sender_spec;
1028        overridden.image = Some(override_image.to_string());
1029        let deployment = create_deployment(
1030            &kanidm,
1031            "idm-mail-sender",
1032            &overridden,
1033            "idm-mail-sender-config",
1034        )
1035        .unwrap();
1036        assert_eq!(
1037            deployment.spec.unwrap().template.spec.unwrap().containers[0]
1038                .image
1039                .as_deref(),
1040            Some(override_image),
1041        );
1042
1043        // Even a digest-only server image can be used with an explicit override.
1044        let mut digest_only_server = kanidm;
1045        digest_only_server.spec.image = "kanidm/server@sha256:deadbeef".to_string();
1046        let deployment = create_deployment(
1047            &digest_only_server,
1048            "idm-mail-sender",
1049            &overridden,
1050            "idm-mail-sender-config",
1051        )
1052        .unwrap();
1053        assert_eq!(
1054            deployment.spec.unwrap().template.spec.unwrap().containers[0]
1055                .image
1056                .as_deref(),
1057            Some(override_image),
1058        );
1059    }
1060
1061    #[test]
1062    fn default_mail_sender_image_uses_docker_hub_versioned_tools() {
1063        for (server, expected) in [
1064            ("kanidm/server:1.11.2", "kanidm/tools:1.11.2"),
1065            ("kanidm/server:latest", "kanidm/tools:latest"),
1066            ("kanidm/server", "kanidm/tools:latest"),
1067            (
1068                "kanidm/server:1.11.2@sha256:deadbeef",
1069                "kanidm/tools:1.11.2",
1070            ),
1071        ] {
1072            assert_eq!(default_mail_sender_image(server).unwrap(), expected);
1073        }
1074    }
1075
1076    #[test]
1077    fn digest_only_server_image_requires_explicit_mail_sender_image() {
1078        assert!(default_mail_sender_image("kanidm/server@sha256:deadbeef").is_err());
1079    }
1080
1081    #[test]
1082    fn toml_basic_string_escapes_config_values() {
1083        assert_eq!(
1084            toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
1085            r#""quoted \"value\" with \\ slash\nand tab\t""#
1086        );
1087    }
1088
1089    #[test]
1090    fn group_contains_member_matches_bare_name_against_spn() {
1091        let members = vec![
1092            "other-user".to_string(),
1093            "my-sa@idm.example.com".to_string(),
1094        ];
1095        assert!(group_contains_member(&members, "my-sa"));
1096    }
1097
1098    #[test]
1099    fn group_contains_member_is_case_insensitive() {
1100        let members = vec!["My-SA@idm.example.com".to_string()];
1101        assert!(group_contains_member(&members, "my-sa"));
1102    }
1103
1104    #[test]
1105    fn group_contains_member_returns_false_for_empty() {
1106        let members: Vec<String> = vec![];
1107        assert!(!group_contains_member(&members, "my-sa"));
1108    }
1109
1110    #[test]
1111    fn group_contains_member_returns_false_when_no_match() {
1112        let members = vec![
1113            "other-user".to_string(),
1114            "another-sa@idm.example.com".to_string(),
1115        ];
1116        assert!(!group_contains_member(&members, "my-sa"));
1117    }
1118}