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