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!(namespace, kanidm_name, "reconciling mail sender");
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            namespace,
149            kanidm_name, "mail sender not enabled, cleaning up resources"
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!(name, "ensuring mail sender service account exists");
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!(name, "service account already exists, updating");
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!(name, "adding mail sender to message_senders group");
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!(name, "service account already in group");
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!(name, current_token_id = ?current_token_id, "ensuring mail sender API token exists");
285
286    let start = tokio::time::Instant::now();
287    let existing_tokens_result = kanidm_client.idm_service_account_list_api_token(name).await;
288    let existing_tokens = match existing_tokens_result {
289        Ok(tokens) => {
290            metrics.record_kanidm_sdk_outcome(
291                KANIDM_RESOURCE_MAIL_SENDER,
292                KANIDM_OP_LIST_API_TOKENS,
293                KANIDM_OUTCOME_UNCHANGED,
294                start.elapsed(),
295            );
296            tokens
297        }
298        Err(ClientError::Http(status, _, _)) if status == 404 => {
299            metrics.record_kanidm_sdk_outcome(
300                KANIDM_RESOURCE_MAIL_SENDER,
301                KANIDM_OP_LIST_API_TOKENS,
302                KANIDM_OUTCOME_UNCHANGED,
303                start.elapsed(),
304            );
305            vec![]
306        }
307        Err(e) => {
308            metrics.record_kanidm_sdk_outcome(
309                KANIDM_RESOURCE_MAIL_SENDER,
310                KANIDM_OP_LIST_API_TOKENS,
311                KANIDM_OUTCOME_ERROR,
312                start.elapsed(),
313            );
314            return Err(Error::KanidmClientError(
315                format!("failed to list API tokens for {name}"),
316                Box::new(e),
317            ));
318        }
319    };
320
321    let existing_mail_sender_tokens: Vec<_> = existing_tokens
322        .iter()
323        .filter(|t| t.label == MAIL_SENDER_COMPONENT)
324        .collect();
325
326    if let Some(token) = existing_mail_sender_tokens.first() {
327        if current_token_id.as_ref() == Some(&token.token_id.to_string()) {
328            debug!(name, token_id = %token.token_id, "mail sender token already exists with matching token_id, reading from existing secret");
329            if let Some(existing_token_value) =
330                read_token_from_config_secret(ctx, namespace, config_secret_name).await?
331            {
332                return Ok((existing_token_value, token.token_id.to_string(), false));
333            }
334            debug!(name, token_id = %token.token_id, "existing token value not found in secret, destroying all tokens and regenerating");
335        } else {
336            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");
337        }
338
339        for token in existing_mail_sender_tokens {
340            record_kanidm_sdk_call(
341                metrics,
342                KANIDM_RESOURCE_MAIL_SENDER,
343                KANIDM_OP_DESTROY_API_TOKEN,
344                KANIDM_OUTCOME_CHANGED,
345                kanidm_client.idm_service_account_destroy_api_token(name, token.token_id),
346            )
347            .await
348            .map_err(|e| {
349                Error::KanidmClientError(
350                    format!("failed to destroy API token {} for {name}", token.token_id),
351                    Box::new(e),
352                )
353            })?;
354        }
355    }
356
357    debug!(name, "generating new read-write API token for mail sender");
358
359    let token_value = record_kanidm_sdk_call(
360        metrics,
361        KANIDM_RESOURCE_MAIL_SENDER,
362        KANIDM_OP_GENERATE_API_TOKEN,
363        KANIDM_OUTCOME_CHANGED,
364        kanidm_client.idm_service_account_generate_api_token(
365            name,
366            MAIL_SENDER_COMPONENT,
367            None,
368            true,
369            false,
370        ),
371    )
372    .await
373    .map_err(|e| {
374        Error::KanidmClientError(
375            format!("failed to generate API token for {name}"),
376            Box::new(e),
377        )
378    })?;
379
380    let new_tokens = record_kanidm_sdk_call(
381        metrics,
382        KANIDM_RESOURCE_MAIL_SENDER,
383        KANIDM_OP_LIST_API_TOKENS,
384        KANIDM_OUTCOME_UNCHANGED,
385        kanidm_client.idm_service_account_list_api_token(name),
386    )
387    .await
388    .map_err(|e| {
389        Error::KanidmClientError(
390            format!("failed to list API tokens for {name} after generation"),
391            Box::new(e),
392        )
393    })?;
394
395    let new_token = new_tokens
396        .iter()
397        .find(|t| t.label == MAIL_SENDER_COMPONENT)
398        .ok_or_else(|| {
399            Error::MissingData(format!(
400                "generated token with label {MAIL_SENDER_COMPONENT} not found for {name}"
401            ))
402        })?;
403
404    Ok((token_value, new_token.token_id.to_string(), true))
405}
406
407async fn read_token_from_config_secret(
408    ctx: &Context,
409    namespace: &str,
410    name: &str,
411) -> Result<Option<String>> {
412    let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
413    let secret = match secret_api.get(name).await {
414        Ok(s) => s,
415        Err(kube::Error::Api(e)) if e.code == 404 => {
416            debug!(
417                name,
418                "mail sender config secret not found, will regenerate token"
419            );
420            return Ok(None);
421        }
422        Err(e) => {
423            return Err(Error::kube_error(
424                "get",
425                "mail sender config secret",
426                namespace,
427                name,
428                e,
429            ));
430        }
431    };
432
433    let mail_config = secret
434        .string_data
435        .as_ref()
436        .and_then(|d| d.get(MAIL_CONFIG_KEY).cloned())
437        .or_else(|| {
438            secret
439                .data
440                .as_ref()
441                .and_then(|d| d.get(MAIL_CONFIG_KEY))
442                .map(|v| String::from_utf8_lossy(&v.0).to_string())
443        });
444
445    match mail_config {
446        Some(config) => {
447            let token = config
448                .lines()
449                .find(|line| line.starts_with("token = "))
450                .and_then(|line| line.strip_prefix("token = "))
451                .and_then(|value| value.strip_prefix('"').and_then(|v| v.strip_suffix('"')))
452                .map(|s| s.to_string());
453            Ok(token)
454        }
455        None => {
456            debug!(
457                name,
458                "mail sender config secret missing mail-sender.toml key, will regenerate token"
459            );
460            Ok(None)
461        }
462    }
463}
464
465fn create_config_secret(
466    kanidm: &Kanidm,
467    name: &str,
468    spec: &MailSenderSpec,
469    token: &str,
470    smtp_credentials: &SmtpCredentials,
471) -> Result<Secret> {
472    debug!(name, "creating config secret");
473
474    let domain = &kanidm.spec.domain;
475    let default_origin = format!("https://{domain}");
476    let origin = kanidm.spec.origin.as_ref().unwrap_or(&default_origin);
477    let default_display_name = format!("Kanidm {domain}");
478    let display_name = kanidm
479        .spec
480        .domain_appearance
481        .as_ref()
482        .and_then(|da| da.display_name.as_ref())
483        .unwrap_or(&default_display_name);
484    let poll_interval = spec
485        .queue_poll_interval_seconds
486        .unwrap_or(DEFAULT_QUEUE_POLL_INTERVAL);
487    let connect_timeout = spec
488        .connect_timeout_seconds
489        .unwrap_or(DEFAULT_CONNECT_TIMEOUT);
490
491    let client_config = format!("uri = {}", toml_basic_string(origin));
492
493    let reply_to = spec
494        .reply_to_address
495        .as_deref()
496        .unwrap_or(&spec.from_address);
497
498    let token = toml_basic_string(token);
499    let display_name = toml_basic_string(display_name);
500    let origin = toml_basic_string(origin);
501    let from_address = toml_basic_string(&spec.from_address);
502    let reply_to = toml_basic_string(reply_to);
503    let relay_host = toml_basic_string(&spec.relay);
504    let username = toml_basic_string(&smtp_credentials.username);
505    let password = toml_basic_string(&smtp_credentials.password);
506    let schedule = toml_basic_string(&format!("0 */{poll_interval} * * * * *"));
507
508    let mail_config = format!(
509        r#"token = {token}
510instance_display_name = {display_name}
511instance_url = {origin}
512mail_from_address = {from_address}
513mail_reply_to_address = {reply_to}
514mail_relay = {relay_host}
515mail_username = {username}
516mail_password = {password}
517mail_connect_timeout_seconds = {connect_timeout}
518schedule = {schedule}
519"#
520    );
521
522    let extended_labels = generate_extended_mail_sender_labels(kanidm);
523
524    Ok(Secret {
525        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
526            name: Some(name.to_string()),
527            namespace: Some(kanidm.namespace().unwrap()),
528            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
529            labels: Some(extended_labels),
530            ..Default::default()
531        },
532        string_data: Some(BTreeMap::from([
533            (CLIENT_CONFIG_KEY.to_string(), client_config),
534            (MAIL_CONFIG_KEY.to_string(), mail_config),
535        ])),
536        type_: Some("Opaque".to_string()),
537        ..Default::default()
538    })
539}
540
541fn create_deployment(
542    kanidm: &Kanidm,
543    name: &str,
544    spec: &MailSenderSpec,
545    config_secret_name: &str,
546) -> Result<Deployment> {
547    debug!(name, "creating deployment");
548
549    let namespace = kanidm.namespace().unwrap();
550    let image = spec.image.clone().unwrap_or_else(|| {
551        let default_image = kanidm.spec.image.clone();
552        if default_image.contains("/server:") {
553            default_image.replace("/server:", "/tools:")
554        } else {
555            format!("{}-tools", default_image)
556        }
557    });
558
559    let extended_labels = generate_extended_mail_sender_labels(kanidm);
560
561    let container = Container {
562        name: MAIL_SENDER_COMPONENT.to_string(),
563        image: Some(image),
564        image_pull_policy: kanidm.spec.image_pull_policy.clone(),
565        command: Some(vec![
566            "/sbin/kanidm-mail-sender".to_string(),
567            "-c".to_string(),
568            format!("/data/config/{CLIENT_CONFIG_KEY}"),
569            "-m".to_string(),
570            format!("/data/config/{MAIL_CONFIG_KEY}"),
571        ]),
572        resources: spec.resources.clone(),
573        volume_mounts: Some(vec![VolumeMount {
574            name: "config".to_string(),
575            mount_path: "/data/config".to_string(),
576            read_only: Some(true),
577            ..Default::default()
578        }]),
579        ..Default::default()
580    };
581
582    let pod_spec = PodSpec {
583        containers: vec![container],
584        security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
585            PodSecurityContext {
586                run_as_non_root: Some(true),
587                run_as_user: Some(65534),
588                ..Default::default()
589            }
590        })),
591        volumes: Some(vec![Volume {
592            name: "config".to_string(),
593            secret: Some(SecretVolumeSource {
594                secret_name: Some(config_secret_name.to_string()),
595                items: Some(vec![
596                    KeyToPath {
597                        key: CLIENT_CONFIG_KEY.to_string(),
598                        path: CLIENT_CONFIG_KEY.to_string(),
599                        ..Default::default()
600                    },
601                    KeyToPath {
602                        key: MAIL_CONFIG_KEY.to_string(),
603                        path: MAIL_CONFIG_KEY.to_string(),
604                        ..Default::default()
605                    },
606                ]),
607                ..Default::default()
608            }),
609            ..Default::default()
610        }]),
611        node_selector: spec.node_selector.clone(),
612        affinity: spec.affinity.clone(),
613        tolerations: spec.tolerations.clone(),
614        automount_service_account_token: Some(false),
615        ..Default::default()
616    };
617
618    let pod_template = PodTemplateSpec {
619        metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
620            labels: Some(extended_labels.clone()),
621            ..Default::default()
622        }),
623        spec: Some(pod_spec),
624    };
625
626    Ok(Deployment {
627        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
628            name: Some(name.to_string()),
629            namespace: Some(namespace),
630            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
631            labels: Some(extended_labels.clone()),
632            ..Default::default()
633        },
634        spec: Some(DeploymentSpec {
635            replicas: Some(1),
636            selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
637                match_labels: Some(extended_labels),
638                ..Default::default()
639            },
640            template: pod_template,
641            strategy: Some(DeploymentStrategy {
642                type_: Some("Recreate".to_string()),
643                ..Default::default()
644            }),
645            ..Default::default()
646        }),
647        ..Default::default()
648    })
649}
650
651struct SmtpCredentials {
652    username: String,
653    password: String,
654}
655
656async fn read_smtp_credentials(
657    ctx: &Context,
658    spec: &MailSenderSpec,
659    namespace: &str,
660) -> Result<SmtpCredentials> {
661    let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
662    let secret = secret_api
663        .get(&spec.credentials_secret.name)
664        .await
665        .map_err(|e| {
666            Error::kube_error(
667                "get",
668                "SMTP credentials secret",
669                namespace,
670                &spec.credentials_secret.name,
671                e,
672            )
673        })?;
674
675    let username_key = &spec.credentials_secret.username_key;
676    let password_key = &spec.credentials_secret.password_key;
677
678    let get_string = |key: &str| -> Result<String> {
679        secret
680            .string_data
681            .as_ref()
682            .and_then(|d| d.get(key).cloned())
683            .or_else(|| {
684                secret
685                    .data
686                    .as_ref()
687                    .and_then(|d| d.get(key))
688                    .map(|v| String::from_utf8_lossy(&v.0).to_string())
689            })
690            .ok_or_else(|| {
691                Error::MissingData(format!(
692                    "SMTP credentials secret {} missing key {}",
693                    spec.credentials_secret.name, key
694                ))
695            })
696    };
697
698    Ok(SmtpCredentials {
699        username: get_string(username_key)?,
700        password: get_string(password_key)?,
701    })
702}
703
704pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<bool> {
705    let namespace = kanidm.namespace().unwrap();
706    let kanidm_name = kanidm.name_any();
707    let mut changed = false;
708
709    let deployment_name = mail_sender_deployment_name(&kanidm_name);
710    let config_secret_name = mail_sender_config_map_name(&kanidm_name);
711
712    let deployment_api: Api<Deployment> =
713        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
714    let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
715        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
716
717    let dp = DeleteParams::default();
718
719    match deployment_api.delete(&deployment_name, &dp).await {
720        Ok(_) => {
721            changed = true;
722        }
723        Err(kube::Error::Api(e)) if e.code == 404 => {
724            debug!(deployment_name, "mail sender deployment already absent");
725        }
726        Err(e) => {
727            return Err(Error::kube_error(
728                "delete",
729                "deployment",
730                &namespace,
731                &deployment_name,
732                e,
733            ));
734        }
735    }
736
737    match secret_api.delete(&config_secret_name, &dp).await {
738        Ok(_) => {
739            changed = true;
740        }
741        Err(kube::Error::Api(e)) if e.code == 404 => {
742            debug!(
743                config_secret_name,
744                "mail sender config secret already absent"
745            );
746        }
747        Err(e) => {
748            return Err(Error::kube_error(
749                "delete",
750                "secret",
751                &namespace,
752                &config_secret_name,
753                e,
754            ));
755        }
756    }
757
758    Ok(changed)
759}
760
761pub async fn cleanup_mail_sender_in_kanidm(
762    kanidm_client: &KanidmClient,
763    kanidm_name: &str,
764    metrics: &crate::metrics::ControllerMetrics,
765) -> Result<bool> {
766    let sa_name = mail_sender_service_account_name(kanidm_name);
767    let mut changed = false;
768
769    debug!(sa_name, "removing mail sender from message_senders group");
770    let start = tokio::time::Instant::now();
771    let remove_result = kanidm_client
772        .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
773        .await;
774    match remove_result {
775        Ok(()) => {
776            metrics.record_kanidm_sdk_outcome(
777                KANIDM_RESOURCE_MAIL_SENDER,
778                KANIDM_OP_REMOVE_MEMBERS,
779                KANIDM_OUTCOME_CHANGED,
780                start.elapsed(),
781            );
782            changed = true;
783        }
784        Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
785            debug!(sa_name, "mail sender group membership already absent");
786            metrics.record_kanidm_sdk_outcome(
787                KANIDM_RESOURCE_MAIL_SENDER,
788                KANIDM_OP_REMOVE_MEMBERS,
789                KANIDM_OUTCOME_UNCHANGED,
790                start.elapsed(),
791            );
792        }
793        Err(e) => {
794            metrics.record_kanidm_sdk_outcome(
795                KANIDM_RESOURCE_MAIL_SENDER,
796                KANIDM_OP_REMOVE_MEMBERS,
797                KANIDM_OUTCOME_ERROR,
798                start.elapsed(),
799            );
800            return Err(Error::KanidmClientError(
801                format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
802                Box::new(e),
803            ));
804        }
805    }
806
807    debug!(sa_name, "deleting mail sender service account");
808    let start = tokio::time::Instant::now();
809    let delete_result = kanidm_client.idm_service_account_delete(&sa_name).await;
810    match delete_result {
811        Ok(()) => {
812            metrics.record_kanidm_sdk_outcome(
813                KANIDM_RESOURCE_MAIL_SENDER,
814                KANIDM_OP_DELETE,
815                KANIDM_OUTCOME_CHANGED,
816                start.elapsed(),
817            );
818            changed = true;
819        }
820        Err(e) if is_not_found_error(&e) => {
821            debug!(sa_name, "mail sender service account already absent");
822            metrics.record_kanidm_sdk_outcome(
823                KANIDM_RESOURCE_MAIL_SENDER,
824                KANIDM_OP_DELETE,
825                KANIDM_OUTCOME_UNCHANGED,
826                start.elapsed(),
827            );
828        }
829        Err(e) => {
830            metrics.record_kanidm_sdk_outcome(
831                KANIDM_RESOURCE_MAIL_SENDER,
832                KANIDM_OP_DELETE,
833                KANIDM_OUTCOME_ERROR,
834                start.elapsed(),
835            );
836            return Err(Error::KanidmClientError(
837                format!("failed to delete service account {sa_name}"),
838                Box::new(e),
839            ));
840        }
841    }
842
843    Ok(changed)
844}
845
846fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
847    match e {
848        kanidm_client::ClientError::Http(status, _, body) => {
849            status.as_u16() == 409
850                || body.contains("already exists")
851                || body.contains("conflicting_with")
852                || body.contains("AttributeUniqueness")
853        }
854        _ => false,
855    }
856}
857
858fn is_already_member_error(e: &kanidm_client::ClientError) -> bool {
859    match e {
860        kanidm_client::ClientError::Http(_, _, body) => body.contains("already a member"),
861        _ => false,
862    }
863}
864
865fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
866    match e {
867        ClientError::Http(status, operation_error, body) => {
868            status.as_u16() == 404
869                || operation_error == &Some(OperationError::NoMatchingEntries)
870                || body.contains("NoMatchingEntries")
871                || body.contains("not found")
872                || body.contains("does not exist")
873        }
874        _ => false,
875    }
876}
877
878fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
879    match e {
880        ClientError::Http(_, _, body) => body.contains("not a member"),
881        _ => false,
882    }
883}
884
885fn toml_basic_string(value: &str) -> String {
886    let mut output = String::with_capacity(value.len() + 2);
887    output.push('"');
888    for c in value.chars() {
889        match c {
890            '\u{08}' => output.push_str("\\b"),
891            '\t' => output.push_str("\\t"),
892            '\n' => output.push_str("\\n"),
893            '\u{0c}' => output.push_str("\\f"),
894            '\r' => output.push_str("\\r"),
895            '"' => output.push_str("\\\""),
896            '\\' => output.push_str("\\\\"),
897            c if c.is_control() => {
898                let code = c as u32;
899                if code <= 0xffff {
900                    output.push_str(&format!("\\u{code:04X}"));
901                } else {
902                    output.push_str(&format!("\\U{code:08X}"));
903                }
904            }
905            c => output.push(c),
906        }
907    }
908    output.push('"');
909    output
910}
911
912fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
913    BTreeMap::from([
914        (NAME_LABEL.to_string(), "kanidm".to_string()),
915        (
916            MANAGED_BY_LABEL.to_string(),
917            format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
918        ),
919        (INSTANCE_LABEL.to_string(), kanidm.name_any()),
920        (CLUSTER_LABEL.to_string(), kanidm.name_any()),
921    ])
922}
923
924fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
925    generate_mail_sender_labels(kanidm)
926        .into_iter()
927        .chain([
928            (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
929            (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
930        ])
931        .collect()
932}
933
934#[cfg(test)]
935mod tests {
936    use super::toml_basic_string;
937
938    #[test]
939    fn toml_basic_string_escapes_config_values() {
940        assert_eq!(
941            toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
942            r#""quoted \"value\" with \\ slash\nand tab\t""#
943        );
944    }
945}