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