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