Skip to main content

kaniop_operator/kanidm/reconcile/
mail_sender.rs

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}