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