1use super::super::controller::context::Context;
2use super::CLUSTER_LABEL;
3use crate::controller::{INSTANCE_LABEL, MANAGED_BY_LABEL, NAME_LABEL};
4use crate::kanidm::crd::{Kanidm, MailSenderSpec, MailSenderStatus};
5use kaniop_k8s_util::error::{Error, Result};
6
7use std::collections::BTreeMap;
8use std::sync::Arc;
9
10use k8s_openapi::api::apps::v1::{Deployment, DeploymentSpec, DeploymentStrategy};
11use k8s_openapi::api::core::v1::{
12 Container, KeyToPath, PodSecurityContext, PodSpec, PodTemplateSpec, Secret, SecretVolumeSource,
13 Volume, VolumeMount,
14};
15use kanidm_client::{ClientError, KanidmClient, StatusCode};
16use kanidm_proto::internal::OperationError;
17use kube::ResourceExt;
18use kube::api::{Api, DeleteParams};
19use tracing::{debug, info};
20
21const MAIL_SENDER_LABEL: &str = "mail-sender";
22const MAIL_SENDER_COMPONENT: &str = "kanidm-mail-sender";
23const MESSAGE_SENDERS_GROUP: &str = "idm_message_senders";
24const MAIL_SENDER_SERVICE_ACCOUNT_SUFFIX: &str = "mail-sender";
25const MAIL_SENDER_TOKEN_SUFFIX: &str = "mail-sender-token";
26const MAIL_SENDER_CONFIG_SUFFIX: &str = "mail-sender-config";
27const MAIL_SENDER_DEPLOYMENT_SUFFIX: &str = "mail-sender";
28const DEFAULT_QUEUE_POLL_INTERVAL: i32 = 5;
29const DEFAULT_CONNECT_TIMEOUT: i32 = 15;
30const CLIENT_CONFIG_KEY: &str = "client.toml";
31const MAIL_CONFIG_KEY: &str = "mail-sender.toml";
32const ENTRY_MANAGED_BY: &str = "idm_admin";
33
34pub fn mail_sender_service_account_name(kanidm_name: &str) -> String {
35 format!("{kanidm_name}-{MAIL_SENDER_SERVICE_ACCOUNT_SUFFIX}")
36}
37
38pub fn mail_sender_token_secret_name(kanidm_name: &str) -> String {
39 format!("{kanidm_name}-{MAIL_SENDER_TOKEN_SUFFIX}")
40}
41
42pub fn mail_sender_config_map_name(kanidm_name: &str) -> String {
43 format!("{kanidm_name}-{MAIL_SENDER_CONFIG_SUFFIX}")
44}
45
46pub fn mail_sender_deployment_name(kanidm_name: &str) -> String {
47 format!("{kanidm_name}-{MAIL_SENDER_DEPLOYMENT_SUFFIX}")
48}
49
50pub async fn reconcile_mail_sender(
51 kanidm: &Kanidm,
52 kanidm_client: Arc<KanidmClient>,
53 ctx: Arc<Context>,
54) -> Result<Option<MailSenderStatus>> {
55 let namespace = kanidm.namespace().unwrap();
56 let kanidm_name = kanidm.name_any();
57
58 if let Some(mail_sender_spec) = &kanidm.spec.mail_sender {
59 info!(msg = "reconciling mail sender", namespace, kanidm_name);
60
61 let sa_name = mail_sender_service_account_name(&kanidm_name);
62 let config_secret_name = mail_sender_config_map_name(&kanidm_name);
63 let deployment_name = mail_sender_deployment_name(&kanidm_name);
64
65 ensure_mail_sender_service_account(&kanidm_client, &sa_name, &kanidm.spec.domain).await?;
66
67 ensure_mail_sender_in_group(&kanidm_client, &sa_name).await?;
68
69 let token = generate_mail_sender_token(&kanidm_client, &sa_name).await?;
70
71 let smtp_credentials = read_smtp_credentials(&ctx, mail_sender_spec, &namespace).await?;
72
73 let config_secret = create_config_secret(
74 kanidm,
75 &config_secret_name,
76 mail_sender_spec,
77 &token,
78 &smtp_credentials,
79 )?;
80 kanidm.patch(&ctx, config_secret).await?;
81
82 let deployment = create_deployment(
83 kanidm,
84 &deployment_name,
85 mail_sender_spec,
86 &config_secret_name,
87 )?;
88 kanidm.patch(&ctx, deployment).await?;
89
90 let deployment_api: Api<Deployment> =
91 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
92 let deployment_status = deployment_api
93 .get(&deployment_name)
94 .await
95 .map_err(|e| Error::kube_error("get", "deployment", &namespace, &deployment_name, e))?;
96
97 let ready = deployment_status
98 .status
99 .as_ref()
100 .is_some_and(|s| s.ready_replicas.unwrap_or(0) >= 1);
101
102 Ok(Some(MailSenderStatus {
103 service_account_name: sa_name,
104 token_secret_name: config_secret_name.clone(),
105 deployment_name,
106 config_map_name: config_secret_name,
107 ready,
108 }))
109 } else {
110 debug!(
111 msg = "mail sender not enabled, cleaning up resources",
112 namespace, kanidm_name
113 );
114 cleanup_mail_sender_resources(kanidm, &ctx).await?;
115 Ok(None)
116 }
117}
118
119async fn ensure_mail_sender_service_account(
120 kanidm_client: &KanidmClient,
121 name: &str,
122 domain: &str,
123) -> Result<()> {
124 debug!(msg = "ensuring mail sender service account exists", name);
125
126 let display_name = format!("Mail Sender ({domain})");
127
128 let create_result = kanidm_client
129 .idm_service_account_create(name, &display_name, ENTRY_MANAGED_BY)
130 .await;
131
132 match create_result {
133 Ok(_) => Ok(()),
134 Err(e) if is_already_exists_error(&e) => {
135 debug!(msg = "service account already exists, updating", name);
136 kanidm_client
137 .idm_service_account_update(name, None, Some(&display_name), None, None)
138 .await
139 .map_err(|e| {
140 Error::KanidmClientError(
141 format!("failed to update service account {name}"),
142 Box::new(e),
143 )
144 })?;
145 Ok(())
146 }
147 Err(e) => Err(Error::KanidmClientError(
148 format!("failed to create service account {name}"),
149 Box::new(e),
150 )),
151 }
152}
153
154async fn ensure_mail_sender_in_group(kanidm_client: &KanidmClient, name: &str) -> Result<()> {
155 debug!(msg = "adding mail sender to message_senders group", name);
156
157 let add_result = kanidm_client
158 .idm_group_add_members(MESSAGE_SENDERS_GROUP, &[name])
159 .await;
160
161 match add_result {
162 Ok(_) => Ok(()),
163 Err(e) if is_already_member_error(&e) => {
164 debug!(msg = "service account already in group", name);
165 Ok(())
166 }
167 Err(e) => Err(Error::KanidmClientError(
168 format!("failed to add {name} to {MESSAGE_SENDERS_GROUP}"),
169 Box::new(e),
170 )),
171 }
172}
173
174async fn generate_mail_sender_token(kanidm_client: &KanidmClient, name: &str) -> Result<String> {
175 debug!(
176 msg = "generating read-write API token for mail sender",
177 name
178 );
179
180 let token = kanidm_client
181 .idm_service_account_generate_api_token(name, MAIL_SENDER_COMPONENT, None, true, false)
182 .await
183 .map_err(|e| {
184 Error::KanidmClientError(
185 format!("failed to generate API token for {name}"),
186 Box::new(e),
187 )
188 })?;
189
190 Ok(token)
191}
192
193fn create_config_secret(
194 kanidm: &Kanidm,
195 name: &str,
196 spec: &MailSenderSpec,
197 token: &str,
198 smtp_credentials: &SmtpCredentials,
199) -> Result<Secret> {
200 debug!(msg = "creating config secret", name);
201
202 let domain = &kanidm.spec.domain;
203 let default_origin = format!("https://{domain}");
204 let origin = kanidm.spec.origin.as_ref().unwrap_or(&default_origin);
205 let default_display_name = format!("Kanidm {domain}");
206 let display_name = kanidm
207 .spec
208 .domain_appearance
209 .as_ref()
210 .and_then(|da| da.display_name.as_ref())
211 .unwrap_or(&default_display_name);
212 let poll_interval = spec
213 .queue_poll_interval_seconds
214 .unwrap_or(DEFAULT_QUEUE_POLL_INTERVAL);
215 let connect_timeout = spec
216 .connect_timeout_seconds
217 .unwrap_or(DEFAULT_CONNECT_TIMEOUT);
218
219 let client_config = format!("uri = {}", toml_basic_string(origin));
220
221 let reply_to = spec
222 .reply_to_address
223 .as_deref()
224 .unwrap_or(&spec.from_address);
225
226 let relay_host = mail_relay_host(&spec.relay);
227
228 let token = toml_basic_string(token);
229 let display_name = toml_basic_string(display_name);
230 let origin = toml_basic_string(origin);
231 let from_address = toml_basic_string(&spec.from_address);
232 let reply_to = toml_basic_string(reply_to);
233 let relay_host = toml_basic_string(relay_host);
234 let username = toml_basic_string(&smtp_credentials.username);
235 let password = toml_basic_string(&smtp_credentials.password);
236 let schedule = toml_basic_string(&format!("0 */{poll_interval} * * * *"));
237
238 let mail_config = format!(
239 r#"token = {token}
240instance_display_name = {display_name}
241instance_url = {origin}
242mail_from_address = {from_address}
243mail_reply_to_address = {reply_to}
244mail_relay = {relay_host}
245mail_username = {username}
246mail_password = {password}
247connect_timeout_seconds = {connect_timeout}
248schedule = {schedule}
249"#
250 );
251
252 let extended_labels = generate_extended_mail_sender_labels(kanidm);
253
254 Ok(Secret {
255 metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
256 name: Some(name.to_string()),
257 namespace: Some(kanidm.namespace().unwrap()),
258 labels: Some(extended_labels),
259 ..Default::default()
260 },
261 string_data: Some(BTreeMap::from([
262 (CLIENT_CONFIG_KEY.to_string(), client_config),
263 (MAIL_CONFIG_KEY.to_string(), mail_config),
264 ])),
265 type_: Some("Opaque".to_string()),
266 ..Default::default()
267 })
268}
269
270fn create_deployment(
271 kanidm: &Kanidm,
272 name: &str,
273 spec: &MailSenderSpec,
274 config_secret_name: &str,
275) -> Result<Deployment> {
276 debug!(msg = "creating deployment", name);
277
278 let namespace = kanidm.namespace().unwrap();
279 let image = spec.image.clone().unwrap_or_else(|| {
280 let default_image = kanidm.spec.image.clone();
281 if default_image.contains("/server:") {
282 default_image.replace("/server:", "/tools:")
283 } else {
284 format!("{}-tools", default_image)
285 }
286 });
287
288 let extended_labels = generate_extended_mail_sender_labels(kanidm);
289
290 let container = Container {
291 name: MAIL_SENDER_COMPONENT.to_string(),
292 image: Some(image),
293 image_pull_policy: kanidm.spec.image_pull_policy.clone(),
294 command: Some(vec![
295 "/sbin/kanidm-mail-sender".to_string(),
296 "-c".to_string(),
297 format!("/data/config/{CLIENT_CONFIG_KEY}"),
298 "-m".to_string(),
299 format!("/data/config/{MAIL_CONFIG_KEY}"),
300 ]),
301 resources: spec.resources.clone(),
302 volume_mounts: Some(vec![VolumeMount {
303 name: "config".to_string(),
304 mount_path: "/data/config".to_string(),
305 read_only: Some(true),
306 ..Default::default()
307 }]),
308 ..Default::default()
309 };
310
311 let pod_spec = PodSpec {
312 containers: vec![container],
313 security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
314 PodSecurityContext {
315 run_as_non_root: Some(true),
316 run_as_user: Some(65534),
317 ..Default::default()
318 }
319 })),
320 volumes: Some(vec![Volume {
321 name: "config".to_string(),
322 secret: Some(SecretVolumeSource {
323 secret_name: Some(config_secret_name.to_string()),
324 items: Some(vec![
325 KeyToPath {
326 key: CLIENT_CONFIG_KEY.to_string(),
327 path: CLIENT_CONFIG_KEY.to_string(),
328 ..Default::default()
329 },
330 KeyToPath {
331 key: MAIL_CONFIG_KEY.to_string(),
332 path: MAIL_CONFIG_KEY.to_string(),
333 ..Default::default()
334 },
335 ]),
336 ..Default::default()
337 }),
338 ..Default::default()
339 }]),
340 node_selector: spec.node_selector.clone(),
341 affinity: spec.affinity.clone(),
342 tolerations: spec.tolerations.clone(),
343 automount_service_account_token: Some(false),
344 ..Default::default()
345 };
346
347 let pod_template = PodTemplateSpec {
348 metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
349 labels: Some(extended_labels.clone()),
350 ..Default::default()
351 }),
352 spec: Some(pod_spec),
353 };
354
355 Ok(Deployment {
356 metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
357 name: Some(name.to_string()),
358 namespace: Some(namespace),
359 labels: Some(extended_labels.clone()),
360 ..Default::default()
361 },
362 spec: Some(DeploymentSpec {
363 replicas: Some(1),
364 selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
365 match_labels: Some(extended_labels),
366 ..Default::default()
367 },
368 template: pod_template,
369 strategy: Some(DeploymentStrategy {
370 type_: Some("Recreate".to_string()),
371 ..Default::default()
372 }),
373 ..Default::default()
374 }),
375 ..Default::default()
376 })
377}
378
379struct SmtpCredentials {
380 username: String,
381 password: String,
382}
383
384async fn read_smtp_credentials(
385 ctx: &Context,
386 spec: &MailSenderSpec,
387 namespace: &str,
388) -> Result<SmtpCredentials> {
389 let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
390 let secret = secret_api
391 .get(&spec.credentials_secret.name)
392 .await
393 .map_err(|e| {
394 Error::kube_error(
395 "get",
396 "SMTP credentials secret",
397 namespace,
398 &spec.credentials_secret.name,
399 e,
400 )
401 })?;
402
403 let username_key = &spec.credentials_secret.username_key;
404 let password_key = &spec.credentials_secret.password_key;
405
406 let get_string = |key: &str| -> Result<String> {
407 secret
408 .string_data
409 .as_ref()
410 .and_then(|d| d.get(key).cloned())
411 .or_else(|| {
412 secret
413 .data
414 .as_ref()
415 .and_then(|d| d.get(key))
416 .map(|v| String::from_utf8_lossy(&v.0).to_string())
417 })
418 .ok_or_else(|| {
419 Error::MissingData(format!(
420 "SMTP credentials secret {} missing key {}",
421 spec.credentials_secret.name, key
422 ))
423 })
424 };
425
426 Ok(SmtpCredentials {
427 username: get_string(username_key)?,
428 password: get_string(password_key)?,
429 })
430}
431
432pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<()> {
433 let namespace = kanidm.namespace().unwrap();
434 let kanidm_name = kanidm.name_any();
435
436 let deployment_name = mail_sender_deployment_name(&kanidm_name);
437 let config_secret_name = mail_sender_config_map_name(&kanidm_name);
438
439 let deployment_api: Api<Deployment> =
440 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
441 let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
442 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
443
444 let dp = DeleteParams::default();
445
446 match deployment_api.delete(&deployment_name, &dp).await {
447 Ok(_) => {}
448 Err(kube::Error::Api(e)) if e.code == 404 => {
449 debug!(
450 msg = "mail sender deployment already absent",
451 deployment_name
452 );
453 }
454 Err(e) => {
455 return Err(Error::kube_error(
456 "delete",
457 "deployment",
458 &namespace,
459 &deployment_name,
460 e,
461 ));
462 }
463 }
464
465 match secret_api.delete(&config_secret_name, &dp).await {
466 Ok(_) => {}
467 Err(kube::Error::Api(e)) if e.code == 404 => {
468 debug!(
469 msg = "mail sender config secret already absent",
470 config_secret_name
471 );
472 }
473 Err(e) => {
474 return Err(Error::kube_error(
475 "delete",
476 "secret",
477 &namespace,
478 &config_secret_name,
479 e,
480 ));
481 }
482 }
483
484 Ok(())
485}
486
487pub async fn cleanup_mail_sender_in_kanidm(
488 kanidm_client: &KanidmClient,
489 kanidm_name: &str,
490) -> Result<()> {
491 let sa_name = mail_sender_service_account_name(kanidm_name);
492
493 debug!(
494 msg = "removing mail sender from message_senders group",
495 sa_name
496 );
497 match kanidm_client
498 .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
499 .await
500 {
501 Ok(()) => {}
502 Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
503 debug!(msg = "mail sender group membership already absent", sa_name);
504 }
505 Err(e) => {
506 return Err(Error::KanidmClientError(
507 format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
508 Box::new(e),
509 ));
510 }
511 }
512
513 debug!(msg = "deleting mail sender service account", sa_name);
514 match kanidm_client.idm_service_account_delete(&sa_name).await {
515 Ok(()) => {}
516 Err(e) if is_not_found_error(&e) => {
517 debug!(msg = "mail sender service account already absent", sa_name);
518 }
519 Err(e) => {
520 return Err(Error::KanidmClientError(
521 format!("failed to delete service account {sa_name}"),
522 Box::new(e),
523 ));
524 }
525 }
526
527 Ok(())
528}
529
530fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
531 match e {
532 kanidm_client::ClientError::Http(status, _, body) => {
533 *status == StatusCode::CONFLICT || body.contains("already exists")
534 }
535 _ => false,
536 }
537}
538
539fn is_already_member_error(e: &kanidm_client::ClientError) -> bool {
540 match e {
541 kanidm_client::ClientError::Http(_, _, body) => body.contains("already a member"),
542 _ => false,
543 }
544}
545
546fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
547 match e {
548 ClientError::Http(status, operation_error, body) => {
549 *status == StatusCode::NOT_FOUND
550 || operation_error == &Some(OperationError::NoMatchingEntries)
551 || body.contains("NoMatchingEntries")
552 || body.contains("not found")
553 || body.contains("does not exist")
554 }
555 _ => false,
556 }
557}
558
559fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
560 match e {
561 ClientError::Http(_, _, body) => body.contains("not a member"),
562 _ => false,
563 }
564}
565
566fn mail_relay_host(relay: &str) -> &str {
567 relay
568 .strip_prefix("smtps://")
569 .or_else(|| relay.strip_prefix("smtp://"))
570 .unwrap_or(relay)
571}
572
573fn toml_basic_string(value: &str) -> String {
574 let mut output = String::with_capacity(value.len() + 2);
575 output.push('"');
576 for c in value.chars() {
577 match c {
578 '\u{08}' => output.push_str("\\b"),
579 '\t' => output.push_str("\\t"),
580 '\n' => output.push_str("\\n"),
581 '\u{0c}' => output.push_str("\\f"),
582 '\r' => output.push_str("\\r"),
583 '"' => output.push_str("\\\""),
584 '\\' => output.push_str("\\\\"),
585 c if c.is_control() => {
586 let code = c as u32;
587 if code <= 0xffff {
588 output.push_str(&format!("\\u{code:04X}"));
589 } else {
590 output.push_str(&format!("\\U{code:08X}"));
591 }
592 }
593 c => output.push(c),
594 }
595 }
596 output.push('"');
597 output
598}
599
600fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
601 BTreeMap::from([
602 (NAME_LABEL.to_string(), "kanidm".to_string()),
603 (
604 MANAGED_BY_LABEL.to_string(),
605 format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
606 ),
607 (INSTANCE_LABEL.to_string(), kanidm.name_any()),
608 (CLUSTER_LABEL.to_string(), kanidm.name_any()),
609 ])
610}
611
612fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
613 generate_mail_sender_labels(kanidm)
614 .into_iter()
615 .chain([
616 (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
617 (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
618 ])
619 .collect()
620}
621
622#[cfg(test)]
623mod tests {
624 use super::{mail_relay_host, toml_basic_string};
625
626 #[test]
627 fn mail_relay_host_strips_supported_schemes() {
628 assert_eq!(
629 mail_relay_host("smtps://smtp.example.com"),
630 "smtp.example.com"
631 );
632 assert_eq!(
633 mail_relay_host("smtp://smtp.example.com:587"),
634 "smtp.example.com:587"
635 );
636 assert_eq!(mail_relay_host("smtp.example.com"), "smtp.example.com");
637 }
638
639 #[test]
640 fn toml_basic_string_escapes_config_values() {
641 assert_eq!(
642 toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
643 r#""quoted \"value\" with \\ slash\nand tab\t""#
644 );
645 }
646}