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_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 owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
420 labels: Some(extended_labels),
421 ..Default::default()
422 },
423 string_data: Some(BTreeMap::from([
424 (CLIENT_CONFIG_KEY.to_string(), client_config),
425 (MAIL_CONFIG_KEY.to_string(), mail_config),
426 ])),
427 type_: Some("Opaque".to_string()),
428 ..Default::default()
429 })
430}
431
432fn create_deployment(
433 kanidm: &Kanidm,
434 name: &str,
435 spec: &MailSenderSpec,
436 config_secret_name: &str,
437) -> Result<Deployment> {
438 debug!(msg = "creating deployment", name);
439
440 let namespace = kanidm.namespace().unwrap();
441 let image = spec.image.clone().unwrap_or_else(|| {
442 let default_image = kanidm.spec.image.clone();
443 if default_image.contains("/server:") {
444 default_image.replace("/server:", "/tools:")
445 } else {
446 format!("{}-tools", default_image)
447 }
448 });
449
450 let extended_labels = generate_extended_mail_sender_labels(kanidm);
451
452 let container = Container {
453 name: MAIL_SENDER_COMPONENT.to_string(),
454 image: Some(image),
455 image_pull_policy: kanidm.spec.image_pull_policy.clone(),
456 command: Some(vec![
457 "/sbin/kanidm-mail-sender".to_string(),
458 "-c".to_string(),
459 format!("/data/config/{CLIENT_CONFIG_KEY}"),
460 "-m".to_string(),
461 format!("/data/config/{MAIL_CONFIG_KEY}"),
462 ]),
463 resources: spec.resources.clone(),
464 volume_mounts: Some(vec![VolumeMount {
465 name: "config".to_string(),
466 mount_path: "/data/config".to_string(),
467 read_only: Some(true),
468 ..Default::default()
469 }]),
470 ..Default::default()
471 };
472
473 let pod_spec = PodSpec {
474 containers: vec![container],
475 security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
476 PodSecurityContext {
477 run_as_non_root: Some(true),
478 run_as_user: Some(65534),
479 ..Default::default()
480 }
481 })),
482 volumes: Some(vec![Volume {
483 name: "config".to_string(),
484 secret: Some(SecretVolumeSource {
485 secret_name: Some(config_secret_name.to_string()),
486 items: Some(vec![
487 KeyToPath {
488 key: CLIENT_CONFIG_KEY.to_string(),
489 path: CLIENT_CONFIG_KEY.to_string(),
490 ..Default::default()
491 },
492 KeyToPath {
493 key: MAIL_CONFIG_KEY.to_string(),
494 path: MAIL_CONFIG_KEY.to_string(),
495 ..Default::default()
496 },
497 ]),
498 ..Default::default()
499 }),
500 ..Default::default()
501 }]),
502 node_selector: spec.node_selector.clone(),
503 affinity: spec.affinity.clone(),
504 tolerations: spec.tolerations.clone(),
505 automount_service_account_token: Some(false),
506 ..Default::default()
507 };
508
509 let pod_template = PodTemplateSpec {
510 metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
511 labels: Some(extended_labels.clone()),
512 ..Default::default()
513 }),
514 spec: Some(pod_spec),
515 };
516
517 Ok(Deployment {
518 metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
519 name: Some(name.to_string()),
520 namespace: Some(namespace),
521 owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
522 labels: Some(extended_labels.clone()),
523 ..Default::default()
524 },
525 spec: Some(DeploymentSpec {
526 replicas: Some(1),
527 selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
528 match_labels: Some(extended_labels),
529 ..Default::default()
530 },
531 template: pod_template,
532 strategy: Some(DeploymentStrategy {
533 type_: Some("Recreate".to_string()),
534 ..Default::default()
535 }),
536 ..Default::default()
537 }),
538 ..Default::default()
539 })
540}
541
542struct SmtpCredentials {
543 username: String,
544 password: String,
545}
546
547async fn read_smtp_credentials(
548 ctx: &Context,
549 spec: &MailSenderSpec,
550 namespace: &str,
551) -> Result<SmtpCredentials> {
552 let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
553 let secret = secret_api
554 .get(&spec.credentials_secret.name)
555 .await
556 .map_err(|e| {
557 Error::kube_error(
558 "get",
559 "SMTP credentials secret",
560 namespace,
561 &spec.credentials_secret.name,
562 e,
563 )
564 })?;
565
566 let username_key = &spec.credentials_secret.username_key;
567 let password_key = &spec.credentials_secret.password_key;
568
569 let get_string = |key: &str| -> Result<String> {
570 secret
571 .string_data
572 .as_ref()
573 .and_then(|d| d.get(key).cloned())
574 .or_else(|| {
575 secret
576 .data
577 .as_ref()
578 .and_then(|d| d.get(key))
579 .map(|v| String::from_utf8_lossy(&v.0).to_string())
580 })
581 .ok_or_else(|| {
582 Error::MissingData(format!(
583 "SMTP credentials secret {} missing key {}",
584 spec.credentials_secret.name, key
585 ))
586 })
587 };
588
589 Ok(SmtpCredentials {
590 username: get_string(username_key)?,
591 password: get_string(password_key)?,
592 })
593}
594
595pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<()> {
596 let namespace = kanidm.namespace().unwrap();
597 let kanidm_name = kanidm.name_any();
598
599 let deployment_name = mail_sender_deployment_name(&kanidm_name);
600 let config_secret_name = mail_sender_config_map_name(&kanidm_name);
601
602 let deployment_api: Api<Deployment> =
603 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
604 let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
605 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
606
607 let dp = DeleteParams::default();
608
609 match deployment_api.delete(&deployment_name, &dp).await {
610 Ok(_) => {}
611 Err(kube::Error::Api(e)) if e.code == 404 => {
612 debug!(
613 msg = "mail sender deployment already absent",
614 deployment_name
615 );
616 }
617 Err(e) => {
618 return Err(Error::kube_error(
619 "delete",
620 "deployment",
621 &namespace,
622 &deployment_name,
623 e,
624 ));
625 }
626 }
627
628 match secret_api.delete(&config_secret_name, &dp).await {
629 Ok(_) => {}
630 Err(kube::Error::Api(e)) if e.code == 404 => {
631 debug!(
632 msg = "mail sender config secret already absent",
633 config_secret_name
634 );
635 }
636 Err(e) => {
637 return Err(Error::kube_error(
638 "delete",
639 "secret",
640 &namespace,
641 &config_secret_name,
642 e,
643 ));
644 }
645 }
646
647 Ok(())
648}
649
650pub async fn cleanup_mail_sender_in_kanidm(
651 kanidm_client: &KanidmClient,
652 kanidm_name: &str,
653) -> Result<()> {
654 let sa_name = mail_sender_service_account_name(kanidm_name);
655
656 debug!(
657 msg = "removing mail sender from message_senders group",
658 sa_name
659 );
660 match kanidm_client
661 .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
662 .await
663 {
664 Ok(()) => {}
665 Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
666 debug!(msg = "mail sender group membership already absent", sa_name);
667 }
668 Err(e) => {
669 return Err(Error::KanidmClientError(
670 format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
671 Box::new(e),
672 ));
673 }
674 }
675
676 debug!(msg = "deleting mail sender service account", sa_name);
677 match kanidm_client.idm_service_account_delete(&sa_name).await {
678 Ok(()) => {}
679 Err(e) if is_not_found_error(&e) => {
680 debug!(msg = "mail sender service account already absent", sa_name);
681 }
682 Err(e) => {
683 return Err(Error::KanidmClientError(
684 format!("failed to delete service account {sa_name}"),
685 Box::new(e),
686 ));
687 }
688 }
689
690 Ok(())
691}
692
693fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
694 match e {
695 kanidm_client::ClientError::Http(status, _, body) => {
696 status.as_u16() == 409
697 || body.contains("already exists")
698 || body.contains("conflicting_with")
699 || body.contains("AttributeUniqueness")
700 }
701 _ => false,
702 }
703}
704
705fn is_already_member_error(e: &kanidm_client::ClientError) -> bool {
706 match e {
707 kanidm_client::ClientError::Http(_, _, body) => body.contains("already a member"),
708 _ => false,
709 }
710}
711
712fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
713 match e {
714 ClientError::Http(status, operation_error, body) => {
715 status.as_u16() == 404
716 || operation_error == &Some(OperationError::NoMatchingEntries)
717 || body.contains("NoMatchingEntries")
718 || body.contains("not found")
719 || body.contains("does not exist")
720 }
721 _ => false,
722 }
723}
724
725fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
726 match e {
727 ClientError::Http(_, _, body) => body.contains("not a member"),
728 _ => false,
729 }
730}
731
732fn mail_relay_host(relay: &str) -> &str {
733 relay
734 .strip_prefix("smtps://")
735 .or_else(|| relay.strip_prefix("smtp://"))
736 .unwrap_or(relay)
737}
738
739fn toml_basic_string(value: &str) -> String {
740 let mut output = String::with_capacity(value.len() + 2);
741 output.push('"');
742 for c in value.chars() {
743 match c {
744 '\u{08}' => output.push_str("\\b"),
745 '\t' => output.push_str("\\t"),
746 '\n' => output.push_str("\\n"),
747 '\u{0c}' => output.push_str("\\f"),
748 '\r' => output.push_str("\\r"),
749 '"' => output.push_str("\\\""),
750 '\\' => output.push_str("\\\\"),
751 c if c.is_control() => {
752 let code = c as u32;
753 if code <= 0xffff {
754 output.push_str(&format!("\\u{code:04X}"));
755 } else {
756 output.push_str(&format!("\\U{code:08X}"));
757 }
758 }
759 c => output.push(c),
760 }
761 }
762 output.push('"');
763 output
764}
765
766fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
767 BTreeMap::from([
768 (NAME_LABEL.to_string(), "kanidm".to_string()),
769 (
770 MANAGED_BY_LABEL.to_string(),
771 format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
772 ),
773 (INSTANCE_LABEL.to_string(), kanidm.name_any()),
774 (CLUSTER_LABEL.to_string(), kanidm.name_any()),
775 ])
776}
777
778fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
779 generate_mail_sender_labels(kanidm)
780 .into_iter()
781 .chain([
782 (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
783 (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
784 ])
785 .collect()
786}
787
788#[cfg(test)]
789mod tests {
790 use super::{mail_relay_host, toml_basic_string};
791
792 #[test]
793 fn mail_relay_host_strips_supported_schemes() {
794 assert_eq!(
795 mail_relay_host("smtps://smtp.example.com"),
796 "smtp.example.com"
797 );
798 assert_eq!(
799 mail_relay_host("smtp://smtp.example.com:587"),
800 "smtp.example.com:587"
801 );
802 assert_eq!(mail_relay_host("smtp.example.com"), "smtp.example.com");
803 }
804
805 #[test]
806 fn toml_basic_string_escapes_config_values() {
807 assert_eq!(
808 toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
809 r#""quoted \"value\" with \\ slash\nand tab\t""#
810 );
811 }
812}