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