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