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}