Skip to main content

kaniop_operator/kanidm/reconcile/
statefulset.rs

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