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