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