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}