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!("0 */{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
581fn create_deployment(
582    kanidm: &Kanidm,
583    name: &str,
584    spec: &MailSenderSpec,
585    config_secret_name: &str,
586) -> Result<Deployment> {
587    debug!(name, "creating deployment");
588
589    let namespace = kanidm.namespace().unwrap();
590    let image = spec.image.clone().unwrap_or_else(|| {
591        let default_image = kanidm.spec.image.clone();
592        if default_image.contains("/server:") {
593            default_image.replace("/server:", "/tools:")
594        } else {
595            format!("{}-tools", default_image)
596        }
597    });
598
599    let extended_labels = generate_extended_mail_sender_labels(kanidm);
600
601    let container = Container {
602        name: MAIL_SENDER_COMPONENT.to_string(),
603        image: Some(image),
604        image_pull_policy: kanidm.spec.image_pull_policy.clone(),
605        command: Some(vec![
606            "/sbin/kanidm-mail-sender".to_string(),
607            "-c".to_string(),
608            format!("/data/config/{CLIENT_CONFIG_KEY}"),
609            "-m".to_string(),
610            format!("/data/config/{MAIL_CONFIG_KEY}"),
611        ]),
612        resources: spec.resources.clone(),
613        volume_mounts: Some(vec![VolumeMount {
614            name: "config".to_string(),
615            mount_path: "/data/config".to_string(),
616            read_only: Some(true),
617            ..Default::default()
618        }]),
619        ..Default::default()
620    };
621
622    let pod_spec = PodSpec {
623        containers: vec![container],
624        security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
625            PodSecurityContext {
626                run_as_non_root: Some(true),
627                run_as_user: Some(65534),
628                ..Default::default()
629            }
630        })),
631        volumes: Some(vec![Volume {
632            name: "config".to_string(),
633            secret: Some(SecretVolumeSource {
634                secret_name: Some(config_secret_name.to_string()),
635                items: Some(vec![
636                    KeyToPath {
637                        key: CLIENT_CONFIG_KEY.to_string(),
638                        path: CLIENT_CONFIG_KEY.to_string(),
639                        ..Default::default()
640                    },
641                    KeyToPath {
642                        key: MAIL_CONFIG_KEY.to_string(),
643                        path: MAIL_CONFIG_KEY.to_string(),
644                        ..Default::default()
645                    },
646                ]),
647                ..Default::default()
648            }),
649            ..Default::default()
650        }]),
651        node_selector: spec.node_selector.clone(),
652        affinity: spec.affinity.clone(),
653        tolerations: spec.tolerations.clone(),
654        automount_service_account_token: Some(false),
655        ..Default::default()
656    };
657
658    let pod_template = PodTemplateSpec {
659        metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
660            labels: Some(extended_labels.clone()),
661            ..Default::default()
662        }),
663        spec: Some(pod_spec),
664    };
665
666    Ok(Deployment {
667        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
668            name: Some(name.to_string()),
669            namespace: Some(namespace),
670            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
671            labels: Some(extended_labels.clone()),
672            ..Default::default()
673        },
674        spec: Some(DeploymentSpec {
675            replicas: Some(1),
676            selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
677                match_labels: Some(extended_labels),
678                ..Default::default()
679            },
680            template: pod_template,
681            strategy: Some(DeploymentStrategy {
682                type_: Some("Recreate".to_string()),
683                ..Default::default()
684            }),
685            ..Default::default()
686        }),
687        ..Default::default()
688    })
689}
690
691struct SmtpCredentials {
692    username: String,
693    password: String,
694}
695
696async fn read_smtp_credentials(
697    ctx: &Context,
698    spec: &MailSenderSpec,
699    namespace: &str,
700) -> Result<SmtpCredentials> {
701    let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
702    let secret = secret_api
703        .get(&spec.credentials_secret.name)
704        .await
705        .map_err(|e| {
706            Error::kube_error(
707                "get",
708                "SMTP credentials secret",
709                namespace,
710                &spec.credentials_secret.name,
711                e,
712            )
713        })?;
714
715    let username_key = &spec.credentials_secret.username_key;
716    let password_key = &spec.credentials_secret.password_key;
717
718    let get_string = |key: &str| -> Result<String> {
719        secret
720            .string_data
721            .as_ref()
722            .and_then(|d| d.get(key).cloned())
723            .or_else(|| {
724                secret
725                    .data
726                    .as_ref()
727                    .and_then(|d| d.get(key))
728                    .map(|v| String::from_utf8_lossy(&v.0).to_string())
729            })
730            .ok_or_else(|| {
731                Error::MissingData(format!(
732                    "SMTP credentials secret {} missing key {}",
733                    spec.credentials_secret.name, key
734                ))
735            })
736    };
737
738    Ok(SmtpCredentials {
739        username: get_string(username_key)?,
740        password: get_string(password_key)?,
741    })
742}
743
744pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<bool> {
745    let namespace = kanidm.namespace().unwrap();
746    let kanidm_name = kanidm.name_any();
747    let mut changed = false;
748
749    let deployment_name = mail_sender_deployment_name(&kanidm_name);
750    let config_secret_name = mail_sender_config_map_name(&kanidm_name);
751
752    let deployment_api: Api<Deployment> =
753        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
754    let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
755        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
756
757    let dp = DeleteParams::default();
758
759    match deployment_api.delete(&deployment_name, &dp).await {
760        Ok(_) => {
761            changed = true;
762        }
763        Err(kube::Error::Api(e)) if e.code == 404 => {
764            debug!(deployment_name, "mail sender deployment already absent");
765        }
766        Err(e) => {
767            return Err(Error::kube_error(
768                "delete",
769                "deployment",
770                &namespace,
771                &deployment_name,
772                e,
773            ));
774        }
775    }
776
777    match secret_api.delete(&config_secret_name, &dp).await {
778        Ok(_) => {
779            changed = true;
780        }
781        Err(kube::Error::Api(e)) if e.code == 404 => {
782            debug!(
783                config_secret_name,
784                "mail sender config secret already absent"
785            );
786        }
787        Err(e) => {
788            return Err(Error::kube_error(
789                "delete",
790                "secret",
791                &namespace,
792                &config_secret_name,
793                e,
794            ));
795        }
796    }
797
798    Ok(changed)
799}
800
801pub async fn cleanup_mail_sender_in_kanidm(
802    kanidm_client: &KanidmClient,
803    kanidm_name: &str,
804    metrics: &crate::metrics::ControllerMetrics,
805) -> Result<bool> {
806    let sa_name = mail_sender_service_account_name(kanidm_name);
807    let mut changed = false;
808
809    debug!(sa_name, "removing mail sender from message_senders group");
810    let start = tokio::time::Instant::now();
811    let remove_result = kanidm_client
812        .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
813        .await;
814    match remove_result {
815        Ok(()) => {
816            metrics.record_kanidm_sdk_outcome(
817                KANIDM_RESOURCE_MAIL_SENDER,
818                KANIDM_OP_REMOVE_MEMBERS,
819                KANIDM_OUTCOME_CHANGED,
820                start.elapsed(),
821            );
822            changed = true;
823        }
824        Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
825            debug!(sa_name, "mail sender group membership already absent");
826            metrics.record_kanidm_sdk_outcome(
827                KANIDM_RESOURCE_MAIL_SENDER,
828                KANIDM_OP_REMOVE_MEMBERS,
829                KANIDM_OUTCOME_UNCHANGED,
830                start.elapsed(),
831            );
832        }
833        Err(e) => {
834            metrics.record_kanidm_sdk_outcome(
835                KANIDM_RESOURCE_MAIL_SENDER,
836                KANIDM_OP_REMOVE_MEMBERS,
837                KANIDM_OUTCOME_ERROR,
838                start.elapsed(),
839            );
840            return Err(Error::KanidmClientError(
841                format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
842                Box::new(e),
843            ));
844        }
845    }
846
847    debug!(sa_name, "deleting mail sender service account");
848    let start = tokio::time::Instant::now();
849    let delete_result = kanidm_client.idm_service_account_delete(&sa_name).await;
850    match delete_result {
851        Ok(()) => {
852            metrics.record_kanidm_sdk_outcome(
853                KANIDM_RESOURCE_MAIL_SENDER,
854                KANIDM_OP_DELETE,
855                KANIDM_OUTCOME_CHANGED,
856                start.elapsed(),
857            );
858            changed = true;
859        }
860        Err(e) if is_not_found_error(&e) => {
861            debug!(sa_name, "mail sender service account already absent");
862            metrics.record_kanidm_sdk_outcome(
863                KANIDM_RESOURCE_MAIL_SENDER,
864                KANIDM_OP_DELETE,
865                KANIDM_OUTCOME_UNCHANGED,
866                start.elapsed(),
867            );
868        }
869        Err(e) => {
870            metrics.record_kanidm_sdk_outcome(
871                KANIDM_RESOURCE_MAIL_SENDER,
872                KANIDM_OP_DELETE,
873                KANIDM_OUTCOME_ERROR,
874                start.elapsed(),
875            );
876            return Err(Error::KanidmClientError(
877                format!("failed to delete service account {sa_name}"),
878                Box::new(e),
879            ));
880        }
881    }
882
883    Ok(changed)
884}
885
886fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
887    match e {
888        kanidm_client::ClientError::Http(status, _, body) => {
889            status.as_u16() == 409
890                || body.contains("already exists")
891                || body.contains("conflicting_with")
892                || body.contains("AttributeUniqueness")
893        }
894        _ => false,
895    }
896}
897
898fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
899    match e {
900        ClientError::Http(status, operation_error, body) => {
901            status.as_u16() == 404
902                || operation_error == &Some(OperationError::NoMatchingEntries)
903                || body.contains("NoMatchingEntries")
904                || body.contains("not found")
905                || body.contains("does not exist")
906        }
907        _ => false,
908    }
909}
910
911fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
912    match e {
913        ClientError::Http(_, _, body) => body.contains("not a member"),
914        _ => false,
915    }
916}
917
918fn toml_basic_string(value: &str) -> String {
919    let mut output = String::with_capacity(value.len() + 2);
920    output.push('"');
921    for c in value.chars() {
922        match c {
923            '\u{08}' => output.push_str("\\b"),
924            '\t' => output.push_str("\\t"),
925            '\n' => output.push_str("\\n"),
926            '\u{0c}' => output.push_str("\\f"),
927            '\r' => output.push_str("\\r"),
928            '"' => output.push_str("\\\""),
929            '\\' => output.push_str("\\\\"),
930            c if c.is_control() => {
931                let code = c as u32;
932                if code <= 0xffff {
933                    output.push_str(&format!("\\u{code:04X}"));
934                } else {
935                    output.push_str(&format!("\\U{code:08X}"));
936                }
937            }
938            c => output.push(c),
939        }
940    }
941    output.push('"');
942    output
943}
944
945fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
946    BTreeMap::from([
947        (NAME_LABEL.to_string(), "kanidm".to_string()),
948        (
949            MANAGED_BY_LABEL.to_string(),
950            format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
951        ),
952        (INSTANCE_LABEL.to_string(), kanidm.name_any()),
953        (CLUSTER_LABEL.to_string(), kanidm.name_any()),
954    ])
955}
956
957fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
958    generate_mail_sender_labels(kanidm)
959        .into_iter()
960        .chain([
961            (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
962            (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
963        ])
964        .collect()
965}
966
967#[cfg(test)]
968mod tests {
969    use super::{group_contains_member, toml_basic_string};
970
971    #[test]
972    fn toml_basic_string_escapes_config_values() {
973        assert_eq!(
974            toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
975            r#""quoted \"value\" with \\ slash\nand tab\t""#
976        );
977    }
978
979    #[test]
980    fn group_contains_member_matches_bare_name_against_spn() {
981        let members = vec![
982            "other-user".to_string(),
983            "my-sa@idm.example.com".to_string(),
984        ];
985        assert!(group_contains_member(&members, "my-sa"));
986    }
987
988    #[test]
989    fn group_contains_member_is_case_insensitive() {
990        let members = vec!["My-SA@idm.example.com".to_string()];
991        assert!(group_contains_member(&members, "my-sa"));
992    }
993
994    #[test]
995    fn group_contains_member_returns_false_for_empty() {
996        let members: Vec<String> = vec![];
997        assert!(!group_contains_member(&members, "my-sa"));
998    }
999
1000    #[test]
1001    fn group_contains_member_returns_false_when_no_match() {
1002        let members = vec![
1003            "other-user".to_string(),
1004            "another-sa@idm.example.com".to_string(),
1005        ];
1006        assert!(!group_contains_member(&members, "my-sa"));
1007    }
1008}