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!("*/{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 default_mail_sender_image(server_image: &str) -> Result<String> {
586 let tag = match kaniop_k8s_util::resources::get_image_tag(server_image) {
587 Some(tag) => tag,
588 None if !server_image.contains('@') => "latest".to_string(),
589 None => {
590 return Err(Error::MissingData(
591 "Cannot infer a mail sender image tag from the Kanidm server image; set spec.mailSender.image explicitly".to_string(),
592 ));
593 }
594 };
595
596 Ok(format!("kanidm/tools:{tag}"))
597}
598
599fn create_deployment(
600 kanidm: &Kanidm,
601 name: &str,
602 spec: &MailSenderSpec,
603 config_secret_name: &str,
604) -> Result<Deployment> {
605 debug!(name, "creating deployment");
606
607 let namespace = kanidm.namespace().unwrap();
608 let image = match &spec.image {
609 Some(image) => image.clone(),
610 None => default_mail_sender_image(&kanidm.spec.image)?,
611 };
612
613 let extended_labels = generate_extended_mail_sender_labels(kanidm);
614
615 let container = Container {
616 name: MAIL_SENDER_COMPONENT.to_string(),
617 image: Some(image),
618 image_pull_policy: kanidm.spec.image_pull_policy.clone(),
619 command: Some(vec![
620 "/sbin/kanidm-mail-sender".to_string(),
621 "-c".to_string(),
622 format!("/data/config/{CLIENT_CONFIG_KEY}"),
623 "-m".to_string(),
624 format!("/data/config/{MAIL_CONFIG_KEY}"),
625 ]),
626 resources: spec.resources.clone(),
627 volume_mounts: Some(vec![VolumeMount {
628 name: "config".to_string(),
629 mount_path: "/data/config".to_string(),
630 read_only: Some(true),
631 ..Default::default()
632 }]),
633 ..Default::default()
634 };
635
636 let pod_spec = PodSpec {
637 containers: vec![container],
638 security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
639 PodSecurityContext {
640 run_as_non_root: Some(true),
641 run_as_user: Some(65534),
642 ..Default::default()
643 }
644 })),
645 volumes: Some(vec![Volume {
646 name: "config".to_string(),
647 secret: Some(SecretVolumeSource {
648 secret_name: Some(config_secret_name.to_string()),
649 items: Some(vec![
650 KeyToPath {
651 key: CLIENT_CONFIG_KEY.to_string(),
652 path: CLIENT_CONFIG_KEY.to_string(),
653 ..Default::default()
654 },
655 KeyToPath {
656 key: MAIL_CONFIG_KEY.to_string(),
657 path: MAIL_CONFIG_KEY.to_string(),
658 ..Default::default()
659 },
660 ]),
661 ..Default::default()
662 }),
663 ..Default::default()
664 }]),
665 node_selector: spec.node_selector.clone(),
666 affinity: spec.affinity.clone(),
667 tolerations: spec.tolerations.clone(),
668 automount_service_account_token: Some(false),
669 ..Default::default()
670 };
671
672 let pod_template = PodTemplateSpec {
673 metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
674 labels: Some(extended_labels.clone()),
675 ..Default::default()
676 }),
677 spec: Some(pod_spec),
678 };
679
680 Ok(Deployment {
681 metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
682 name: Some(name.to_string()),
683 namespace: Some(namespace),
684 owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
685 labels: Some(extended_labels.clone()),
686 ..Default::default()
687 },
688 spec: Some(DeploymentSpec {
689 replicas: Some(1),
690 selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
691 match_labels: Some(extended_labels),
692 ..Default::default()
693 },
694 template: pod_template,
695 strategy: Some(DeploymentStrategy {
696 type_: Some("Recreate".to_string()),
697 ..Default::default()
698 }),
699 ..Default::default()
700 }),
701 ..Default::default()
702 })
703}
704
705struct SmtpCredentials {
706 username: String,
707 password: String,
708}
709
710async fn read_smtp_credentials(
711 ctx: &Context,
712 spec: &MailSenderSpec,
713 namespace: &str,
714) -> Result<SmtpCredentials> {
715 let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
716 let secret = secret_api
717 .get(&spec.credentials_secret.name)
718 .await
719 .map_err(|e| {
720 Error::kube_error(
721 "get",
722 "SMTP credentials secret",
723 namespace,
724 &spec.credentials_secret.name,
725 e,
726 )
727 })?;
728
729 let username_key = &spec.credentials_secret.username_key;
730 let password_key = &spec.credentials_secret.password_key;
731
732 let get_string = |key: &str| -> Result<String> {
733 secret
734 .string_data
735 .as_ref()
736 .and_then(|d| d.get(key).cloned())
737 .or_else(|| {
738 secret
739 .data
740 .as_ref()
741 .and_then(|d| d.get(key))
742 .map(|v| String::from_utf8_lossy(&v.0).to_string())
743 })
744 .ok_or_else(|| {
745 Error::MissingData(format!(
746 "SMTP credentials secret {} missing key {}",
747 spec.credentials_secret.name, key
748 ))
749 })
750 };
751
752 Ok(SmtpCredentials {
753 username: get_string(username_key)?,
754 password: get_string(password_key)?,
755 })
756}
757
758pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<bool> {
759 let namespace = kanidm.namespace().unwrap();
760 let kanidm_name = kanidm.name_any();
761 let mut changed = false;
762
763 let deployment_name = mail_sender_deployment_name(&kanidm_name);
764 let config_secret_name = mail_sender_config_map_name(&kanidm_name);
765
766 let deployment_api: Api<Deployment> =
767 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
768 let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
769 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
770
771 let dp = DeleteParams::default();
772
773 match deployment_api.delete(&deployment_name, &dp).await {
774 Ok(_) => {
775 changed = true;
776 }
777 Err(kube::Error::Api(e)) if e.code == 404 => {
778 debug!(deployment_name, "mail sender deployment already absent");
779 }
780 Err(e) => {
781 return Err(Error::kube_error(
782 "delete",
783 "deployment",
784 &namespace,
785 &deployment_name,
786 e,
787 ));
788 }
789 }
790
791 match secret_api.delete(&config_secret_name, &dp).await {
792 Ok(_) => {
793 changed = true;
794 }
795 Err(kube::Error::Api(e)) if e.code == 404 => {
796 debug!(
797 config_secret_name,
798 "mail sender config secret already absent"
799 );
800 }
801 Err(e) => {
802 return Err(Error::kube_error(
803 "delete",
804 "secret",
805 &namespace,
806 &config_secret_name,
807 e,
808 ));
809 }
810 }
811
812 Ok(changed)
813}
814
815pub async fn cleanup_mail_sender_in_kanidm(
816 kanidm_client: &KanidmClient,
817 kanidm_name: &str,
818 metrics: &crate::metrics::ControllerMetrics,
819) -> Result<bool> {
820 let sa_name = mail_sender_service_account_name(kanidm_name);
821 let mut changed = false;
822
823 debug!(sa_name, "removing mail sender from message_senders group");
824 let start = tokio::time::Instant::now();
825 let remove_result = kanidm_client
826 .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
827 .await;
828 match remove_result {
829 Ok(()) => {
830 metrics.record_kanidm_sdk_outcome(
831 KANIDM_RESOURCE_MAIL_SENDER,
832 KANIDM_OP_REMOVE_MEMBERS,
833 KANIDM_OUTCOME_CHANGED,
834 start.elapsed(),
835 );
836 changed = true;
837 }
838 Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
839 debug!(sa_name, "mail sender group membership already absent");
840 metrics.record_kanidm_sdk_outcome(
841 KANIDM_RESOURCE_MAIL_SENDER,
842 KANIDM_OP_REMOVE_MEMBERS,
843 KANIDM_OUTCOME_UNCHANGED,
844 start.elapsed(),
845 );
846 }
847 Err(e) => {
848 metrics.record_kanidm_sdk_outcome(
849 KANIDM_RESOURCE_MAIL_SENDER,
850 KANIDM_OP_REMOVE_MEMBERS,
851 KANIDM_OUTCOME_ERROR,
852 start.elapsed(),
853 );
854 return Err(Error::KanidmClientError(
855 format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
856 Box::new(e),
857 ));
858 }
859 }
860
861 debug!(sa_name, "deleting mail sender service account");
862 let start = tokio::time::Instant::now();
863 let delete_result = kanidm_client.idm_service_account_delete(&sa_name).await;
864 match delete_result {
865 Ok(()) => {
866 metrics.record_kanidm_sdk_outcome(
867 KANIDM_RESOURCE_MAIL_SENDER,
868 KANIDM_OP_DELETE,
869 KANIDM_OUTCOME_CHANGED,
870 start.elapsed(),
871 );
872 changed = true;
873 }
874 Err(e) if is_not_found_error(&e) => {
875 debug!(sa_name, "mail sender service account already absent");
876 metrics.record_kanidm_sdk_outcome(
877 KANIDM_RESOURCE_MAIL_SENDER,
878 KANIDM_OP_DELETE,
879 KANIDM_OUTCOME_UNCHANGED,
880 start.elapsed(),
881 );
882 }
883 Err(e) => {
884 metrics.record_kanidm_sdk_outcome(
885 KANIDM_RESOURCE_MAIL_SENDER,
886 KANIDM_OP_DELETE,
887 KANIDM_OUTCOME_ERROR,
888 start.elapsed(),
889 );
890 return Err(Error::KanidmClientError(
891 format!("failed to delete service account {sa_name}"),
892 Box::new(e),
893 ));
894 }
895 }
896
897 Ok(changed)
898}
899
900fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
901 match e {
902 kanidm_client::ClientError::Http(status, _, body) => {
903 status.as_u16() == 409
904 || body.contains("already exists")
905 || body.contains("conflicting_with")
906 || body.contains("AttributeUniqueness")
907 }
908 _ => false,
909 }
910}
911
912fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
913 match e {
914 ClientError::Http(status, operation_error, body) => {
915 status.as_u16() == 404
916 || operation_error == &Some(OperationError::NoMatchingEntries)
917 || body.contains("NoMatchingEntries")
918 || body.contains("not found")
919 || body.contains("does not exist")
920 }
921 _ => false,
922 }
923}
924
925fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
926 match e {
927 ClientError::Http(_, _, body) => body.contains("not a member"),
928 _ => false,
929 }
930}
931
932fn toml_basic_string(value: &str) -> String {
933 let mut output = String::with_capacity(value.len() + 2);
934 output.push('"');
935 for c in value.chars() {
936 match c {
937 '\u{08}' => output.push_str("\\b"),
938 '\t' => output.push_str("\\t"),
939 '\n' => output.push_str("\\n"),
940 '\u{0c}' => output.push_str("\\f"),
941 '\r' => output.push_str("\\r"),
942 '"' => output.push_str("\\\""),
943 '\\' => output.push_str("\\\\"),
944 c if c.is_control() => {
945 let code = c as u32;
946 if code <= 0xffff {
947 output.push_str(&format!("\\u{code:04X}"));
948 } else {
949 output.push_str(&format!("\\U{code:08X}"));
950 }
951 }
952 c => output.push(c),
953 }
954 }
955 output.push('"');
956 output
957}
958
959fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
960 BTreeMap::from([
961 (NAME_LABEL.to_string(), "kanidm".to_string()),
962 (
963 MANAGED_BY_LABEL.to_string(),
964 format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
965 ),
966 (INSTANCE_LABEL.to_string(), kanidm.name_any()),
967 (CLUSTER_LABEL.to_string(), kanidm.name_any()),
968 ])
969}
970
971fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
972 generate_mail_sender_labels(kanidm)
973 .into_iter()
974 .chain([
975 (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
976 (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
977 ])
978 .collect()
979}
980
981#[cfg(test)]
982mod tests {
983 use super::{
984 create_deployment, default_mail_sender_image, group_contains_member, toml_basic_string,
985 };
986 use crate::kanidm::crd::{Kanidm, MailSenderSpec};
987 use serde_json::json;
988
989 #[test]
990 fn digest_pinned_server_image_creates_pullable_mail_sender_deployment() {
991 let kanidm: Kanidm = serde_json::from_value(json!({
993 "apiVersion": "kaniop.rs/v1beta1",
994 "kind": "Kanidm",
995 "metadata": {"name": "idm", "namespace": "default"},
996 "spec": {
997 "domain": "idm.example.com",
998 "image": "kanidm/server:1.11.2@sha256:deadbeef",
999 "replicaGroups": [{"name": "default", "replicas": 1}]
1000 }
1001 }))
1002 .unwrap();
1003 let mail_sender_spec: MailSenderSpec = serde_json::from_value(json!({
1004 "relay": "smtps://smtp.example.com",
1005 "credentialsSecret": {"name": "smtp-credentials"},
1006 "fromAddress": "kanidm@example.com"
1007 }))
1008 .unwrap();
1009
1010 let deployment = create_deployment(
1011 &kanidm,
1012 "idm-mail-sender",
1013 &mail_sender_spec,
1014 "idm-mail-sender-config",
1015 )
1016 .unwrap();
1017
1018 let image = deployment.spec.unwrap().template.spec.unwrap().containers[0]
1019 .image
1020 .clone();
1021 assert_eq!(image.as_deref(), Some("kanidm/tools:1.11.2"));
1022 assert!(!image.unwrap().contains("@sha256:"));
1023
1024 let override_image = "mirror.example.org/custom/mail-sender:custom@sha256:abcdef";
1027 let mut overridden = mail_sender_spec;
1028 overridden.image = Some(override_image.to_string());
1029 let deployment = create_deployment(
1030 &kanidm,
1031 "idm-mail-sender",
1032 &overridden,
1033 "idm-mail-sender-config",
1034 )
1035 .unwrap();
1036 assert_eq!(
1037 deployment.spec.unwrap().template.spec.unwrap().containers[0]
1038 .image
1039 .as_deref(),
1040 Some(override_image),
1041 );
1042
1043 let mut digest_only_server = kanidm;
1045 digest_only_server.spec.image = "kanidm/server@sha256:deadbeef".to_string();
1046 let deployment = create_deployment(
1047 &digest_only_server,
1048 "idm-mail-sender",
1049 &overridden,
1050 "idm-mail-sender-config",
1051 )
1052 .unwrap();
1053 assert_eq!(
1054 deployment.spec.unwrap().template.spec.unwrap().containers[0]
1055 .image
1056 .as_deref(),
1057 Some(override_image),
1058 );
1059 }
1060
1061 #[test]
1062 fn default_mail_sender_image_uses_docker_hub_versioned_tools() {
1063 for (server, expected) in [
1064 ("kanidm/server:1.11.2", "kanidm/tools:1.11.2"),
1065 ("kanidm/server:latest", "kanidm/tools:latest"),
1066 ("kanidm/server", "kanidm/tools:latest"),
1067 (
1068 "kanidm/server:1.11.2@sha256:deadbeef",
1069 "kanidm/tools:1.11.2",
1070 ),
1071 ] {
1072 assert_eq!(default_mail_sender_image(server).unwrap(), expected);
1073 }
1074 }
1075
1076 #[test]
1077 fn digest_only_server_image_requires_explicit_mail_sender_image() {
1078 assert!(default_mail_sender_image("kanidm/server@sha256:deadbeef").is_err());
1079 }
1080
1081 #[test]
1082 fn toml_basic_string_escapes_config_values() {
1083 assert_eq!(
1084 toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
1085 r#""quoted \"value\" with \\ slash\nand tab\t""#
1086 );
1087 }
1088
1089 #[test]
1090 fn group_contains_member_matches_bare_name_against_spn() {
1091 let members = vec![
1092 "other-user".to_string(),
1093 "my-sa@idm.example.com".to_string(),
1094 ];
1095 assert!(group_contains_member(&members, "my-sa"));
1096 }
1097
1098 #[test]
1099 fn group_contains_member_is_case_insensitive() {
1100 let members = vec!["My-SA@idm.example.com".to_string()];
1101 assert!(group_contains_member(&members, "my-sa"));
1102 }
1103
1104 #[test]
1105 fn group_contains_member_returns_false_for_empty() {
1106 let members: Vec<String> = vec![];
1107 assert!(!group_contains_member(&members, "my-sa"));
1108 }
1109
1110 #[test]
1111 fn group_contains_member_returns_false_when_no_match() {
1112 let members = vec![
1113 "other-user".to_string(),
1114 "another-sa@idm.example.com".to_string(),
1115 ];
1116 assert!(!group_contains_member(&members, "my-sa"));
1117 }
1118}