Skip to main content

kaniop_operator/kanidm/reconcile/
statefulset.rs

1use super::secret::{REPLICA_SECRET_KEY, SecretExt};
2use super::service::ServiceExt;
3use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
4
5use crate::controller::cluster_domain;
6use crate::kanidm::crd::{IpFamily, Kanidm, KanidmServerRole, ReplicaGroup, ReplicationType};
7
8use kaniop_backup_core::auth::{
9    AuthRole, build_auth_env_vars, build_auth_volume_mounts, build_auth_volumes,
10    build_ca_bundle_volume, build_ca_bundle_volume_mount, build_encryption_env_vars,
11    ca_bundle_env_var,
12};
13use kaniop_backup_core::image::data_mover_image;
14use kaniop_backup_core::pod_defaults::{default_resource_requirements, hardened_security_context};
15
16use kaniop_k8s_util::error::Result;
17use kaniop_k8s_util::resources::merge_containers;
18
19use std::collections::BTreeMap;
20
21use k8s_openapi::api::apps::v1::{StatefulSet, StatefulSetSpec};
22use k8s_openapi::api::core::v1::{
23    Container, ContainerPort, EmptyDirVolumeSource, EnvVar, EnvVarSource, HTTPGetAction,
24    ObjectFieldSelector, PersistentVolumeClaim, PodSpec, PodTemplateSpec, Probe, SecretKeySelector,
25    SecretVolumeSource, Volume, VolumeMount,
26};
27use k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector;
28use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
29use kube::ResourceExt;
30use kube::api::{ObjectMeta, Resource};
31
32pub const REPLICA_GROUP_LABEL: &str = "kanidm.kaniop.rs/replica-group";
33pub const REPLICA_LABEL: &str = "kanidm.kaniop.rs/replica";
34pub const TLS_SECRET_HASH_ANNOTATION: &str = "kanidm.kaniop.rs/tls-secret-hash";
35pub const CONTAINER_REPLICATION_PORT: i32 = 8444;
36pub const CONTAINER_REPLICATION_PORT_NAME: &str = "replication";
37
38// renovate: datasource=docker
39const REPLICATION_CONFIG_IMAGE: &str = "ghcr.io/rash-sh/rash:2.18.3";
40const REPLICATION_CONFIG_SCRIPT: &str = r#"
41- copy:
42    content: |
43      version = "2"
44
45      {% if env.KANIOP_BACKUP_ENABLED == "true" and env.POD_NAME == env.KANIDM_PRIMARY_NODE -%}
46      [online_backup]
47      path = "/data/backups"
48      schedule = "{{ env.KANIOP_BACKUP_SCHEDULE }}"
49      versions = {{ env.KANIOP_BACKUP_VERSIONS }}
50      {% endif -%}
51
52      {% if env.KANIOP_REPLICATION_ENABLED == "true" -%}
53      {% set pod_env = env.POD_NAME | upper | replace('-', '_') -%}
54      [replication]
55      origin = "repl://{{ env[pod_env + '_HOST'] }}:{{ env.REPLICATION_PORT }}"
56      bindaddress = "{{ env.BIND_ADDRESS }}:{{ env.REPLICATION_PORT }}"
57
58      {% for e in env -%}
59      {% if e is startingwith(env.KANIDM_NAME| upper | replace('-', '_')) -%}
60      {% if e == pod_env or e is endingwith("_TYPE") or
61         e + '_TYPE' not in env or env[e + '_TYPE'] == "" -%}
62        {% continue -%}
63      {% endif -%}
64      {% set replica = e | lower | replace('_', '-') -%}
65      [replication."repl://{{ env[e + '_HOST'] }}:{{ env.REPLICATION_PORT }}"]
66      {% set type = env[e + '_TYPE'] -%}
67      type = "{{ type }}"
68      {% if type == "mutual-pull" -%}
69      partner_cert = "{{ env[e] }}"
70      {% elif type == "pull" -%}
71      supplier_cert = "{{ env[e] }}"
72      {% else -%}
73      consumer_cert = "{{ env[e] }}"
74      {% endif -%}
75      {% if type != "allow-pull" -%}
76      {% if replica == env.KANIDM_PRIMARY_NODE -%}
77      automatic_refresh = true
78      {% else -%}
79      automatic_refresh = false
80      {% endif -%}
81      {% endif %}
82      {% elif e is startingwith("EXTERNAL_REPLICATION_NODE") -%}
83      {% if e + '_CERT' not in env or e is endingwith("_TYPE") or e is endingwith("_CERT") or e is endingwith("_AUTOMATIC_REFRESH") -%}
84        {% continue -%}
85      {% endif -%}
86      [replication."{{ env[e] }}"]
87      {% set type = env[e + '_TYPE'] -%}
88      type = "{{ type }}"
89      {% if type == "mutual-pull" -%}
90      partner_cert = "{{ env[e + '_CERT'] }}"
91      {% elif type == "pull" -%}
92      supplier_cert = "{{ env[e + '_CERT'] }}"
93      {% else -%}
94      consumer_cert = "{{ env[e + '_CERT'] }}"
95      {% endif -%}
96      {% if type != "allow-pull" -%}
97      automatic_refresh = {{ env[e + '_AUTOMATIC_REFRESH'] }}
98      {% endif %}
99      {% endif %}
100      {%- endfor -%}
101      {% endif -%}
102    dest: "{{ env.KANIDM_CONFIG_PATH }}"
103    mode: "0400"
104"#;
105const CONTAINER_HTTPS_PORT: i32 = 8443;
106const CONTAINER_LDAP_PORT: i32 = 3636;
107pub const KANIDM_CONFIG_PATH: &str = "/run/kanidm/server.toml";
108pub const KANIDM_BACKUP_PATH: &str = "/data/backups";
109const VOLUME_CONFIG_NAME: &str = "kanidm-config";
110const VOLUME_CONFIG_PATH: &str = "/run/kanidm";
111const VOLUME_DATA_NAME: &str = "kanidm-data";
112const VOLUME_DATA_PATH: &str = "/data";
113const VOLUME_TLS_NAME: &str = "kanidm-certs";
114const VOLUME_TLS_PATH: &str = "/etc/kanidm/tls";
115
116const IPV4_BIND_ADDRESS: &str = "0.0.0.0";
117const IPV6_BIND_ADDRESS: &str = "[::]";
118
119#[derive(Debug, Clone, PartialEq, Eq)]
120pub(super) enum StatefulSetApplyStrategy {
121    Apply,
122    Recreate { immutable_fields: Vec<&'static str> },
123}
124
125/// Normalize only API defaults with stable, resource-local semantics.
126///
127/// * `podManagementPolicy` defaults to `OrderedReady`.
128/// * PVC `volumeMode` defaults to `Filesystem`.
129/// * When the generated desired PVC template has `storageClassName: None` (omission or
130///   defaulting), preserve the live object's `storageClassName` so that a CR cannot
131///   distinguish omission/defaulting from removal after the StatefulSet has been created.
132///
133/// Never copies `storageClassName` when the desired object explicitly sets a non-None
134/// value—the explicit desired value always wins.
135pub(super) fn preserve_defaulted_statefulset_fields(
136    desired: &mut StatefulSet,
137    current: &StatefulSet,
138) {
139    let Some(desired_spec) = desired.spec.as_mut() else {
140        return;
141    };
142
143    if desired_spec.pod_management_policy.is_none() {
144        desired_spec.pod_management_policy = Some("OrderedReady".to_string());
145    }
146
147    if let Some(templates) = desired_spec.volume_claim_templates.as_mut() {
148        if let Some(current_templates) = current
149            .spec
150            .as_ref()
151            .and_then(|s| s.volume_claim_templates.as_ref())
152        {
153            for template in templates.iter_mut() {
154                if let Some(spec) = template.spec.as_mut() {
155                    // Preserve defaulted storageClassName: the CR cannot distinguish omission
156                    // from removal after creation, so compatibility/defaulting wins. Match by
157                    // claim-template name rather than relying on vector order.
158                    if spec.storage_class_name.is_none()
159                        && let Some(template_name) = template.metadata.name.as_deref()
160                        && let Some(current_spec) = current_templates
161                            .iter()
162                            .find(|current| current.metadata.name.as_deref() == Some(template_name))
163                            .and_then(|current| current.spec.as_ref())
164                    {
165                        spec.storage_class_name
166                            .clone_from(&current_spec.storage_class_name);
167                    }
168                    if spec.volume_mode.is_none() {
169                        spec.volume_mode = Some("Filesystem".to_string());
170                    }
171                }
172            }
173        } else {
174            for template in templates {
175                if let Some(spec) = template.spec.as_mut() {
176                    if spec.volume_mode.is_none() {
177                        spec.volume_mode = Some("Filesystem".to_string());
178                    }
179                }
180            }
181        }
182    }
183}
184
185fn pod_management_policy(spec: &StatefulSetSpec) -> &str {
186    spec.pod_management_policy
187        .as_deref()
188        .unwrap_or("OrderedReady")
189}
190
191fn normalized_volume_claim_templates(spec: &StatefulSetSpec) -> Option<Vec<PersistentVolumeClaim>> {
192    let mut templates = spec.volume_claim_templates.clone();
193    if let Some(templates) = templates.as_mut() {
194        for template in templates {
195            if let Some(pvc_spec) = template.spec.as_mut()
196                && pvc_spec.volume_mode.is_none()
197            {
198                pvc_spec.volume_mode = Some("Filesystem".to_string());
199            }
200        }
201    }
202    templates
203}
204
205fn deletes_pvcs_when_deleted(spec: &StatefulSetSpec) -> bool {
206    spec.persistent_volume_claim_retention_policy
207        .as_ref()
208        .and_then(|policy| policy.when_deleted.as_deref())
209        == Some("Delete")
210}
211
212/// Classify StatefulSet updates without deriving destructive behavior from an HTTP status code.
213///
214/// Selector, serviceName and podManagementPolicy changes can be recreated when deletion is known
215/// to preserve PVCs. `volumeClaimTemplates` changes are deliberately left on the non-destructive
216/// apply path because deleting/recreating a StatefulSet is not a PVC migration. Kubernetes will
217/// reject unsupported template updates while the existing StatefulSet remains intact.
218pub(super) fn classify_statefulset_change(
219    current: &StatefulSet,
220    desired: &StatefulSet,
221) -> StatefulSetApplyStrategy {
222    let (Some(current_spec), Some(desired_spec)) = (current.spec.as_ref(), desired.spec.as_ref())
223    else {
224        // A malformed or incomplete object is not sufficient evidence for deletion.
225        return StatefulSetApplyStrategy::Apply;
226    };
227
228    if normalized_volume_claim_templates(current_spec)
229        != normalized_volume_claim_templates(desired_spec)
230    {
231        return StatefulSetApplyStrategy::Apply;
232    }
233
234    let mut immutable_fields = Vec::new();
235    if current_spec.selector != desired_spec.selector {
236        immutable_fields.push("spec.selector");
237    }
238    if current_spec.service_name != desired_spec.service_name {
239        immutable_fields.push("spec.serviceName");
240    }
241    if pod_management_policy(current_spec) != pod_management_policy(desired_spec) {
242        immutable_fields.push("spec.podManagementPolicy");
243    }
244
245    if immutable_fields.is_empty() || deletes_pvcs_when_deleted(current_spec) {
246        StatefulSetApplyStrategy::Apply
247    } else {
248        StatefulSetApplyStrategy::Recreate { immutable_fields }
249    }
250}
251
252pub trait StatefulSetExt {
253    fn statefulset_name(&self, rg_name: &str) -> String;
254    fn pod_name(&self, rg_name: &str, i: i32) -> String;
255    fn pod_env_prefix(&self, pod_name: &str) -> String;
256
257    fn create_statefulset(
258        &self,
259        replica_group: &ReplicaGroup,
260        tls_secret_hash: Option<&str>,
261        backup_config: Option<&BackupConfig>,
262    ) -> Result<StatefulSet>;
263}
264
265impl StatefulSetExt for Kanidm {
266    #[inline]
267    fn statefulset_name(&self, rg_name: &str) -> String {
268        format!("{kanidm_name}-{rg_name}", kanidm_name = self.name_any())
269    }
270
271    #[inline]
272    fn pod_name(&self, rg_name: &str, i: i32) -> String {
273        format!("{}-{}", self.statefulset_name(rg_name), i)
274    }
275
276    #[inline]
277    fn pod_env_prefix(&self, pod_name: &str) -> String {
278        pod_name.to_uppercase().replace("-", "_")
279    }
280
281    fn create_statefulset(
282        &self,
283        replica_group: &ReplicaGroup,
284        tls_secret_hash: Option<&str>,
285        backup_config: Option<&BackupConfig>,
286    ) -> Result<StatefulSet> {
287        let pod_labels = self.generate_pod_labels(replica_group);
288        let labels = self.generate_sts_labels(&pod_labels);
289        let env = self.generate_env_vars(replica_group);
290        let init_containers = self.generate_init_containers(replica_group, backup_config)?;
291        let ports = self.generate_container_ports();
292        let probe = self.generate_probe();
293        let volume_mounts = self.generate_volume_mounts(backup_config);
294        let mut containers = self.generate_containers(
295            &env,
296            &volume_mounts,
297            &ports,
298            &probe,
299            replica_group,
300            backup_config,
301        )?;
302        let transport_config = backup_config.and_then(|config| config.transport.as_ref());
303
304        if replica_group.primary_node {
305            if let Some(config) = transport_config {
306                let sidecar = self.build_transport_sidecar(config, replica_group)?;
307                containers.push(sidecar);
308            } else {
309                containers.retain(|c| c.name != super::transport::TRANSPORT_SIDECAR_NAME);
310            }
311        } else {
312            containers.retain(|c| c.name != super::transport::TRANSPORT_SIDECAR_NAME);
313        }
314
315        let dns_policy = self.generate_dns_policy();
316        let (mut volumes, volume_claim_templates) = self.generate_volumes(backup_config);
317
318        if let Some(config) = transport_config {
319            let auth_volumes = build_auth_volumes(&config.auth_method);
320            volumes.extend(auth_volumes);
321            if let Some(ca_bundle_ref) = &config.ca_bundle_ref {
322                volumes.push(build_ca_bundle_volume(ca_bundle_ref));
323            }
324            if !volumes.iter().any(|v| v.name == "kanidm-tmp") {
325                volumes.push(Volume {
326                    name: "kanidm-tmp".to_string(),
327                    empty_dir: Some(EmptyDirVolumeSource::default()),
328                    ..Volume::default()
329                });
330            }
331        }
332
333        Ok(StatefulSet {
334            metadata: self.generate_metadata(
335                &replica_group.name,
336                &replica_group.stateful_set_annotations,
337                &labels,
338            ),
339            spec: Some(StatefulSetSpec {
340                replicas: Some(replica_group.replicas),
341                selector: LabelSelector {
342                    match_expressions: None,
343                    match_labels: Some(pod_labels.clone()),
344                },
345                template: PodTemplateSpec {
346                    metadata: Some(ObjectMeta {
347                        labels: Some(pod_labels),
348                        annotations: tls_secret_hash.map(|hash| {
349                            BTreeMap::from([(
350                                TLS_SECRET_HASH_ANNOTATION.to_string(),
351                                hash.to_string(),
352                            )])
353                        }),
354                        ..ObjectMeta::default()
355                    }),
356                    spec: Some(PodSpec {
357                        containers,
358                        volumes: Some(volumes),
359                        node_selector: replica_group.node_selector.clone(),
360                        affinity: replica_group.affinity.clone(),
361                        tolerations: replica_group.tolerations.clone(),
362                        topology_spread_constraints: replica_group
363                            .topology_spread_constraints
364                            .clone(),
365                        security_context: self.spec.security_context.clone(),
366                        dns_policy,
367                        dns_config: self.spec.dns_config.clone(),
368                        init_containers: Some(init_containers),
369                        host_aliases: self.spec.host_aliases.clone(),
370                        enable_service_links: Some(self.spec.enable_service_links),
371                        automount_service_account_token: self.spec.automount_service_account_token,
372                        host_users: self.spec.host_users,
373                        runtime_class_name: self.spec.runtime_class_name.clone(),
374                        ..PodSpec::default()
375                    }),
376                },
377                service_name: Some(self.service_name()),
378                persistent_volume_claim_retention_policy: self
379                    .spec
380                    .persistent_volume_claim_retention_policy
381                    .clone(),
382                min_ready_seconds: self.spec.min_ready_seconds,
383                volume_claim_templates,
384                ..StatefulSetSpec::default()
385            }),
386            ..StatefulSet::default()
387        })
388    }
389}
390
391impl Kanidm {
392    fn uses_generated_config(&self, backup_config: Option<&BackupConfig>) -> bool {
393        self.is_replication_enabled() || backup_config.is_some()
394    }
395
396    fn generate_pod_labels(&self, replica_group: &ReplicaGroup) -> BTreeMap<String, String> {
397        self.generate_resource_labels()
398            .into_iter()
399            .chain(std::iter::once((
400                REPLICA_GROUP_LABEL.to_string(),
401                replica_group.name.clone(),
402            )))
403            .collect()
404    }
405
406    fn generate_sts_labels(
407        &self,
408        pod_labels: &BTreeMap<String, String>,
409    ) -> BTreeMap<String, String> {
410        pod_labels.clone()
411    }
412
413    fn generate_env_vars(&self, replica_group: &ReplicaGroup) -> Vec<EnvVar> {
414        let origin = match self.spec.origin.clone() {
415            Some(o) => o,
416            None => format!("https://{}", self.spec.domain.clone()),
417        };
418        let bind_address = match self.spec.ip_family {
419            IpFamily::Ipv4 => IPV4_BIND_ADDRESS,
420            IpFamily::Ipv6 => IPV6_BIND_ADDRESS,
421        };
422
423        self.spec
424            .env
425            .clone()
426            .unwrap_or_default()
427            .into_iter()
428            .chain(vec![
429                EnvVar {
430                    name: "KANIDM_DOMAIN".to_string(),
431                    value: Some(self.spec.domain.clone()),
432                    ..EnvVar::default()
433                },
434                EnvVar {
435                    name: "KANIDM_ORIGIN".to_string(),
436                    value: Some(origin),
437                    ..EnvVar::default()
438                },
439                EnvVar {
440                    name: "KANIDM_DB_PATH".to_string(),
441                    value: Some(format!("{VOLUME_DATA_PATH}/kanidm.db")),
442                    ..EnvVar::default()
443                },
444                EnvVar {
445                    name: "KANIDM_TLS_CHAIN".to_string(),
446                    value: Some(format!("{VOLUME_TLS_PATH}/tls.crt")),
447                    ..EnvVar::default()
448                },
449                EnvVar {
450                    name: "KANIDM_TLS_KEY".to_string(),
451                    value: Some(format!("{VOLUME_TLS_PATH}/tls.key")),
452                    ..EnvVar::default()
453                },
454                EnvVar {
455                    name: "KANIDM_BINDADDRESS".to_string(),
456                    value: Some(format!("{bind_address}:{CONTAINER_HTTPS_PORT}")),
457                    ..EnvVar::default()
458                },
459                EnvVar {
460                    name: "KANIDM_ROLE".to_string(),
461                    value: Some(serde_plain::to_string(&replica_group.role.clone()).unwrap()),
462                    ..EnvVar::default()
463                },
464                EnvVar {
465                    name: "KANIDM_LOG_LEVEL".to_string(),
466                    value: Some(serde_plain::to_string(&self.spec.log_level.clone()).unwrap()),
467                    ..EnvVar::default()
468                },
469            ])
470            .chain(
471                self.spec
472                    .ldap_port_name
473                    .clone()
474                    .into_iter()
475                    .map(|_| EnvVar {
476                        name: "KANIDM_LDAPBINDADDRESS".to_string(),
477                        value: Some(format!("{bind_address}:{CONTAINER_LDAP_PORT}")),
478                        ..EnvVar::default()
479                    }),
480            )
481            .collect()
482    }
483
484    fn generate_config_volume_mount(&self) -> VolumeMount {
485        VolumeMount {
486            name: VOLUME_CONFIG_NAME.to_string(),
487            mount_path: VOLUME_CONFIG_PATH.to_string(),
488            read_only: Some(false),
489            ..VolumeMount::default()
490        }
491    }
492
493    fn generate_volume_mounts(&self, backup_config: Option<&BackupConfig>) -> Vec<VolumeMount> {
494        self.spec
495            .volume_mounts
496            .clone()
497            .unwrap_or_default()
498            .into_iter()
499            .chain([
500                VolumeMount {
501                    name: VOLUME_DATA_NAME.to_string(),
502                    mount_path: VOLUME_DATA_PATH.to_string(),
503                    ..VolumeMount::default()
504                },
505                VolumeMount {
506                    name: VOLUME_TLS_NAME.to_string(),
507                    mount_path: VOLUME_TLS_PATH.to_string(),
508                    read_only: Some(true),
509                    ..VolumeMount::default()
510                },
511            ])
512            .chain(
513                self.uses_generated_config(backup_config)
514                    .then(|| self.generate_config_volume_mount()),
515            )
516            .collect()
517    }
518
519    fn generate_init_containers(
520        &self,
521        replica_group: &ReplicaGroup,
522        backup_config: Option<&BackupConfig>,
523    ) -> Result<Vec<Container>> {
524        if self.uses_generated_config(backup_config) {
525            let external_replica_nodes_envs = self
526                .spec
527                .external_replication_nodes
528                .iter()
529                .flat_map(|ern| {
530                    [
531                        EnvVar {
532                            name: format!("EXTERNAL_REPLICATION_NODE_{}", ern.name),
533                            value: Some(format!(
534                                "repl://{host}:{port}",
535                                host = ern.hostname.clone(),
536                                port = ern.port
537                            )),
538                            ..EnvVar::default()
539                        },
540                        EnvVar {
541                            name: format!("EXTERNAL_REPLICATION_NODE_{}_CERT", ern.name),
542                            value_from: Some(EnvVarSource {
543                                secret_key_ref: Some(ern.certificate.clone()),
544                                ..EnvVarSource::default()
545                            }),
546                            ..EnvVar::default()
547                        },
548                        EnvVar {
549                            name: format!("EXTERNAL_REPLICATION_NODE_{}_TYPE", ern.name),
550                            value: serde_plain::to_string(&ern._type).ok(),
551                            ..EnvVar::default()
552                        },
553                        EnvVar {
554                            name: format!(
555                                "EXTERNAL_REPLICATION_NODE_{}_AUTOMATIC_REFRESH",
556                                ern.name
557                            ),
558                            value: Some(ern.automatic_refresh.to_string()),
559                            ..EnvVar::default()
560                        },
561                    ]
562                })
563                .collect::<Vec<EnvVar>>();
564            let replica_secrets_envs = self
565                .spec
566                .replica_groups
567                .iter()
568                .flat_map(|rg| {
569                    (0..rg.replicas).flat_map(move |i| {
570                        let pod_name = self.pod_name(&rg.name, i);
571                        let pod_env_prefix = self.pod_env_prefix(&pod_name);
572                        let pod_host = match rg
573                            .services
574                            .as_ref()
575                            .and_then(|s| s.replication_hostname_template.as_ref())
576                        {
577                            Some(template) => template
578                                .replace("{pod_name}", &pod_name)
579                                .replace("{replica_index}", &i.to_string())
580                                .replace("{domain}", &self.spec.domain),
581                            None => format!(
582                                "{pod_name}.{}.{}.svc.{}",
583                                self.service_name(),
584                                self.get_namespace(),
585                                cluster_domain()
586                            ),
587                        };
588                        [
589                            EnvVar {
590                                name: pod_env_prefix.clone(),
591                                value_from: Some(EnvVarSource {
592                                    secret_key_ref: Some(SecretKeySelector {
593                                        name: self.replica_secret_name(&pod_name),
594                                        key: REPLICA_SECRET_KEY.to_string(),
595                                        optional: Some(true),
596                                    }),
597                                    ..EnvVarSource::default()
598                                }),
599                                ..EnvVar::default()
600                            },
601                            EnvVar {
602                                name: format!("{pod_env_prefix}_TYPE"),
603                                value: replication_type(
604                                    replica_group.role.clone(),
605                                    rg.role.clone(),
606                                )
607                                .and_then(|t| serde_plain::to_string(&t).ok()),
608                                ..EnvVar::default()
609                            },
610                            EnvVar {
611                                name: format!("{pod_env_prefix}_HOST"),
612                                value: Some(pod_host),
613                                ..EnvVar::default()
614                            },
615                        ]
616                    })
617                })
618                .collect::<Vec<EnvVar>>();
619
620            let primary_node = self
621                .spec
622                .replica_groups
623                .iter()
624                .find(|rg| rg.primary_node)
625                .map(|rg| format!("{}-0", self.statefulset_name(&rg.name)));
626
627            let bind_address = match self.spec.ip_family {
628                IpFamily::Ipv4 => IPV4_BIND_ADDRESS,
629                IpFamily::Ipv6 => IPV6_BIND_ADDRESS,
630            };
631
632            let env = external_replica_nodes_envs
633                .into_iter()
634                .chain(replica_secrets_envs)
635                .chain([
636                    EnvVar {
637                        name: "POD_NAME".to_string(),
638                        value_from: Some(EnvVarSource {
639                            field_ref: Some(ObjectFieldSelector {
640                                api_version: Some("v1".to_string()),
641                                field_path: "metadata.name".to_string(),
642                            }),
643                            ..EnvVarSource::default()
644                        }),
645                        ..EnvVar::default()
646                    },
647                    EnvVar {
648                        name: "REPLICATION_PORT".to_string(),
649                        value: Some(CONTAINER_REPLICATION_PORT.to_string()),
650                        ..EnvVar::default()
651                    },
652                    EnvVar {
653                        name: "BIND_ADDRESS".to_string(),
654                        value: Some(bind_address.to_string()),
655                        ..EnvVar::default()
656                    },
657                    EnvVar {
658                        name: "KANIDM_CONFIG_PATH".to_string(),
659                        value: Some(KANIDM_CONFIG_PATH.to_string()),
660                        ..EnvVar::default()
661                    },
662                    EnvVar {
663                        name: "KANIDM_NAME".to_string(),
664                        value: Some(self.name_any()),
665                        ..EnvVar::default()
666                    },
667                    EnvVar {
668                        name: "KANIOP_REPLICATION_ENABLED".to_string(),
669                        value: Some(self.is_replication_enabled().to_string()),
670                        ..EnvVar::default()
671                    },
672                    EnvVar {
673                        name: "KANIOP_BACKUP_ENABLED".to_string(),
674                        value: Some(backup_config.is_some().to_string()),
675                        ..EnvVar::default()
676                    },
677                ])
678                .chain(backup_config.into_iter().flat_map(|backup| {
679                    [
680                        EnvVar {
681                            name: "KANIOP_BACKUP_SCHEDULE".to_string(),
682                            value: Some(backup.schedule.clone()),
683                            ..EnvVar::default()
684                        },
685                        EnvVar {
686                            name: "KANIOP_BACKUP_VERSIONS".to_string(),
687                            value: Some(backup.local_versions.to_string()),
688                            ..EnvVar::default()
689                        },
690                    ]
691                }))
692                .chain(primary_node.map(|pn| EnvVar {
693                    name: "KANIDM_PRIMARY_NODE".to_string(),
694                    value: Some(pn),
695                    ..EnvVar::default()
696                }))
697                .collect::<Vec<EnvVar>>();
698
699            let init_container = Container {
700                name: "kanidm-generate-replication-config".to_string(),
701                image: Some(REPLICATION_CONFIG_IMAGE.to_string()),
702                env: Some(env),
703                args: Some(vec![
704                    "--script".to_string(),
705                    REPLICATION_CONFIG_SCRIPT.to_string(),
706                ]),
707                volume_mounts: Some(vec![self.generate_config_volume_mount()]),
708                ..Container::default()
709            };
710
711            merge_containers(self.spec.init_containers.clone(), &init_container)
712        } else {
713            // When replication is disabled, filter out any user init containers that have the
714            // name kanidm-generate-replication-config since that's an operator-managed container
715            // that only exists with replication enabled
716            let filtered_init_containers = self
717                .spec
718                .init_containers
719                .clone()
720                .unwrap_or_default()
721                .into_iter()
722                .filter(|container| container.name != "kanidm-generate-replication-config")
723                .collect();
724            Ok(filtered_init_containers)
725        }
726    }
727
728    fn generate_container_ports(&self) -> Vec<ContainerPort> {
729        std::iter::once(ContainerPort {
730            name: Some(self.spec.port_name.clone()),
731            container_port: CONTAINER_HTTPS_PORT,
732            ..ContainerPort::default()
733        })
734        .chain(
735            self.spec
736                .ldap_port_name
737                .clone()
738                .into_iter()
739                .map(|port_name| ContainerPort {
740                    name: Some(port_name.clone()),
741                    container_port: CONTAINER_LDAP_PORT,
742                    ..ContainerPort::default()
743                }),
744        )
745        .chain(self.is_replication_enabled().then(|| ContainerPort {
746            name: Some(CONTAINER_REPLICATION_PORT_NAME.to_string()),
747            container_port: CONTAINER_REPLICATION_PORT,
748            ..ContainerPort::default()
749        }))
750        .collect()
751    }
752
753    fn generate_probe(&self) -> Probe {
754        Probe {
755            http_get: Some(HTTPGetAction {
756                path: Some("/status".to_string()),
757                port: IntOrString::String(self.spec.port_name.clone()),
758                scheme: Some("HTTPS".to_string()),
759                ..HTTPGetAction::default()
760            }),
761            ..Probe::default()
762        }
763    }
764
765    fn generate_containers(
766        &self,
767        env: &[EnvVar],
768        volume_mounts: &[VolumeMount],
769        ports: &[ContainerPort],
770        probe: &Probe,
771        replica_group: &ReplicaGroup,
772        backup_config: Option<&BackupConfig>,
773    ) -> Result<Vec<Container>> {
774        let command = vec!["kanidmd".to_string(), "server".to_string()]
775            .into_iter()
776            .chain(
777                self.uses_generated_config(backup_config)
778                    .then(|| vec!["-c".to_string(), KANIDM_CONFIG_PATH.to_string()])
779                    .into_iter()
780                    .flatten(),
781            )
782            .collect::<Vec<String>>();
783        let kanidm_container = Container {
784            name: "kanidm".to_string(),
785            image: Some(self.spec.image.clone()),
786            image_pull_policy: self.spec.image_pull_policy.clone(),
787            command: Some(command),
788            env: Some(env.to_owned()),
789            ports: Some(ports.to_owned()),
790            volume_mounts: Some(volume_mounts.to_owned()),
791            resources: replica_group.resources.clone(),
792            readiness_probe: Some(probe.clone()),
793            liveness_probe: Some(probe.clone()),
794            ..Container::default()
795        };
796
797        merge_containers(self.spec.containers.clone(), &kanidm_container)
798    }
799
800    fn generate_dns_policy(&self) -> Option<String> {
801        match self.spec.host_network {
802            Some(true) => Some("ClusterFirstWithHostNet".to_string()),
803            _ => self.spec.dns_policy.clone(),
804        }
805    }
806
807    fn generate_volumes(
808        &self,
809        backup_config: Option<&BackupConfig>,
810    ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
811        let secret_name = self.effective_tls_secret_name();
812
813        self.expand_storage(
814            self.spec
815                .volumes
816                .clone()
817                .unwrap_or_default()
818                .into_iter()
819                .chain(std::iter::once(Volume {
820                    name: VOLUME_TLS_NAME.to_string(),
821                    secret: Some(SecretVolumeSource {
822                        secret_name: Some(secret_name),
823                        default_mode: Some(0o400),
824                        ..SecretVolumeSource::default()
825                    }),
826                    ..Volume::default()
827                }))
828                .chain(self.uses_generated_config(backup_config).then(|| Volume {
829                    name: VOLUME_CONFIG_NAME.to_string(),
830                    empty_dir: Some(EmptyDirVolumeSource {
831                        medium: None,
832                        size_limit: None,
833                    }),
834                    ..Volume::default()
835                }))
836                .collect(),
837        )
838    }
839
840    fn expand_storage(
841        &self,
842        volumes: Vec<Volume>,
843    ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
844        let default_expand_storage = |volumes: Vec<Volume>| {
845            (
846                volumes
847                    .into_iter()
848                    .chain(std::iter::once(Volume {
849                        name: VOLUME_DATA_NAME.to_string(),
850                        empty_dir: Some(EmptyDirVolumeSource {
851                            medium: None,
852                            size_limit: None,
853                        }),
854                        ..Volume::default()
855                    }))
856                    .collect(),
857                None,
858            )
859        };
860
861        match self.spec.storage.clone() {
862            Some(storage) => {
863                if let Some(empty_dir) = storage.empty_dir {
864                    (
865                        volumes
866                            .into_iter()
867                            .chain(std::iter::once(Volume {
868                                name: VOLUME_DATA_NAME.to_string(),
869                                empty_dir: Some(empty_dir),
870                                ..Volume::default()
871                            }))
872                            .collect(),
873                        None,
874                    )
875                } else if let Some(ephemeral) = storage.ephemeral {
876                    (
877                        volumes
878                            .into_iter()
879                            .chain(std::iter::once(Volume {
880                                name: VOLUME_DATA_NAME.to_string(),
881                                ephemeral: Some(ephemeral),
882                                ..Volume::default()
883                            }))
884                            .collect(),
885                        None,
886                    )
887                } else if let Some(volume_claim_template) = storage.volume_claim_template {
888                    let pvc = volume_claim_template.to_persistent_volume_claim();
889                    let named_template = PersistentVolumeClaim {
890                        metadata: ObjectMeta {
891                            name: Some(VOLUME_DATA_NAME.to_string()),
892                            ..pvc.metadata
893                        },
894                        spec: pvc.spec,
895                        ..pvc
896                    };
897                    (volumes, Some(vec![named_template]))
898                } else {
899                    default_expand_storage(volumes)
900                }
901            }
902            None => default_expand_storage(volumes),
903        }
904    }
905
906    fn generate_metadata(
907        &self,
908        replica_group_name: &str,
909        annotations: &Option<BTreeMap<String, String>>,
910        labels: &BTreeMap<String, String>,
911    ) -> ObjectMeta {
912        ObjectMeta {
913            name: Some(self.statefulset_name(replica_group_name)),
914            namespace: self.namespace(),
915            labels: Some(labels.clone()),
916            owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
917            annotations: annotations.clone(),
918            ..ObjectMeta::default()
919        }
920    }
921
922    fn build_transport_sidecar(
923        &self,
924        config: &TransportSidecarConfig,
925        replica_group: &ReplicaGroup,
926    ) -> Result<Container> {
927        let primary_node = format!("{}-0", self.statefulset_name(&replica_group.name));
928
929        let mut env_vars = vec![
930            EnvVar {
931                name: "POD_NAME".to_string(),
932                value_from: Some(EnvVarSource {
933                    field_ref: Some(ObjectFieldSelector {
934                        api_version: Some("v1".to_string()),
935                        field_path: "metadata.name".to_string(),
936                    }),
937                    ..EnvVarSource::default()
938                }),
939                ..EnvVar::default()
940            },
941            EnvVar {
942                name: "KANIDM_PRIMARY_NODE".to_string(),
943                value: Some(primary_node),
944                ..EnvVar::default()
945            },
946        ];
947
948        let auth_env = build_auth_env_vars(&config.auth_method, &self.name_any(), AuthRole::Writer);
949        env_vars.extend(auth_env);
950
951        if config.ca_bundle_ref.is_some() {
952            env_vars.push(ca_bundle_env_var());
953        }
954
955        env_vars.extend(build_encryption_env_vars(
956            config.encryption_key_ref.as_ref(),
957        ));
958
959        let mut volume_mounts = vec![
960            VolumeMount {
961                name: VOLUME_DATA_NAME.to_string(),
962                mount_path: VOLUME_DATA_PATH.to_string(),
963                read_only: Some(true),
964                ..VolumeMount::default()
965            },
966            VolumeMount {
967                name: "kanidm-tmp".to_string(),
968                mount_path: "/tmp".to_string(),
969                ..VolumeMount::default()
970            },
971        ];
972
973        let auth_mounts = build_auth_volume_mounts(&config.auth_method);
974        volume_mounts.extend(auth_mounts);
975
976        if config.ca_bundle_ref.is_some() {
977            volume_mounts.push(build_ca_bundle_volume_mount());
978        }
979
980        Ok(Container {
981            name: super::transport::TRANSPORT_SIDECAR_NAME.to_string(),
982            image: Some(data_mover_image()),
983            command: Some(vec!["/bin/kaniop-data-mover".to_string()]),
984            args: Some(vec![
985                "transport".to_string(),
986                "--operation-doc".to_string(),
987                config.operation_doc_json.clone(),
988            ]),
989            env: Some(env_vars),
990            volume_mounts: Some(volume_mounts),
991            security_context: Some(hardened_security_context()),
992            resources: Some(default_resource_requirements()),
993            ..Container::default()
994        })
995    }
996}
997
998fn replication_type(
999    source_role: KanidmServerRole,
1000    target_role: KanidmServerRole,
1001) -> Option<ReplicationType> {
1002    match (source_role, target_role) {
1003        (
1004            KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
1005            KanidmServerRole::WriteReplicaNoUi | KanidmServerRole::WriteReplica,
1006        ) => Some(ReplicationType::MutualPull),
1007
1008        (
1009            KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
1010            KanidmServerRole::ReadOnlyReplica,
1011        ) => Some(ReplicationType::AllowPull),
1012        (
1013            KanidmServerRole::ReadOnlyReplica,
1014            KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
1015        ) => Some(ReplicationType::Pull),
1016        (KanidmServerRole::ReadOnlyReplica, KanidmServerRole::ReadOnlyReplica) => None,
1017    }
1018}
1019
1020#[cfg(test)]
1021mod tests {
1022    use super::{
1023        StatefulSetApplyStrategy, StatefulSetExt, TLS_SECRET_HASH_ANNOTATION,
1024        classify_statefulset_change, preserve_defaulted_statefulset_fields,
1025    };
1026    use crate::kanidm::crd::{
1027        Kanidm, KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
1028    };
1029    use k8s_openapi::api::apps::v1::{
1030        StatefulSet, StatefulSetPersistentVolumeClaimRetentionPolicy,
1031    };
1032    use k8s_openapi::api::core::v1::{
1033        EmptyDirVolumeSource, EphemeralVolumeSource, PersistentVolumeClaim,
1034        PersistentVolumeClaimSpec, Volume,
1035    };
1036    use kube::api::ObjectMeta;
1037
1038    fn create_kanidm_with_storage(storage: Option<KanidmStorage>) -> Kanidm {
1039        Kanidm {
1040            spec: KanidmSpec {
1041                storage,
1042                ..Default::default()
1043            },
1044            ..Default::default()
1045        }
1046    }
1047
1048    pub(super) fn create_kanidm_with_replica_group() -> (Kanidm, ReplicaGroup) {
1049        let replica_group = ReplicaGroup {
1050            name: "default".to_string(),
1051            replicas: 1,
1052            ..Default::default()
1053        };
1054        let kanidm = Kanidm {
1055            metadata: ObjectMeta {
1056                name: Some("test".to_string()),
1057                namespace: Some("default".to_string()),
1058                ..Default::default()
1059            },
1060            spec: KanidmSpec {
1061                domain: "idm.example.com".to_string(),
1062                replica_groups: vec![replica_group.clone()],
1063                ..Default::default()
1064            },
1065            ..Default::default()
1066        };
1067        (kanidm, replica_group)
1068    }
1069
1070    #[test]
1071    fn test_create_statefulset_with_tls_secret_hash_annotation() {
1072        let (kanidm, replica_group) = create_kanidm_with_replica_group();
1073        let sts = kanidm
1074            .create_statefulset(&replica_group, Some("abc123"), None)
1075            .unwrap();
1076
1077        let annotations = sts
1078            .spec
1079            .unwrap()
1080            .template
1081            .metadata
1082            .unwrap()
1083            .annotations
1084            .unwrap();
1085        assert_eq!(
1086            annotations.get(TLS_SECRET_HASH_ANNOTATION),
1087            Some(&"abc123".to_string())
1088        );
1089    }
1090
1091    #[test]
1092    fn test_create_statefulset_without_tls_secret_hash_annotation() {
1093        let (kanidm, replica_group) = create_kanidm_with_replica_group();
1094        let sts = kanidm
1095            .create_statefulset(&replica_group, None, None)
1096            .unwrap();
1097
1098        let annotations = sts.spec.unwrap().template.metadata.unwrap().annotations;
1099        assert!(annotations.is_none());
1100    }
1101
1102    #[test]
1103    fn test_generate_volumes_without_storage() {
1104        let kanidm = create_kanidm_with_storage(None);
1105        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1106
1107        assert_eq!(volumes.clone().len(), 1);
1108        assert_eq!(volumes.clone().first().unwrap().name, "kanidm-data");
1109        assert!(volumes.first().unwrap().empty_dir.is_some());
1110        assert!(volume_claim_template.is_none());
1111    }
1112
1113    fn generated_statefulset() -> StatefulSet {
1114        let (kanidm, replica_group) = create_kanidm_with_replica_group();
1115        kanidm
1116            .create_statefulset(&replica_group, None, None)
1117            .unwrap()
1118    }
1119
1120    #[test]
1121    fn statefulset_mutable_change_uses_apply() {
1122        let current = generated_statefulset();
1123        let mut desired = current.clone();
1124        desired.spec.as_mut().unwrap().replicas = Some(2);
1125
1126        assert_eq!(
1127            classify_statefulset_change(&current, &desired),
1128            StatefulSetApplyStrategy::Apply
1129        );
1130    }
1131
1132    #[test]
1133    fn statefulset_selector_change_requires_recreation() {
1134        let current = generated_statefulset();
1135        let mut desired = current.clone();
1136        desired
1137            .spec
1138            .as_mut()
1139            .unwrap()
1140            .selector
1141            .match_labels
1142            .get_or_insert_default()
1143            .insert("immutable".to_string(), "changed".to_string());
1144
1145        assert_eq!(
1146            classify_statefulset_change(&current, &desired),
1147            StatefulSetApplyStrategy::Recreate {
1148                immutable_fields: vec!["spec.selector"]
1149            }
1150        );
1151    }
1152
1153    #[test]
1154    fn statefulset_service_name_change_requires_recreation() {
1155        let current = generated_statefulset();
1156        let mut desired = current.clone();
1157        desired.spec.as_mut().unwrap().service_name = Some("different".to_string());
1158
1159        assert_eq!(
1160            classify_statefulset_change(&current, &desired),
1161            StatefulSetApplyStrategy::Recreate {
1162                immutable_fields: vec!["spec.serviceName"]
1163            }
1164        );
1165    }
1166
1167    #[test]
1168    fn statefulset_pod_management_default_does_not_recreate() {
1169        let mut current = generated_statefulset();
1170        current.spec.as_mut().unwrap().pod_management_policy = Some("OrderedReady".to_string());
1171        let mut desired = generated_statefulset();
1172        preserve_defaulted_statefulset_fields(&mut desired, &current);
1173
1174        assert_eq!(
1175            classify_statefulset_change(&current, &desired),
1176            StatefulSetApplyStrategy::Apply
1177        );
1178    }
1179
1180    #[test]
1181    fn statefulset_non_default_pod_management_policy_requires_recreation() {
1182        let mut current = generated_statefulset();
1183        current.spec.as_mut().unwrap().pod_management_policy = Some("Parallel".to_string());
1184        let mut desired = generated_statefulset();
1185        preserve_defaulted_statefulset_fields(&mut desired, &current);
1186
1187        assert_eq!(
1188            classify_statefulset_change(&current, &desired),
1189            StatefulSetApplyStrategy::Recreate {
1190                immutable_fields: vec!["spec.podManagementPolicy"]
1191            }
1192        );
1193    }
1194
1195    #[test]
1196    fn statefulset_volume_claim_template_change_is_non_destructive() {
1197        let mut current = generated_statefulset();
1198        current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1199            metadata: ObjectMeta {
1200                name: Some("kanidm-data".to_string()),
1201                ..Default::default()
1202            },
1203            spec: Some(PersistentVolumeClaimSpec {
1204                storage_class_name: Some("old".to_string()),
1205                ..Default::default()
1206            }),
1207            ..Default::default()
1208        }]);
1209        let mut desired = current.clone();
1210        desired
1211            .spec
1212            .as_mut()
1213            .unwrap()
1214            .volume_claim_templates
1215            .as_mut()
1216            .unwrap()[0]
1217            .spec
1218            .as_mut()
1219            .unwrap()
1220            .storage_class_name = Some("new".to_string());
1221
1222        assert_eq!(
1223            classify_statefulset_change(&current, &desired),
1224            StatefulSetApplyStrategy::Apply
1225        );
1226    }
1227
1228    #[test]
1229    fn statefulset_storage_class_defaulting_preserves_live_value() {
1230        let mut current = generated_statefulset();
1231        current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1232            metadata: ObjectMeta {
1233                name: Some("kanidm-data".to_string()),
1234                ..Default::default()
1235            },
1236            spec: Some(PersistentVolumeClaimSpec {
1237                storage_class_name: Some("fast".to_string()),
1238                ..Default::default()
1239            }),
1240            ..Default::default()
1241        }]);
1242        let mut desired = current.clone();
1243        desired
1244            .spec
1245            .as_mut()
1246            .unwrap()
1247            .volume_claim_templates
1248            .as_mut()
1249            .unwrap()[0]
1250            .spec
1251            .as_mut()
1252            .unwrap()
1253            .storage_class_name = None;
1254        preserve_defaulted_statefulset_fields(&mut desired, &current);
1255
1256        // The CR cannot distinguish omission from removal after creation,
1257        // so compatibility/defaulting wins: live storageClassName is preserved.
1258        assert_eq!(
1259            desired
1260                .spec
1261                .as_ref()
1262                .unwrap()
1263                .volume_claim_templates
1264                .as_ref()
1265                .unwrap()[0]
1266                .spec
1267                .as_ref()
1268                .unwrap()
1269                .storage_class_name,
1270            Some("fast".to_string())
1271        );
1272        assert_eq!(
1273            classify_statefulset_change(&current, &desired),
1274            StatefulSetApplyStrategy::Apply
1275        );
1276    }
1277
1278    #[test]
1279    fn statefulset_server_defaults_do_not_require_recreation() {
1280        let mut desired = generated_statefulset();
1281        desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1282            metadata: ObjectMeta {
1283                name: Some("kanidm-data".to_string()),
1284                ..Default::default()
1285            },
1286            spec: Some(PersistentVolumeClaimSpec::default()),
1287            ..Default::default()
1288        }]);
1289        let mut current = desired.clone();
1290        let current_spec = current.spec.as_mut().unwrap();
1291        current_spec.pod_management_policy = Some("OrderedReady".to_string());
1292        current_spec.volume_claim_templates.as_mut().unwrap()[0]
1293            .spec
1294            .as_mut()
1295            .unwrap()
1296            .volume_mode = Some("Filesystem".to_string());
1297
1298        preserve_defaulted_statefulset_fields(&mut desired, &current);
1299
1300        assert_eq!(
1301            classify_statefulset_change(&current, &desired),
1302            StatefulSetApplyStrategy::Apply
1303        );
1304    }
1305
1306    #[test]
1307    fn statefulset_delete_retention_blocks_automatic_recreation() {
1308        let mut current = generated_statefulset();
1309        current
1310            .spec
1311            .as_mut()
1312            .unwrap()
1313            .persistent_volume_claim_retention_policy =
1314            Some(StatefulSetPersistentVolumeClaimRetentionPolicy {
1315                when_deleted: Some("Delete".to_string()),
1316                when_scaled: None,
1317            });
1318        let mut desired = current.clone();
1319        desired
1320            .spec
1321            .as_mut()
1322            .unwrap()
1323            .selector
1324            .match_labels
1325            .get_or_insert_default()
1326            .insert("immutable".to_string(), "changed".to_string());
1327
1328        assert_eq!(
1329            classify_statefulset_change(&current, &desired),
1330            StatefulSetApplyStrategy::Apply
1331        );
1332    }
1333
1334    #[test]
1335    fn test_generate_volumes_with_emptydir() {
1336        let storage = Some(KanidmStorage {
1337            empty_dir: Some(EmptyDirVolumeSource::default()),
1338            ..Default::default()
1339        });
1340        let kanidm = create_kanidm_with_storage(storage);
1341        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1342
1343        assert_eq!(volumes.clone().len(), 1);
1344        assert!(
1345            volumes
1346                .iter()
1347                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1348        );
1349        assert!(volume_claim_template.is_none());
1350    }
1351
1352    #[test]
1353    fn test_generate_volumes_with_emptydir_and_ephemeral() {
1354        let storage = Some(KanidmStorage {
1355            empty_dir: Some(EmptyDirVolumeSource::default()),
1356            ephemeral: Some(EphemeralVolumeSource::default()),
1357            ..Default::default()
1358        });
1359        let kanidm = create_kanidm_with_storage(storage);
1360        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1361
1362        assert_eq!(volumes.clone().len(), 1);
1363        assert!(
1364            volumes
1365                .iter()
1366                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1367        );
1368        assert!(volume_claim_template.is_none());
1369    }
1370
1371    #[test]
1372    fn test_generate_volumes_with_emptydir_ephemeral_and_volumeclaimtemplate() {
1373        let storage = Some(KanidmStorage {
1374            empty_dir: Some(EmptyDirVolumeSource::default()),
1375            ephemeral: Some(EphemeralVolumeSource::default()),
1376            volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1377        });
1378        let kanidm = create_kanidm_with_storage(storage);
1379        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1380
1381        assert_eq!(volumes.len(), 1);
1382        assert!(
1383            volumes
1384                .iter()
1385                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1386        );
1387        assert!(volume_claim_template.is_none());
1388    }
1389
1390    #[test]
1391    fn test_generate_volumes_with_ephemeral() {
1392        let storage = Some(KanidmStorage {
1393            ephemeral: Some(EphemeralVolumeSource::default()),
1394            ..Default::default()
1395        });
1396        let kanidm = create_kanidm_with_storage(storage);
1397        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1398
1399        assert_eq!(volumes.len(), 1);
1400        assert!(
1401            volumes
1402                .iter()
1403                .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
1404        );
1405        assert!(volume_claim_template.is_none());
1406    }
1407
1408    #[test]
1409    fn test_generate_volumes_with_ephemeral_and_volumeclaimtemplate() {
1410        let storage = Some(KanidmStorage {
1411            ephemeral: Some(EphemeralVolumeSource::default()),
1412            volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1413            ..Default::default()
1414        });
1415        let kanidm = create_kanidm_with_storage(storage);
1416        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1417
1418        assert_eq!(volumes.len(), 1);
1419        assert!(
1420            volumes
1421                .iter()
1422                .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
1423        );
1424        assert!(volume_claim_template.is_none());
1425    }
1426
1427    #[test]
1428    fn test_generate_volumes_with_volumeclaimtemplate() {
1429        let storage = Some(KanidmStorage {
1430            volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1431            ..Default::default()
1432        });
1433        let kanidm = create_kanidm_with_storage(storage);
1434        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1435
1436        assert!(volumes.is_empty());
1437        assert!(volume_claim_template.is_some());
1438    }
1439
1440    #[test]
1441    fn test_generate_volumes_with_existing_volumes() {
1442        let existing_volume = Volume {
1443            name: "existing-volume".to_string(),
1444            ..Volume::default()
1445        };
1446        let kanidm = create_kanidm_with_storage(None);
1447        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![existing_volume.clone()]);
1448
1449        assert_eq!(volumes.len(), 2);
1450        assert!(volumes.clone().iter().any(|v| v.name == "existing-volume"));
1451        assert!(
1452            volumes
1453                .iter()
1454                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1455        );
1456        assert!(volume_claim_template.is_none());
1457    }
1458
1459    #[test]
1460    fn test_generate_volumes_with_multiple_existing_volumes() {
1461        let existing_volume1 = Volume {
1462            name: "existing-volume-1".to_string(),
1463            ..Volume::default()
1464        };
1465        let existing_volume2 = Volume {
1466            name: "existing-volume-2".to_string(),
1467            ..Volume::default()
1468        };
1469        let kanidm = create_kanidm_with_storage(None);
1470        let (volumes, volume_claim_template) =
1471            kanidm.expand_storage(vec![existing_volume1.clone(), existing_volume2.clone()]);
1472
1473        assert_eq!(volumes.len(), 3);
1474        assert!(
1475            volumes
1476                .clone()
1477                .iter()
1478                .any(|v| v.name == "existing-volume-1")
1479        );
1480        assert!(
1481            volumes
1482                .clone()
1483                .iter()
1484                .any(|v| v.name == "existing-volume-2")
1485        );
1486        assert!(
1487            volumes
1488                .iter()
1489                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1490        );
1491        assert!(volume_claim_template.is_none());
1492    }
1493
1494    #[test]
1495    fn statefulset_storage_class_omission_preserves_live() {
1496        let mut current = generated_statefulset();
1497        current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1498            metadata: ObjectMeta {
1499                name: Some("kanidm-data".to_string()),
1500                ..Default::default()
1501            },
1502            spec: Some(PersistentVolumeClaimSpec {
1503                storage_class_name: Some("standard".to_string()),
1504                ..Default::default()
1505            }),
1506            ..Default::default()
1507        }]);
1508        let mut desired = generated_statefulset();
1509        desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1510            metadata: ObjectMeta {
1511                name: Some("kanidm-data".to_string()),
1512                ..Default::default()
1513            },
1514            spec: Some(PersistentVolumeClaimSpec {
1515                storage_class_name: None,
1516                ..Default::default()
1517            }),
1518            ..Default::default()
1519        }]);
1520        preserve_defaulted_statefulset_fields(&mut desired, &current);
1521
1522        // Omission in desired should preserve the live storageClassName
1523        assert_eq!(
1524            desired
1525                .spec
1526                .as_ref()
1527                .unwrap()
1528                .volume_claim_templates
1529                .as_ref()
1530                .unwrap()[0]
1531                .spec
1532                .as_ref()
1533                .unwrap()
1534                .storage_class_name,
1535            Some("standard".to_string())
1536        );
1537    }
1538
1539    #[test]
1540    fn statefulset_storage_class_explicit_non_null_desired_is_preserved() {
1541        let mut current = generated_statefulset();
1542        current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1543            metadata: ObjectMeta {
1544                name: Some("kanidm-data".to_string()),
1545                ..Default::default()
1546            },
1547            spec: Some(PersistentVolumeClaimSpec {
1548                storage_class_name: Some("old".to_string()),
1549                ..Default::default()
1550            }),
1551            ..Default::default()
1552        }]);
1553        let mut desired = generated_statefulset();
1554        desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1555            metadata: ObjectMeta {
1556                name: Some("kanidm-data".to_string()),
1557                ..Default::default()
1558            },
1559            spec: Some(PersistentVolumeClaimSpec {
1560                storage_class_name: Some("new".to_string()),
1561                ..Default::default()
1562            }),
1563            ..Default::default()
1564        }]);
1565        // Only defaulting, not live-preservation (desired is non-None)
1566        preserve_defaulted_statefulset_fields(&mut desired, &current);
1567
1568        // Explicit non-None desired value wins
1569        assert_eq!(
1570            desired
1571                .spec
1572                .as_ref()
1573                .unwrap()
1574                .volume_claim_templates
1575                .as_ref()
1576                .unwrap()[0]
1577                .spec
1578                .as_ref()
1579                .unwrap()
1580                .storage_class_name,
1581            Some("new".to_string())
1582        );
1583    }
1584}
1585
1586#[cfg(all(test, feature = "integration-test"))]
1587mod integration_test {
1588    use super::{REPLICATION_CONFIG_IMAGE, REPLICATION_CONFIG_SCRIPT};
1589
1590    use std::fs;
1591    use std::path::Path;
1592
1593    use tempfile::tempdir;
1594    use testcontainers::ContainerRequest;
1595    use testcontainers::GenericImage;
1596    use testcontainers::ImageExt;
1597    use testcontainers::core::Mount;
1598    use testcontainers::runners::AsyncRunner;
1599    use tokio::io::{AsyncBufReadExt, BufReader};
1600
1601    struct TestCase<'a> {
1602        env_vars: Vec<(&'a str, &'a str)>,
1603        expected_result: &'a str,
1604    }
1605
1606    async fn run_test_case(
1607        image_parts: &[&str],
1608        cmd: &[&str],
1609        tmp_dir_path: &str,
1610        env_vars: &[(&str, &str)],
1611        expected_result: &str,
1612    ) {
1613        let container = GenericImage::new(image_parts[0], image_parts[1]);
1614        let mut container_request: ContainerRequest<GenericImage> = container.clone().into();
1615
1616        for (key, value) in env_vars {
1617            container_request =
1618                container_request.with_env_var((*key).to_string(), (*value).to_string());
1619        }
1620
1621        let container = container_request
1622            .with_cmd(cmd.iter().map(|&s| s.to_string()))
1623            .with_mount(Mount::bind_mount(tmp_dir_path.to_string(), "/tmp"))
1624            .with_user(nix::unistd::getuid().to_string())
1625            .start()
1626            .await
1627            .unwrap();
1628
1629        let stdout = container.stdout(true);
1630        let mut stdout_reader = BufReader::new(stdout).lines();
1631        let mut stdout_lines = Vec::new();
1632        while let Some(l) = stdout_reader.next_line().await.unwrap() {
1633            stdout_lines.push(l);
1634        }
1635        dbg!(stdout_lines.join("\n"));
1636
1637        let stderr = container.stderr(true);
1638        let mut stderr_reader = BufReader::new(stderr).lines();
1639        let mut stderr_lines = Vec::new();
1640        while let Some(l) = stderr_reader.next_line().await.unwrap() {
1641            stderr_lines.push(l);
1642        }
1643        dbg!(stderr_lines.join("\n"));
1644
1645        let server_toml_path = Path::new(tmp_dir_path).join("server.toml");
1646        let content = fs::read_to_string(server_toml_path).expect("Unable to read server.toml");
1647        assert_eq!(content, expected_result);
1648    }
1649
1650    #[tokio::test]
1651    async fn test_replication_config_generation() {
1652        let image_parts = REPLICATION_CONFIG_IMAGE.split(':').collect::<Vec<&str>>();
1653        let cmd = ["--script", REPLICATION_CONFIG_SCRIPT];
1654        let tmp_dir = tempdir().unwrap();
1655        let tmp_dir_path = tmp_dir.path().to_str().unwrap().to_string();
1656
1657        let test_cases = vec![
1658            TestCase {
1659                env_vars: vec![
1660                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1661                    ("REPLICATION_PORT", "8444"),
1662                    ("BIND_ADDRESS", "0.0.0.0"),
1663                    ("KANIDM_NAME", "kanidm-test"),
1664                    ("POD_NAME", "kanidm-test-default-0"),
1665                    ("KANIOP_REPLICATION_ENABLED", "true"),
1666                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1667                    (
1668                        "KANIDM_TEST_DEFAULT_0_HOST",
1669                        "kanidm-test-default-0.kanidm-test",
1670                    ),
1671                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1672                    (
1673                        "KANIDM_TEST_DEFAULT_1_HOST",
1674                        "kanidm-test-default-1.kanidm-test",
1675                    ),
1676                ],
1677                expected_result: r#"version = "2"
1678
1679[replication]
1680origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1681bindaddress = "0.0.0.0:8444"
1682
1683"#,
1684            },
1685            TestCase {
1686                env_vars: vec![
1687                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1688                    ("REPLICATION_PORT", "8444"),
1689                    ("BIND_ADDRESS", "0.0.0.0"),
1690                    ("KANIDM_NAME", "kanidm-test"),
1691                    ("POD_NAME", "kanidm-test-default-0"),
1692                    ("KANIOP_REPLICATION_ENABLED", "true"),
1693                    (
1694                        "EXTERNAL_REPLICATION_NODE_HOST_0",
1695                        "repl://external-host-0:8444",
1696                    ),
1697                    (
1698                        "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1699                        "dummy-cert-external-host-0",
1700                    ),
1701                    ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1702                    ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1703                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1704                    (
1705                        "KANIDM_TEST_DEFAULT_0_HOST",
1706                        "kanidm-test-default-0.kanidm-test",
1707                    ),
1708                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1709                    (
1710                        "KANIDM_TEST_DEFAULT_1_HOST",
1711                        "kanidm-test-default-1.kanidm-test",
1712                    ),
1713                ],
1714                expected_result: r#"version = "2"
1715
1716[replication]
1717origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1718bindaddress = "0.0.0.0:8444"
1719
1720[replication."repl://external-host-0:8444"]
1721type = "mutual-pull"
1722partner_cert = "dummy-cert-external-host-0"
1723automatic_refresh = true
1724
1725"#,
1726            },
1727            TestCase {
1728                env_vars: vec![
1729                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1730                    ("REPLICATION_PORT", "8444"),
1731                    ("BIND_ADDRESS", "0.0.0.0"),
1732                    ("KANIDM_NAME", "kanidm-test"),
1733                    ("POD_NAME", "kanidm-test-default-0"),
1734                    ("KANIOP_REPLICATION_ENABLED", "true"),
1735                    (
1736                        "EXTERNAL_REPLICATION_NODE_HOST_0",
1737                        "repl://external-host-0:8444",
1738                    ),
1739                    ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1740                    ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1741                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1742                    (
1743                        "KANIDM_TEST_DEFAULT_0_HOST",
1744                        "kanidm-test-default-0.kanidm-test",
1745                    ),
1746                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1747                    (
1748                        "KANIDM_TEST_DEFAULT_1_HOST",
1749                        "kanidm-test-default-1.kanidm-test",
1750                    ),
1751                ],
1752                expected_result: r#"version = "2"
1753
1754[replication]
1755origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1756bindaddress = "0.0.0.0:8444"
1757
1758"#,
1759            },
1760            TestCase {
1761                env_vars: vec![
1762                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1763                    ("REPLICATION_PORT", "8444"),
1764                    ("BIND_ADDRESS", "0.0.0.0"),
1765                    ("KANIDM_NAME", "kanidm-test"),
1766                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1767                    ("POD_NAME", "kanidm-test-default-0"),
1768                    ("KANIOP_REPLICATION_ENABLED", "true"),
1769                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1770                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1771                    (
1772                        "KANIDM_TEST_DEFAULT_0_HOST",
1773                        "kanidm-test-default-0.kanidm-test",
1774                    ),
1775                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1776                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1777                    (
1778                        "KANIDM_TEST_DEFAULT_1_HOST",
1779                        "kanidm-test-default-1.kanidm-test",
1780                    ),
1781                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1782                    ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1783                    (
1784                        "KANIDM_TEST_DEFAULT_3_HOST",
1785                        "kanidm-test-default-3.kanidm-test",
1786                    ),
1787                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1788                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1789                    (
1790                        "KANIDM_TEST_READ_REPLICA_0_HOST",
1791                        "kanidm-test-read-replica-0.kanidm-test",
1792                    ),
1793                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1794                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1795                    (
1796                        "KANIDM_TEST_READ_REPLICA_1_HOST",
1797                        "kanidm-test-read-replica-1.kanidm-test",
1798                    ),
1799                ],
1800                expected_result: r#"version = "2"
1801
1802[replication]
1803origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1804bindaddress = "0.0.0.0:8444"
1805
1806[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1807type = "mutual-pull"
1808partner_cert = "dummy-cert-default-1"
1809automatic_refresh = false
1810
1811[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1812type = "mutual-pull"
1813partner_cert = "dummy-cert-default-3"
1814automatic_refresh = false
1815
1816[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1817type = "allow-pull"
1818consumer_cert = "dummy-cert-read-replica-0"
1819
1820[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1821type = "allow-pull"
1822consumer_cert = "dummy-cert-read-replica-1"
1823
1824"#,
1825            },
1826            TestCase {
1827                env_vars: vec![
1828                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1829                    ("REPLICATION_PORT", "8444"),
1830                    ("BIND_ADDRESS", "0.0.0.0"),
1831                    ("KANIDM_NAME", "kanidm-test"),
1832                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1833                    ("POD_NAME", "kanidm-test-default-1"),
1834                    ("KANIOP_REPLICATION_ENABLED", "true"),
1835                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1836                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1837                    (
1838                        "KANIDM_TEST_DEFAULT_0_HOST",
1839                        "kanidm-test-default-0.kanidm-test",
1840                    ),
1841                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1842                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1843                    (
1844                        "KANIDM_TEST_DEFAULT_1_HOST",
1845                        "kanidm-test-default-1.kanidm-test",
1846                    ),
1847                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1848                    ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1849                    (
1850                        "KANIDM_TEST_DEFAULT_3_HOST",
1851                        "kanidm-test-default-3.kanidm-test",
1852                    ),
1853                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1854                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1855                    (
1856                        "KANIDM_TEST_READ_REPLICA_0_HOST",
1857                        "kanidm-test-read-replica-0.kanidm-test",
1858                    ),
1859                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1860                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1861                    (
1862                        "KANIDM_TEST_READ_REPLICA_1_HOST",
1863                        "kanidm-test-read-replica-1.kanidm-test",
1864                    ),
1865                ],
1866                expected_result: r#"version = "2"
1867
1868[replication]
1869origin = "repl://kanidm-test-default-1.kanidm-test:8444"
1870bindaddress = "0.0.0.0:8444"
1871
1872[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1873type = "mutual-pull"
1874partner_cert = "dummy-cert-default-0"
1875automatic_refresh = true
1876
1877[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1878type = "mutual-pull"
1879partner_cert = "dummy-cert-default-3"
1880automatic_refresh = false
1881
1882[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1883type = "allow-pull"
1884consumer_cert = "dummy-cert-read-replica-0"
1885
1886[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1887type = "allow-pull"
1888consumer_cert = "dummy-cert-read-replica-1"
1889
1890"#,
1891            },
1892            TestCase {
1893                env_vars: vec![
1894                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1895                    ("REPLICATION_PORT", "8444"),
1896                    ("BIND_ADDRESS", "0.0.0.0"),
1897                    ("KANIDM_NAME", "kanidm-test"),
1898                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1899                    ("POD_NAME", "kanidm-test-default-3"),
1900                    ("KANIOP_REPLICATION_ENABLED", "true"),
1901                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1902                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1903                    (
1904                        "KANIDM_TEST_DEFAULT_0_HOST",
1905                        "kanidm-test-default-0.kanidm-test",
1906                    ),
1907                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1908                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1909                    (
1910                        "KANIDM_TEST_DEFAULT_1_HOST",
1911                        "kanidm-test-default-1.kanidm-test",
1912                    ),
1913                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1914                    ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1915                    (
1916                        "KANIDM_TEST_DEFAULT_3_HOST",
1917                        "kanidm-test-default-3.kanidm-test",
1918                    ),
1919                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1920                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1921                    (
1922                        "KANIDM_TEST_READ_REPLICA_0_HOST",
1923                        "kanidm-test-read-replica-0.kanidm-test",
1924                    ),
1925                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1926                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1927                    (
1928                        "KANIDM_TEST_READ_REPLICA_1_HOST",
1929                        "kanidm-test-read-replica-1.kanidm-test",
1930                    ),
1931                ],
1932                expected_result: r#"version = "2"
1933
1934[replication]
1935origin = "repl://kanidm-test-default-3.kanidm-test:8444"
1936bindaddress = "0.0.0.0:8444"
1937
1938[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1939type = "mutual-pull"
1940partner_cert = "dummy-cert-default-0"
1941automatic_refresh = true
1942
1943[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1944type = "mutual-pull"
1945partner_cert = "dummy-cert-default-1"
1946automatic_refresh = false
1947
1948[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1949type = "allow-pull"
1950consumer_cert = "dummy-cert-read-replica-0"
1951
1952[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1953type = "allow-pull"
1954consumer_cert = "dummy-cert-read-replica-1"
1955
1956"#,
1957            },
1958            TestCase {
1959                env_vars: vec![
1960                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1961                    ("REPLICATION_PORT", "8444"),
1962                    ("BIND_ADDRESS", "0.0.0.0"),
1963                    ("KANIDM_NAME", "kanidm-test"),
1964                    ("REPLICA_GROUP", "read-replica"),
1965                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1966                    ("POD_NAME", "kanidm-test-read-replica-0"),
1967                    ("KANIOP_REPLICATION_ENABLED", "true"),
1968                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1969                    ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1970                    (
1971                        "KANIDM_TEST_DEFAULT_0_HOST",
1972                        "kanidm-test-default-0.kanidm-test",
1973                    ),
1974                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1975                    ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1976                    (
1977                        "KANIDM_TEST_DEFAULT_1_HOST",
1978                        "kanidm-test-default-1.kanidm-test",
1979                    ),
1980                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1981                    ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1982                    (
1983                        "KANIDM_TEST_DEFAULT_3_HOST",
1984                        "kanidm-test-default-3.kanidm-test",
1985                    ),
1986                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1987                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1988                    (
1989                        "KANIDM_TEST_READ_REPLICA_0_HOST",
1990                        "kanidm-test-read-replica-0.kanidm-test",
1991                    ),
1992                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1993                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1994                    (
1995                        "KANIDM_TEST_READ_REPLICA_1_HOST",
1996                        "kanidm-test-read-replica-1.kanidm-test",
1997                    ),
1998                ],
1999                expected_result: r#"version = "2"
2000
2001[replication]
2002origin = "repl://kanidm-test-read-replica-0.kanidm-test:8444"
2003bindaddress = "0.0.0.0:8444"
2004
2005[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
2006type = "pull"
2007supplier_cert = "dummy-cert-default-0"
2008automatic_refresh = true
2009
2010[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
2011type = "pull"
2012supplier_cert = "dummy-cert-default-1"
2013automatic_refresh = false
2014
2015[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
2016type = "pull"
2017supplier_cert = "dummy-cert-default-3"
2018automatic_refresh = false
2019
2020"#,
2021            },
2022            TestCase {
2023                env_vars: vec![
2024                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2025                    ("REPLICATION_PORT", "8444"),
2026                    ("BIND_ADDRESS", "0.0.0.0"),
2027                    ("KANIDM_NAME", "kanidm-test"),
2028                    ("REPLICA_GROUP", "read-replica"),
2029                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
2030                    ("POD_NAME", "kanidm-test-read-replica-1"),
2031                    ("KANIOP_REPLICATION_ENABLED", "true"),
2032                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2033                    ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
2034                    (
2035                        "KANIDM_TEST_DEFAULT_0_HOST",
2036                        "kanidm-test-default-0.kanidm-test",
2037                    ),
2038                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2039                    ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
2040                    (
2041                        "KANIDM_TEST_DEFAULT_1_HOST",
2042                        "kanidm-test-default-1.kanidm-test",
2043                    ),
2044                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2045                    ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
2046                    (
2047                        "KANIDM_TEST_DEFAULT_3_HOST",
2048                        "kanidm-test-default-3.kanidm-test",
2049                    ),
2050                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2051                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
2052                    (
2053                        "KANIDM_TEST_READ_REPLICA_0_HOST",
2054                        "kanidm-test-read-replica-0.kanidm-test",
2055                    ),
2056                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2057                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
2058                    (
2059                        "KANIDM_TEST_READ_REPLICA_1_HOST",
2060                        "kanidm-test-read-replica-1.kanidm-test",
2061                    ),
2062                ],
2063                expected_result: r#"version = "2"
2064
2065[replication]
2066origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
2067bindaddress = "0.0.0.0:8444"
2068
2069[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
2070type = "pull"
2071supplier_cert = "dummy-cert-default-0"
2072automatic_refresh = true
2073
2074[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
2075type = "pull"
2076supplier_cert = "dummy-cert-default-1"
2077automatic_refresh = false
2078
2079[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
2080type = "pull"
2081supplier_cert = "dummy-cert-default-3"
2082automatic_refresh = false
2083
2084"#,
2085            },
2086            TestCase {
2087                env_vars: vec![
2088                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2089                    ("REPLICATION_PORT", "8444"),
2090                    ("BIND_ADDRESS", "0.0.0.0"),
2091                    ("KANIDM_NAME", "kanidm-test"),
2092                    ("REPLICA_GROUP", "read-replica"),
2093                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
2094                    ("POD_NAME", "kanidm-test-read-replica-1"),
2095                    (
2096                        "EXTERNAL_REPLICATION_NODE_HOST_0",
2097                        "repl://external-host-0:8444",
2098                    ),
2099                    (
2100                        "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
2101                        "dummy-cert-external-host-0",
2102                    ),
2103                    ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
2104                    ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
2105                    ("KANIOP_REPLICATION_ENABLED", "true"),
2106                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2107                    ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
2108                    (
2109                        "KANIDM_TEST_DEFAULT_0_HOST",
2110                        "kanidm-test-default-0.kanidm-test",
2111                    ),
2112                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2113                    ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
2114                    (
2115                        "KANIDM_TEST_DEFAULT_1_HOST",
2116                        "kanidm-test-default-1.kanidm-test",
2117                    ),
2118                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2119                    ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
2120                    (
2121                        "KANIDM_TEST_DEFAULT_3_HOST",
2122                        "kanidm-test-default-3.kanidm-test",
2123                    ),
2124                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2125                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
2126                    (
2127                        "KANIDM_TEST_READ_REPLICA_0_HOST",
2128                        "kanidm-test-read-replica-0.kanidm-test",
2129                    ),
2130                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2131                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
2132                    (
2133                        "KANIDM_TEST_READ_REPLICA_1_HOST",
2134                        "kanidm-test-read-replica-1.kanidm-test",
2135                    ),
2136                ],
2137                expected_result: r#"version = "2"
2138
2139[replication]
2140origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
2141bindaddress = "0.0.0.0:8444"
2142
2143[replication."repl://external-host-0:8444"]
2144type = "mutual-pull"
2145partner_cert = "dummy-cert-external-host-0"
2146automatic_refresh = true
2147
2148[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
2149type = "pull"
2150supplier_cert = "dummy-cert-default-0"
2151automatic_refresh = true
2152
2153[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
2154type = "pull"
2155supplier_cert = "dummy-cert-default-1"
2156automatic_refresh = false
2157
2158[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
2159type = "pull"
2160supplier_cert = "dummy-cert-default-3"
2161automatic_refresh = false
2162
2163"#,
2164            },
2165            TestCase {
2166                env_vars: vec![
2167                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2168                    ("REPLICATION_PORT", "8444"),
2169                    ("BIND_ADDRESS", "0.0.0.0"),
2170                    ("KANIDM_NAME", "kanidm-test"),
2171                    ("POD_NAME", "kanidm-test-default-0"),
2172                    ("KANIOP_REPLICATION_ENABLED", "true"),
2173                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2174                    ("KANIDM_TEST_DEFAULT_0_HOST", "10.200.20.1"),
2175                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
2176                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2177                    ("KANIDM_TEST_DEFAULT_1_HOST", "10.200.20.2"),
2178                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
2179                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2180                    ("KANIDM_TEST_DEFAULT_3_HOST", "10.200.20.4"),
2181                    ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
2182                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2183                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
2184                    (
2185                        "KANIDM_TEST_READ_REPLICA_0_HOST",
2186                        "kanidm-test-read-replica-0.kanidm-test",
2187                    ),
2188                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2189                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
2190                    (
2191                        "KANIDM_TEST_READ_REPLICA_1_HOST",
2192                        "kanidm-test-read-replica-1.kanidm-test",
2193                    ),
2194                ],
2195                expected_result: r#"version = "2"
2196
2197[replication]
2198origin = "repl://10.200.20.1:8444"
2199bindaddress = "0.0.0.0:8444"
2200
2201[replication."repl://10.200.20.2:8444"]
2202type = "mutual-pull"
2203partner_cert = "dummy-cert-default-1"
2204automatic_refresh = false
2205
2206[replication."repl://10.200.20.4:8444"]
2207type = "mutual-pull"
2208partner_cert = "dummy-cert-default-3"
2209automatic_refresh = false
2210
2211[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
2212type = "allow-pull"
2213consumer_cert = "dummy-cert-read-replica-0"
2214
2215[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
2216type = "allow-pull"
2217consumer_cert = "dummy-cert-read-replica-1"
2218
2219"#,
2220            },
2221        ];
2222
2223        for test_case in test_cases {
2224            run_test_case(
2225                &image_parts,
2226                &cmd,
2227                &tmp_dir_path,
2228                &test_case.env_vars,
2229                test_case.expected_result,
2230            )
2231            .await;
2232        }
2233    }
2234    #[test]
2235    fn backup_enables_generated_config_and_native_online_backup_stanza() {
2236        use crate::kanidm::crd::{KanidmStorage, PersistentVolumeClaimTemplate};
2237        use k8s_openapi::api::core::v1::PersistentVolumeClaimSpec;
2238
2239        use crate::kanidm::reconcile::transport::BackupConfig;
2240
2241        use super::StatefulSetExt;
2242
2243        let (mut kanidm, mut replica_group) = super::tests::create_kanidm_with_replica_group();
2244        replica_group.primary_node = true;
2245        kanidm.spec.replica_groups = vec![replica_group.clone()];
2246        let backup_config = BackupConfig {
2247            schedule: "0 2 * * *".to_string(),
2248            local_versions: 7,
2249            transport: None,
2250        };
2251        kanidm.spec.storage = Some(KanidmStorage {
2252            volume_claim_template: Some(PersistentVolumeClaimTemplate {
2253                metadata: None,
2254                spec: Some(PersistentVolumeClaimSpec::default()),
2255            }),
2256            ..Default::default()
2257        });
2258
2259        let sts = kanidm
2260            .create_statefulset(&replica_group, None, Some(&backup_config))
2261            .unwrap();
2262        let pod = sts.spec.unwrap().template.spec.unwrap();
2263        let init = pod
2264            .init_containers
2265            .unwrap()
2266            .into_iter()
2267            .find(|c| c.name == "kanidm-generate-replication-config")
2268            .unwrap();
2269        let env = init.env.unwrap();
2270        assert!(
2271            env.iter()
2272                .any(|e| e.name == "KANIOP_BACKUP_ENABLED" && e.value.as_deref() == Some("true"))
2273        );
2274        assert!(
2275            env.iter()
2276                .any(|e| e.name == "KANIOP_BACKUP_SCHEDULE"
2277                    && e.value.as_deref() == Some("0 2 * * *"))
2278        );
2279        assert!(
2280            env.iter()
2281                .any(|e| e.name == "KANIOP_BACKUP_VERSIONS" && e.value.as_deref() == Some("7"))
2282        );
2283        let script = init.args.unwrap().join("\n");
2284        assert!(script.contains("[online_backup]"));
2285        assert!(script.contains("env.POD_NAME == env.KANIDM_PRIMARY_NODE"));
2286    }
2287
2288    #[test]
2289    fn transport_sidecar_present_for_primary_group_with_config() {
2290        use super::StatefulSetExt;
2291        use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2292        use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2293
2294        use super::tests::create_kanidm_with_replica_group;
2295        let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2296        replica_group.primary_node = true;
2297        kanidm.spec.replica_groups = vec![replica_group.clone()];
2298
2299        let config = BackupConfig {
2300            schedule: "0 2 * * *".to_string(),
2301            local_versions: 7,
2302            transport: Some(TransportSidecarConfig {
2303                operation_doc_json: r#"{"operation":"transport","bucket":"test"}"#.to_string(),
2304                auth_method: AuthMethod {
2305                    workload_identity: None,
2306                    secret_ref: Some(SecretRef {
2307                        name: "writer-secret".to_string(),
2308                    }),
2309                },
2310                ca_bundle_ref: None,
2311                encryption_key_ref: None,
2312            }),
2313        };
2314
2315        let sts = kanidm
2316            .create_statefulset(&replica_group, None, Some(&config))
2317            .unwrap();
2318        let pod = sts.spec.unwrap().template.spec.unwrap();
2319        let containers = pod.containers;
2320
2321        let sidecar = containers.iter().find(|c| c.name == "data-mover-transport");
2322        assert!(sidecar.is_some());
2323        let sidecar = sidecar.unwrap();
2324        assert_eq!(
2325            sidecar.image.as_deref(),
2326            Some("ghcr.io/pando85/kaniop-data-mover:latest")
2327        );
2328        assert_eq!(
2329            sidecar.command.as_ref().unwrap(),
2330            &vec!["/bin/kaniop-data-mover".to_string()]
2331        );
2332        assert_eq!(
2333            sidecar.args.as_ref().unwrap(),
2334            &vec![
2335                "transport".to_string(),
2336                "--operation-doc".to_string(),
2337                r#"{"operation":"transport","bucket":"test"}"#.to_string(),
2338            ]
2339        );
2340
2341        let env = sidecar.env.as_ref().unwrap();
2342        assert!(env.iter().any(|e| e.name == "POD_NAME"));
2343        assert!(env.iter().any(|e| e.name == "KANIDM_PRIMARY_NODE"));
2344        assert!(env.iter().any(|e| e.name == "AWS_ACCESS_KEY_ID"));
2345
2346        let mounts = sidecar.volume_mounts.as_ref().unwrap();
2347        assert!(
2348            mounts
2349                .iter()
2350                .any(|m| m.name == "kanidm-data" && m.read_only == Some(true))
2351        );
2352        assert!(
2353            mounts
2354                .iter()
2355                .any(|m| m.name == "kanidm-tmp" && m.mount_path == "/tmp")
2356        );
2357
2358        let volumes = pod.volumes.as_ref().unwrap();
2359        assert!(volumes.iter().any(|v| v.name == "kanidm-tmp"));
2360
2361        let sc = sidecar.security_context.as_ref().unwrap();
2362        assert_eq!(sc.run_as_non_root, Some(true));
2363        assert_eq!(sc.allow_privilege_escalation, Some(false));
2364        assert_eq!(sc.read_only_root_filesystem, Some(true));
2365        assert!(sc.run_as_user.is_none());
2366        assert!(
2367            sc.capabilities
2368                .as_ref()
2369                .unwrap()
2370                .drop
2371                .as_ref()
2372                .unwrap()
2373                .contains(&"ALL".to_string())
2374        );
2375    }
2376
2377    #[test]
2378    fn transport_sidecar_absent_for_non_primary_group() {
2379        use super::StatefulSetExt;
2380        use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2381        use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2382
2383        use super::tests::create_kanidm_with_replica_group;
2384        let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2385        replica_group.primary_node = false;
2386        kanidm.spec.replica_groups = vec![replica_group.clone()];
2387
2388        let config = BackupConfig {
2389            schedule: "0 2 * * *".to_string(),
2390            local_versions: 7,
2391            transport: Some(TransportSidecarConfig {
2392                operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2393                auth_method: AuthMethod {
2394                    workload_identity: None,
2395                    secret_ref: Some(SecretRef {
2396                        name: "writer-secret".to_string(),
2397                    }),
2398                },
2399                ca_bundle_ref: None,
2400                encryption_key_ref: None,
2401            }),
2402        };
2403
2404        let sts = kanidm
2405            .create_statefulset(&replica_group, None, Some(&config))
2406            .unwrap();
2407        let pod = sts.spec.unwrap().template.spec.unwrap();
2408        let containers = pod.containers;
2409
2410        let sidecar = containers.iter().find(|c| c.name == "data-mover-transport");
2411        assert!(sidecar.is_none());
2412    }
2413
2414    #[test]
2415    fn transport_sidecar_absent_without_config() {
2416        use super::StatefulSetExt;
2417        use super::tests::create_kanidm_with_replica_group;
2418        let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2419        replica_group.primary_node = true;
2420        kanidm.spec.replica_groups = vec![replica_group.clone()];
2421
2422        let sts = kanidm
2423            .create_statefulset(&replica_group, None, None)
2424            .unwrap();
2425        let pod = sts.spec.unwrap().template.spec.unwrap();
2426        let containers = pod.containers;
2427
2428        let sidecar = containers.iter().find(|c| c.name == "data-mover-transport");
2429        assert!(sidecar.is_none());
2430    }
2431
2432    #[test]
2433    fn transport_sidecar_with_ca_bundle() {
2434        use super::StatefulSetExt;
2435        use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2436        use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2437
2438        use super::tests::create_kanidm_with_replica_group;
2439        let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2440        replica_group.primary_node = true;
2441        kanidm.spec.replica_groups = vec![replica_group.clone()];
2442
2443        let config = BackupConfig {
2444            schedule: "0 2 * * *".to_string(),
2445            local_versions: 7,
2446            transport: Some(TransportSidecarConfig {
2447                operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2448                auth_method: AuthMethod {
2449                    workload_identity: None,
2450                    secret_ref: Some(SecretRef {
2451                        name: "writer-secret".to_string(),
2452                    }),
2453                },
2454                ca_bundle_ref: Some("ca-config-map".to_string()),
2455                encryption_key_ref: None,
2456            }),
2457        };
2458
2459        let sts = kanidm
2460            .create_statefulset(&replica_group, None, Some(&config))
2461            .unwrap();
2462        let pod = sts.spec.unwrap().template.spec.unwrap();
2463
2464        let sidecar = pod
2465            .containers
2466            .iter()
2467            .find(|c| c.name == "data-mover-transport")
2468            .unwrap();
2469        let env = sidecar.env.as_ref().unwrap();
2470        assert!(env.iter().any(|e| e.name == "SSL_CERT_FILE"));
2471
2472        let mounts = sidecar.volume_mounts.as_ref().unwrap();
2473        assert!(mounts.iter().any(|m| m.name == "ca-bundle"));
2474
2475        let volumes = pod.volumes.as_ref().unwrap();
2476        assert!(volumes.iter().any(|v| v.name == "ca-bundle"));
2477    }
2478
2479    #[test]
2480    fn transport_sidecar_includes_encryption_key_env_when_key_ref_set() {
2481        use super::StatefulSetExt;
2482        use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2483        use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2484
2485        use super::tests::create_kanidm_with_replica_group;
2486        let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2487        replica_group.primary_node = true;
2488        kanidm.spec.replica_groups = vec![replica_group.clone()];
2489
2490        let config = BackupConfig {
2491            schedule: "0 2 * * *".to_string(),
2492            local_versions: 7,
2493            transport: Some(TransportSidecarConfig {
2494                operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2495                auth_method: AuthMethod {
2496                    workload_identity: None,
2497                    secret_ref: Some(SecretRef {
2498                        name: "writer-secret".to_string(),
2499                    }),
2500                },
2501                ca_bundle_ref: None,
2502                encryption_key_ref: Some(SecretRef {
2503                    name: "kek-secret".to_string(),
2504                }),
2505            }),
2506        };
2507
2508        let sts = kanidm
2509            .create_statefulset(&replica_group, None, Some(&config))
2510            .unwrap();
2511        let pod = sts.spec.unwrap().template.spec.unwrap();
2512
2513        let sidecar = pod
2514            .containers
2515            .iter()
2516            .find(|c| c.name == "data-mover-transport")
2517            .unwrap();
2518        let env = sidecar.env.as_ref().unwrap();
2519        let enc_env = env.iter().find(|e| e.name == "KANIOP_ENCRYPTION_KEY");
2520        assert!(
2521            enc_env.is_some(),
2522            "KANIOP_ENCRYPTION_KEY env var must be present"
2523        );
2524        let enc_env = enc_env.unwrap();
2525        let secret_ref = enc_env
2526            .value_from
2527            .as_ref()
2528            .unwrap()
2529            .secret_key_ref
2530            .as_ref()
2531            .unwrap();
2532        assert_eq!(secret_ref.name, "kek-secret");
2533        assert_eq!(secret_ref.key, "encryption-key");
2534    }
2535
2536    #[test]
2537    fn transport_sidecar_omits_encryption_key_env_when_no_key_ref() {
2538        use super::StatefulSetExt;
2539        use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2540        use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2541
2542        use super::tests::create_kanidm_with_replica_group;
2543        let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2544        replica_group.primary_node = true;
2545        kanidm.spec.replica_groups = vec![replica_group.clone()];
2546
2547        let config = BackupConfig {
2548            schedule: "0 2 * * *".to_string(),
2549            local_versions: 7,
2550            transport: Some(TransportSidecarConfig {
2551                operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2552                auth_method: AuthMethod {
2553                    workload_identity: None,
2554                    secret_ref: Some(SecretRef {
2555                        name: "writer-secret".to_string(),
2556                    }),
2557                },
2558                ca_bundle_ref: None,
2559                encryption_key_ref: None,
2560            }),
2561        };
2562
2563        let sts = kanidm
2564            .create_statefulset(&replica_group, None, Some(&config))
2565            .unwrap();
2566        let pod = sts.spec.unwrap().template.spec.unwrap();
2567
2568        let sidecar = pod
2569            .containers
2570            .iter()
2571            .find(|c| c.name == "data-mover-transport")
2572            .unwrap();
2573        let env = sidecar.env.as_ref().unwrap();
2574        assert!(
2575            !env.iter().any(|e| e.name == "KANIOP_ENCRYPTION_KEY"),
2576            "KANIOP_ENCRYPTION_KEY must be absent when key_ref is None"
2577        );
2578    }
2579}