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!(namespace, kanidm_name, "reconciling mail sender");
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 namespace,
149 kanidm_name, "mail sender not enabled, cleaning up resources"
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!(name, "ensuring mail sender service account exists");
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!(name, "service account already exists, updating");
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!(name, "adding mail sender to message_senders group");
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!(name, "service account already in group");
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!(name, current_token_id = ?current_token_id, "ensuring mail sender API token exists");
285
286 let start = tokio::time::Instant::now();
287 let existing_tokens_result = kanidm_client.idm_service_account_list_api_token(name).await;
288 let existing_tokens = match existing_tokens_result {
289 Ok(tokens) => {
290 metrics.record_kanidm_sdk_outcome(
291 KANIDM_RESOURCE_MAIL_SENDER,
292 KANIDM_OP_LIST_API_TOKENS,
293 KANIDM_OUTCOME_UNCHANGED,
294 start.elapsed(),
295 );
296 tokens
297 }
298 Err(ClientError::Http(status, _, _)) if status == 404 => {
299 metrics.record_kanidm_sdk_outcome(
300 KANIDM_RESOURCE_MAIL_SENDER,
301 KANIDM_OP_LIST_API_TOKENS,
302 KANIDM_OUTCOME_UNCHANGED,
303 start.elapsed(),
304 );
305 vec![]
306 }
307 Err(e) => {
308 metrics.record_kanidm_sdk_outcome(
309 KANIDM_RESOURCE_MAIL_SENDER,
310 KANIDM_OP_LIST_API_TOKENS,
311 KANIDM_OUTCOME_ERROR,
312 start.elapsed(),
313 );
314 return Err(Error::KanidmClientError(
315 format!("failed to list API tokens for {name}"),
316 Box::new(e),
317 ));
318 }
319 };
320
321 let existing_mail_sender_tokens: Vec<_> = existing_tokens
322 .iter()
323 .filter(|t| t.label == MAIL_SENDER_COMPONENT)
324 .collect();
325
326 if let Some(token) = existing_mail_sender_tokens.first() {
327 if current_token_id.as_ref() == Some(&token.token_id.to_string()) {
328 debug!(name, token_id = %token.token_id, "mail sender token already exists with matching token_id, reading from existing secret");
329 if let Some(existing_token_value) =
330 read_token_from_config_secret(ctx, namespace, config_secret_name).await?
331 {
332 return Ok((existing_token_value, token.token_id.to_string(), false));
333 }
334 debug!(name, token_id = %token.token_id, "existing token value not found in secret, destroying all tokens and regenerating");
335 } else {
336 debug!(name, old_token_id = %token.token_id, expected_token_id = ?current_token_id, "mail sender token exists but token_id mismatch, destroying all tokens and regenerating");
337 }
338
339 for token in existing_mail_sender_tokens {
340 record_kanidm_sdk_call(
341 metrics,
342 KANIDM_RESOURCE_MAIL_SENDER,
343 KANIDM_OP_DESTROY_API_TOKEN,
344 KANIDM_OUTCOME_CHANGED,
345 kanidm_client.idm_service_account_destroy_api_token(name, token.token_id),
346 )
347 .await
348 .map_err(|e| {
349 Error::KanidmClientError(
350 format!("failed to destroy API token {} for {name}", token.token_id),
351 Box::new(e),
352 )
353 })?;
354 }
355 }
356
357 debug!(name, "generating new read-write API token for mail sender");
358
359 let token_value = record_kanidm_sdk_call(
360 metrics,
361 KANIDM_RESOURCE_MAIL_SENDER,
362 KANIDM_OP_GENERATE_API_TOKEN,
363 KANIDM_OUTCOME_CHANGED,
364 kanidm_client.idm_service_account_generate_api_token(
365 name,
366 MAIL_SENDER_COMPONENT,
367 None,
368 true,
369 false,
370 ),
371 )
372 .await
373 .map_err(|e| {
374 Error::KanidmClientError(
375 format!("failed to generate API token for {name}"),
376 Box::new(e),
377 )
378 })?;
379
380 let new_tokens = record_kanidm_sdk_call(
381 metrics,
382 KANIDM_RESOURCE_MAIL_SENDER,
383 KANIDM_OP_LIST_API_TOKENS,
384 KANIDM_OUTCOME_UNCHANGED,
385 kanidm_client.idm_service_account_list_api_token(name),
386 )
387 .await
388 .map_err(|e| {
389 Error::KanidmClientError(
390 format!("failed to list API tokens for {name} after generation"),
391 Box::new(e),
392 )
393 })?;
394
395 let new_token = new_tokens
396 .iter()
397 .find(|t| t.label == MAIL_SENDER_COMPONENT)
398 .ok_or_else(|| {
399 Error::MissingData(format!(
400 "generated token with label {MAIL_SENDER_COMPONENT} not found for {name}"
401 ))
402 })?;
403
404 Ok((token_value, new_token.token_id.to_string(), true))
405}
406
407async fn read_token_from_config_secret(
408 ctx: &Context,
409 namespace: &str,
410 name: &str,
411) -> Result<Option<String>> {
412 let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
413 let secret = match secret_api.get(name).await {
414 Ok(s) => s,
415 Err(kube::Error::Api(e)) if e.code == 404 => {
416 debug!(
417 name,
418 "mail sender config secret not found, will regenerate token"
419 );
420 return Ok(None);
421 }
422 Err(e) => {
423 return Err(Error::kube_error(
424 "get",
425 "mail sender config secret",
426 namespace,
427 name,
428 e,
429 ));
430 }
431 };
432
433 let mail_config = secret
434 .string_data
435 .as_ref()
436 .and_then(|d| d.get(MAIL_CONFIG_KEY).cloned())
437 .or_else(|| {
438 secret
439 .data
440 .as_ref()
441 .and_then(|d| d.get(MAIL_CONFIG_KEY))
442 .map(|v| String::from_utf8_lossy(&v.0).to_string())
443 });
444
445 match mail_config {
446 Some(config) => {
447 let token = config
448 .lines()
449 .find(|line| line.starts_with("token = "))
450 .and_then(|line| line.strip_prefix("token = "))
451 .and_then(|value| value.strip_prefix('"').and_then(|v| v.strip_suffix('"')))
452 .map(|s| s.to_string());
453 Ok(token)
454 }
455 None => {
456 debug!(
457 name,
458 "mail sender config secret missing mail-sender.toml key, will regenerate token"
459 );
460 Ok(None)
461 }
462 }
463}
464
465fn create_config_secret(
466 kanidm: &Kanidm,
467 name: &str,
468 spec: &MailSenderSpec,
469 token: &str,
470 smtp_credentials: &SmtpCredentials,
471) -> Result<Secret> {
472 debug!(name, "creating config secret");
473
474 let domain = &kanidm.spec.domain;
475 let default_origin = format!("https://{domain}");
476 let origin = kanidm.spec.origin.as_ref().unwrap_or(&default_origin);
477 let default_display_name = format!("Kanidm {domain}");
478 let display_name = kanidm
479 .spec
480 .domain_appearance
481 .as_ref()
482 .and_then(|da| da.display_name.as_ref())
483 .unwrap_or(&default_display_name);
484 let poll_interval = spec
485 .queue_poll_interval_seconds
486 .unwrap_or(DEFAULT_QUEUE_POLL_INTERVAL);
487 let connect_timeout = spec
488 .connect_timeout_seconds
489 .unwrap_or(DEFAULT_CONNECT_TIMEOUT);
490
491 let client_config = format!("uri = {}", toml_basic_string(origin));
492
493 let reply_to = spec
494 .reply_to_address
495 .as_deref()
496 .unwrap_or(&spec.from_address);
497
498 let token = toml_basic_string(token);
499 let display_name = toml_basic_string(display_name);
500 let origin = toml_basic_string(origin);
501 let from_address = toml_basic_string(&spec.from_address);
502 let reply_to = toml_basic_string(reply_to);
503 let relay_host = toml_basic_string(&spec.relay);
504 let username = toml_basic_string(&smtp_credentials.username);
505 let password = toml_basic_string(&smtp_credentials.password);
506 let schedule = toml_basic_string(&format!("0 */{poll_interval} * * * * *"));
507
508 let mail_config = format!(
509 r#"token = {token}
510instance_display_name = {display_name}
511instance_url = {origin}
512mail_from_address = {from_address}
513mail_reply_to_address = {reply_to}
514mail_relay = {relay_host}
515mail_username = {username}
516mail_password = {password}
517mail_connect_timeout_seconds = {connect_timeout}
518schedule = {schedule}
519"#
520 );
521
522 let extended_labels = generate_extended_mail_sender_labels(kanidm);
523
524 Ok(Secret {
525 metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
526 name: Some(name.to_string()),
527 namespace: Some(kanidm.namespace().unwrap()),
528 owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
529 labels: Some(extended_labels),
530 ..Default::default()
531 },
532 string_data: Some(BTreeMap::from([
533 (CLIENT_CONFIG_KEY.to_string(), client_config),
534 (MAIL_CONFIG_KEY.to_string(), mail_config),
535 ])),
536 type_: Some("Opaque".to_string()),
537 ..Default::default()
538 })
539}
540
541fn create_deployment(
542 kanidm: &Kanidm,
543 name: &str,
544 spec: &MailSenderSpec,
545 config_secret_name: &str,
546) -> Result<Deployment> {
547 debug!(name, "creating deployment");
548
549 let namespace = kanidm.namespace().unwrap();
550 let image = spec.image.clone().unwrap_or_else(|| {
551 let default_image = kanidm.spec.image.clone();
552 if default_image.contains("/server:") {
553 default_image.replace("/server:", "/tools:")
554 } else {
555 format!("{}-tools", default_image)
556 }
557 });
558
559 let extended_labels = generate_extended_mail_sender_labels(kanidm);
560
561 let container = Container {
562 name: MAIL_SENDER_COMPONENT.to_string(),
563 image: Some(image),
564 image_pull_policy: kanidm.spec.image_pull_policy.clone(),
565 command: Some(vec![
566 "/sbin/kanidm-mail-sender".to_string(),
567 "-c".to_string(),
568 format!("/data/config/{CLIENT_CONFIG_KEY}"),
569 "-m".to_string(),
570 format!("/data/config/{MAIL_CONFIG_KEY}"),
571 ]),
572 resources: spec.resources.clone(),
573 volume_mounts: Some(vec![VolumeMount {
574 name: "config".to_string(),
575 mount_path: "/data/config".to_string(),
576 read_only: Some(true),
577 ..Default::default()
578 }]),
579 ..Default::default()
580 };
581
582 let pod_spec = PodSpec {
583 containers: vec![container],
584 security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
585 PodSecurityContext {
586 run_as_non_root: Some(true),
587 run_as_user: Some(65534),
588 ..Default::default()
589 }
590 })),
591 volumes: Some(vec![Volume {
592 name: "config".to_string(),
593 secret: Some(SecretVolumeSource {
594 secret_name: Some(config_secret_name.to_string()),
595 items: Some(vec![
596 KeyToPath {
597 key: CLIENT_CONFIG_KEY.to_string(),
598 path: CLIENT_CONFIG_KEY.to_string(),
599 ..Default::default()
600 },
601 KeyToPath {
602 key: MAIL_CONFIG_KEY.to_string(),
603 path: MAIL_CONFIG_KEY.to_string(),
604 ..Default::default()
605 },
606 ]),
607 ..Default::default()
608 }),
609 ..Default::default()
610 }]),
611 node_selector: spec.node_selector.clone(),
612 affinity: spec.affinity.clone(),
613 tolerations: spec.tolerations.clone(),
614 automount_service_account_token: Some(false),
615 ..Default::default()
616 };
617
618 let pod_template = PodTemplateSpec {
619 metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
620 labels: Some(extended_labels.clone()),
621 ..Default::default()
622 }),
623 spec: Some(pod_spec),
624 };
625
626 Ok(Deployment {
627 metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
628 name: Some(name.to_string()),
629 namespace: Some(namespace),
630 owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
631 labels: Some(extended_labels.clone()),
632 ..Default::default()
633 },
634 spec: Some(DeploymentSpec {
635 replicas: Some(1),
636 selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
637 match_labels: Some(extended_labels),
638 ..Default::default()
639 },
640 template: pod_template,
641 strategy: Some(DeploymentStrategy {
642 type_: Some("Recreate".to_string()),
643 ..Default::default()
644 }),
645 ..Default::default()
646 }),
647 ..Default::default()
648 })
649}
650
651struct SmtpCredentials {
652 username: String,
653 password: String,
654}
655
656async fn read_smtp_credentials(
657 ctx: &Context,
658 spec: &MailSenderSpec,
659 namespace: &str,
660) -> Result<SmtpCredentials> {
661 let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
662 let secret = secret_api
663 .get(&spec.credentials_secret.name)
664 .await
665 .map_err(|e| {
666 Error::kube_error(
667 "get",
668 "SMTP credentials secret",
669 namespace,
670 &spec.credentials_secret.name,
671 e,
672 )
673 })?;
674
675 let username_key = &spec.credentials_secret.username_key;
676 let password_key = &spec.credentials_secret.password_key;
677
678 let get_string = |key: &str| -> Result<String> {
679 secret
680 .string_data
681 .as_ref()
682 .and_then(|d| d.get(key).cloned())
683 .or_else(|| {
684 secret
685 .data
686 .as_ref()
687 .and_then(|d| d.get(key))
688 .map(|v| String::from_utf8_lossy(&v.0).to_string())
689 })
690 .ok_or_else(|| {
691 Error::MissingData(format!(
692 "SMTP credentials secret {} missing key {}",
693 spec.credentials_secret.name, key
694 ))
695 })
696 };
697
698 Ok(SmtpCredentials {
699 username: get_string(username_key)?,
700 password: get_string(password_key)?,
701 })
702}
703
704pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<bool> {
705 let namespace = kanidm.namespace().unwrap();
706 let kanidm_name = kanidm.name_any();
707 let mut changed = false;
708
709 let deployment_name = mail_sender_deployment_name(&kanidm_name);
710 let config_secret_name = mail_sender_config_map_name(&kanidm_name);
711
712 let deployment_api: Api<Deployment> =
713 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
714 let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
715 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
716
717 let dp = DeleteParams::default();
718
719 match deployment_api.delete(&deployment_name, &dp).await {
720 Ok(_) => {
721 changed = true;
722 }
723 Err(kube::Error::Api(e)) if e.code == 404 => {
724 debug!(deployment_name, "mail sender deployment already absent");
725 }
726 Err(e) => {
727 return Err(Error::kube_error(
728 "delete",
729 "deployment",
730 &namespace,
731 &deployment_name,
732 e,
733 ));
734 }
735 }
736
737 match secret_api.delete(&config_secret_name, &dp).await {
738 Ok(_) => {
739 changed = true;
740 }
741 Err(kube::Error::Api(e)) if e.code == 404 => {
742 debug!(
743 config_secret_name,
744 "mail sender config secret already absent"
745 );
746 }
747 Err(e) => {
748 return Err(Error::kube_error(
749 "delete",
750 "secret",
751 &namespace,
752 &config_secret_name,
753 e,
754 ));
755 }
756 }
757
758 Ok(changed)
759}
760
761pub async fn cleanup_mail_sender_in_kanidm(
762 kanidm_client: &KanidmClient,
763 kanidm_name: &str,
764 metrics: &crate::metrics::ControllerMetrics,
765) -> Result<bool> {
766 let sa_name = mail_sender_service_account_name(kanidm_name);
767 let mut changed = false;
768
769 debug!(sa_name, "removing mail sender from message_senders group");
770 let start = tokio::time::Instant::now();
771 let remove_result = kanidm_client
772 .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
773 .await;
774 match remove_result {
775 Ok(()) => {
776 metrics.record_kanidm_sdk_outcome(
777 KANIDM_RESOURCE_MAIL_SENDER,
778 KANIDM_OP_REMOVE_MEMBERS,
779 KANIDM_OUTCOME_CHANGED,
780 start.elapsed(),
781 );
782 changed = true;
783 }
784 Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
785 debug!(sa_name, "mail sender group membership already absent");
786 metrics.record_kanidm_sdk_outcome(
787 KANIDM_RESOURCE_MAIL_SENDER,
788 KANIDM_OP_REMOVE_MEMBERS,
789 KANIDM_OUTCOME_UNCHANGED,
790 start.elapsed(),
791 );
792 }
793 Err(e) => {
794 metrics.record_kanidm_sdk_outcome(
795 KANIDM_RESOURCE_MAIL_SENDER,
796 KANIDM_OP_REMOVE_MEMBERS,
797 KANIDM_OUTCOME_ERROR,
798 start.elapsed(),
799 );
800 return Err(Error::KanidmClientError(
801 format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
802 Box::new(e),
803 ));
804 }
805 }
806
807 debug!(sa_name, "deleting mail sender service account");
808 let start = tokio::time::Instant::now();
809 let delete_result = kanidm_client.idm_service_account_delete(&sa_name).await;
810 match delete_result {
811 Ok(()) => {
812 metrics.record_kanidm_sdk_outcome(
813 KANIDM_RESOURCE_MAIL_SENDER,
814 KANIDM_OP_DELETE,
815 KANIDM_OUTCOME_CHANGED,
816 start.elapsed(),
817 );
818 changed = true;
819 }
820 Err(e) if is_not_found_error(&e) => {
821 debug!(sa_name, "mail sender service account already absent");
822 metrics.record_kanidm_sdk_outcome(
823 KANIDM_RESOURCE_MAIL_SENDER,
824 KANIDM_OP_DELETE,
825 KANIDM_OUTCOME_UNCHANGED,
826 start.elapsed(),
827 );
828 }
829 Err(e) => {
830 metrics.record_kanidm_sdk_outcome(
831 KANIDM_RESOURCE_MAIL_SENDER,
832 KANIDM_OP_DELETE,
833 KANIDM_OUTCOME_ERROR,
834 start.elapsed(),
835 );
836 return Err(Error::KanidmClientError(
837 format!("failed to delete service account {sa_name}"),
838 Box::new(e),
839 ));
840 }
841 }
842
843 Ok(changed)
844}
845
846fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
847 match e {
848 kanidm_client::ClientError::Http(status, _, body) => {
849 status.as_u16() == 409
850 || body.contains("already exists")
851 || body.contains("conflicting_with")
852 || body.contains("AttributeUniqueness")
853 }
854 _ => false,
855 }
856}
857
858fn is_already_member_error(e: &kanidm_client::ClientError) -> bool {
859 match e {
860 kanidm_client::ClientError::Http(_, _, body) => body.contains("already a member"),
861 _ => false,
862 }
863}
864
865fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
866 match e {
867 ClientError::Http(status, operation_error, body) => {
868 status.as_u16() == 404
869 || operation_error == &Some(OperationError::NoMatchingEntries)
870 || body.contains("NoMatchingEntries")
871 || body.contains("not found")
872 || body.contains("does not exist")
873 }
874 _ => false,
875 }
876}
877
878fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
879 match e {
880 ClientError::Http(_, _, body) => body.contains("not a member"),
881 _ => false,
882 }
883}
884
885fn toml_basic_string(value: &str) -> String {
886 let mut output = String::with_capacity(value.len() + 2);
887 output.push('"');
888 for c in value.chars() {
889 match c {
890 '\u{08}' => output.push_str("\\b"),
891 '\t' => output.push_str("\\t"),
892 '\n' => output.push_str("\\n"),
893 '\u{0c}' => output.push_str("\\f"),
894 '\r' => output.push_str("\\r"),
895 '"' => output.push_str("\\\""),
896 '\\' => output.push_str("\\\\"),
897 c if c.is_control() => {
898 let code = c as u32;
899 if code <= 0xffff {
900 output.push_str(&format!("\\u{code:04X}"));
901 } else {
902 output.push_str(&format!("\\U{code:08X}"));
903 }
904 }
905 c => output.push(c),
906 }
907 }
908 output.push('"');
909 output
910}
911
912fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
913 BTreeMap::from([
914 (NAME_LABEL.to_string(), "kanidm".to_string()),
915 (
916 MANAGED_BY_LABEL.to_string(),
917 format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
918 ),
919 (INSTANCE_LABEL.to_string(), kanidm.name_any()),
920 (CLUSTER_LABEL.to_string(), kanidm.name_any()),
921 ])
922}
923
924fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
925 generate_mail_sender_labels(kanidm)
926 .into_iter()
927 .chain([
928 (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
929 (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
930 ])
931 .collect()
932}
933
934#[cfg(test)]
935mod tests {
936 use super::toml_basic_string;
937
938 #[test]
939 fn toml_basic_string_escapes_config_values() {
940 assert_eq!(
941 toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
942 r#""quoted \"value\" with \\ slash\nand tab\t""#
943 );
944 }
945}