kaniop_operator/kanidm/reconcile/
statefulset.rs

1use super::secret::{REPLICA_SECRET_KEY, SecretExt};
2use super::service::ServiceExt;
3
4use crate::kanidm::crd::{Kanidm, KanidmServerRole, ReplicaGroup, ReplicationType};
5
6use kaniop_k8s_util::resources::merge_containers;
7
8use std::collections::BTreeMap;
9
10use k8s_openapi::api::apps::v1::{StatefulSet, StatefulSetSpec};
11use k8s_openapi::api::core::v1::{
12    Container, ContainerPort, EmptyDirVolumeSource, EnvVar, EnvVarSource, HTTPGetAction,
13    ObjectFieldSelector, PersistentVolumeClaim, PodSpec, PodTemplateSpec, Probe, SecretKeySelector,
14    SecretVolumeSource, Volume, VolumeMount,
15};
16use k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector;
17use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
18use kube::ResourceExt;
19use kube::api::{ObjectMeta, Resource};
20
21pub const REPLICA_GROUP_LABEL: &str = "kanidm.kaniop.rs/replica-group";
22
23// renovate: datasource=docker
24const REPLICATION_CONFIG_IMAGE: &str = "ghcr.io/rash-sh/rash:2.16.1";
25const REPLICATION_CONFIG_SCRIPT: &str = r#"
26- copy:
27    content: |
28      version = "2"
29
30      [replication]
31      origin = "repl://{{ env.POD_NAME }}.{{ env.KANIDM_SERVICE_NAME }}:{{ env.REPLICATION_PORT }}"
32      bindaddress = "0.0.0.0:{{ env.REPLICATION_PORT }}"
33
34      {% for e in env -%}
35      {% if e is startingwith(env.KANIDM_SERVICE_NAME| upper | replace('-', '_')) -%}
36      {% if e == env.POD_NAME | upper | replace('-','_') or e is endingwith("_TYPE") or
37         e + '_TYPE' not in env or env[e + '_TYPE'] == "" -%}
38        {% continue -%}
39      {% endif -%}
40      {% set replica = e | lower | replace('_', '-') -%}
41      [replication."repl://{{ replica }}.{{ env.KANIDM_SERVICE_NAME }}:{{ env.REPLICATION_PORT }}"]
42      {% set type = env[e + '_TYPE'] -%}
43      type = "{{ type }}"
44      {% if type == "mutual-pull" -%}
45      partner_cert = "{{ env[e] }}"
46      {% elif type == "pull" -%}
47      supplier_cert = "{{ env[e] }}"
48      {% else -%}
49      consumer_cert = "{{ env[e] }}"
50      {% endif -%}
51      {% if type != "allow-pull" -%}
52      {% if replica == env.KANIDM_PRIMARY_NODE -%}
53      automatic_refresh = true
54      {% else -%}
55      automatic_refresh = false
56      {% endif -%}
57      {% endif %}
58      {% elif e is startingwith("EXTERNAL_REPLICATION_NODE") -%}
59      {% if e + '_CERT' not in env or e is endingwith("_TYPE") or e is endingwith("_CERT") or e is endingwith("_AUTOMATIC_REFRESH") -%}
60        {% continue -%}
61      {% endif -%}
62      [replication."{{ env[e] }}"]
63      {% set type = env[e + '_TYPE'] -%}
64      type = "{{ type }}"
65      {% if type == "mutual-pull" -%}
66      partner_cert = "{{ env[e + '_CERT'] }}"
67      {% elif type == "pull" -%}
68      supplier_cert = "{{ env[e + '_CERT'] }}"
69      {% else -%}
70      consumer_cert = "{{ env[e + '_CERT'] }}"
71      {% endif -%}
72      {% if type != "allow-pull" -%}
73      automatic_refresh = {{ env[e + '_AUTOMATIC_REFRESH'] }}
74      {% endif %}
75      {% endif %}
76      {%- endfor -%}
77    dest: "{{ env.KANIDM_CONFIG_PATH }}"
78"#;
79const CONTAINER_HTTPS_PORT: i32 = 8443;
80const CONTAINER_REPLICATION_PORT: i32 = 8444;
81const CONTAINER_LDAP_PORT: i32 = 3636;
82const KANIDM_CONFIG_PATH: &str = "/run/kanidm/server.toml";
83const VOLUME_CONFIG_NAME: &str = "kanidm-config";
84const VOLUME_CONFIG_PATH: &str = "/run/kanidm";
85const VOLUME_DATA_NAME: &str = "kanidm-data";
86const VOLUME_DATA_PATH: &str = "/data";
87const VOLUME_TLS_NAME: &str = "kanidm-certs";
88const VOLUME_TLS_PATH: &str = "/etc/kanidm/tls";
89
90pub trait StatefulSetExt {
91    fn statefulset_name(&self, rg_name: &str) -> String;
92    fn create_statefulset(&self, replica_group: &ReplicaGroup) -> StatefulSet;
93}
94
95trait StatefulSetExtPrivate {
96    fn expand_storage(
97        &self,
98        volumes: Vec<Volume>,
99    ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>);
100    fn generate_pod_labels(&self, replica_group: &ReplicaGroup) -> BTreeMap<String, String>;
101    fn generate_labels(&self, pod_labels: &BTreeMap<String, String>) -> BTreeMap<String, String>;
102    fn generate_env_vars(&self, replica_group: &ReplicaGroup) -> Vec<EnvVar>;
103    fn generate_config_volume_mount(&self) -> VolumeMount;
104    fn generate_volume_mounts(&self) -> Vec<VolumeMount>;
105    #[allow(clippy::ptr_arg)]
106    fn generate_init_containers(&self, replica_group: &ReplicaGroup) -> Vec<Container>;
107    fn generate_container_ports(&self) -> Vec<ContainerPort>;
108    fn generate_probe(&self) -> Probe;
109    #[allow(clippy::ptr_arg)]
110    fn generate_containers(
111        &self,
112        env: &Vec<EnvVar>,
113        volume_mounts: &Vec<VolumeMount>,
114        ports: &Vec<ContainerPort>,
115        probe: &Probe,
116        replica_group: &ReplicaGroup,
117    ) -> Vec<Container>;
118    fn generate_dns_policy(&self) -> Option<String>;
119    fn generate_volumes(&self) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>);
120    fn generate_metadata(
121        &self,
122        labels: &BTreeMap<String, String>,
123        replica_group_name: &str,
124    ) -> ObjectMeta;
125}
126
127impl StatefulSetExt for Kanidm {
128    #[inline]
129    fn statefulset_name(&self, rg_name: &str) -> String {
130        format!("{kanidm_name}-{rg_name}", kanidm_name = self.name_any())
131    }
132
133    fn create_statefulset(&self, replica_group: &ReplicaGroup) -> StatefulSet {
134        let pod_labels = self.generate_pod_labels(replica_group);
135        let labels = self.generate_labels(&pod_labels);
136        let env = self.generate_env_vars(replica_group);
137        let init_containers = self.generate_init_containers(replica_group);
138        let ports = self.generate_container_ports();
139        let probe = self.generate_probe();
140        let volume_mounts = self.generate_volume_mounts();
141        let containers =
142            self.generate_containers(&env, &volume_mounts, &ports, &probe, replica_group);
143        let dns_policy = self.generate_dns_policy();
144        let (volumes, volume_claim_templates) = self.generate_volumes();
145
146        StatefulSet {
147            metadata: self.generate_metadata(&labels, &replica_group.name),
148            spec: Some(StatefulSetSpec {
149                replicas: Some(replica_group.replicas),
150                selector: LabelSelector {
151                    match_expressions: None,
152                    match_labels: Some(pod_labels.clone()),
153                },
154                template: PodTemplateSpec {
155                    metadata: Some(ObjectMeta {
156                        labels: Some(pod_labels),
157                        ..ObjectMeta::default()
158                    }),
159                    spec: Some(PodSpec {
160                        containers,
161                        volumes: Some(volumes),
162                        node_selector: replica_group.node_selector.clone(),
163                        affinity: replica_group.affinity.clone(),
164                        tolerations: replica_group.tolerations.clone(),
165                        topology_spread_constraints: replica_group
166                            .topology_spread_constraints
167                            .clone(),
168                        security_context: self.spec.security_context.clone(),
169                        dns_policy,
170                        dns_config: self.spec.dns_config.clone(),
171                        init_containers: Some(init_containers),
172                        host_aliases: self.spec.host_aliases.clone(),
173                        enable_service_links: Some(false),
174                        ..PodSpec::default()
175                    }),
176                },
177                service_name: Some(self.service_name()),
178                persistent_volume_claim_retention_policy: self
179                    .spec
180                    .persistent_volume_claim_retention_policy
181                    .clone(),
182                min_ready_seconds: self.spec.min_ready_seconds,
183                volume_claim_templates,
184                ..StatefulSetSpec::default()
185            }),
186            ..StatefulSet::default()
187        }
188    }
189}
190
191impl StatefulSetExtPrivate for Kanidm {
192    fn generate_pod_labels(&self, replica_group: &ReplicaGroup) -> BTreeMap<String, String> {
193        self.generate_resource_labels()
194            .into_iter()
195            .chain(std::iter::once((
196                REPLICA_GROUP_LABEL.to_string(),
197                replica_group.name.clone(),
198            )))
199            .collect()
200    }
201
202    fn generate_labels(&self, pod_labels: &BTreeMap<String, String>) -> BTreeMap<String, String> {
203        self.labels()
204            .clone()
205            .into_iter()
206            .chain(pod_labels.clone())
207            .collect()
208    }
209
210    fn generate_env_vars(&self, replica_group: &ReplicaGroup) -> Vec<EnvVar> {
211        self.spec
212            .env
213            .clone()
214            .unwrap_or_default()
215            .into_iter()
216            .chain(vec![
217                EnvVar {
218                    name: "KANIDM_DOMAIN".to_string(),
219                    value: Some(self.spec.domain.clone()),
220                    ..EnvVar::default()
221                },
222                EnvVar {
223                    name: "KANIDM_ORIGIN".to_string(),
224                    value: Some(format!("https://{}", self.spec.domain.clone())),
225                    ..EnvVar::default()
226                },
227                EnvVar {
228                    name: "KANIDM_DB_PATH".to_string(),
229                    value: Some(format!("{VOLUME_DATA_PATH}/kanidm.db")),
230                    ..EnvVar::default()
231                },
232                EnvVar {
233                    name: "KANIDM_TLS_CHAIN".to_string(),
234                    value: Some(format!("{VOLUME_TLS_PATH}/tls.crt")),
235                    ..EnvVar::default()
236                },
237                EnvVar {
238                    name: "KANIDM_TLS_KEY".to_string(),
239                    value: Some(format!("{VOLUME_TLS_PATH}/tls.key")),
240                    ..EnvVar::default()
241                },
242                EnvVar {
243                    name: "KANIDM_BINDADDRESS".to_string(),
244                    value: Some(format!("0.0.0.0:{CONTAINER_HTTPS_PORT}")),
245                    ..EnvVar::default()
246                },
247                EnvVar {
248                    name: "KANIDM_ROLE".to_string(),
249                    value: Some(serde_plain::to_string(&replica_group.role.clone()).unwrap()),
250                    ..EnvVar::default()
251                },
252                EnvVar {
253                    name: "KANIDM_LOG_LEVEL".to_string(),
254                    value: Some(serde_plain::to_string(&self.spec.log_level.clone()).unwrap()),
255                    ..EnvVar::default()
256                },
257            ])
258            .chain(
259                self.spec
260                    .ldap_port_name
261                    .clone()
262                    .into_iter()
263                    .map(|_| EnvVar {
264                        name: "KANIDM_LDAPBINDADDRESS".to_string(),
265                        value: Some(format!("0.0.0.0:{CONTAINER_LDAP_PORT}")),
266                        ..EnvVar::default()
267                    }),
268            )
269            .collect()
270    }
271
272    fn generate_config_volume_mount(&self) -> VolumeMount {
273        VolumeMount {
274            name: VOLUME_CONFIG_NAME.to_string(),
275            mount_path: VOLUME_CONFIG_PATH.to_string(),
276            read_only: Some(false),
277            ..VolumeMount::default()
278        }
279    }
280
281    fn generate_volume_mounts(&self) -> Vec<VolumeMount> {
282        // TODO: if replication is enabled, we need to mount the config volume
283        self.spec
284            .volume_mounts
285            .clone()
286            .unwrap_or_default()
287            .into_iter()
288            .chain([
289                VolumeMount {
290                    name: VOLUME_DATA_NAME.to_string(),
291                    mount_path: VOLUME_DATA_PATH.to_string(),
292                    ..VolumeMount::default()
293                },
294                VolumeMount {
295                    name: VOLUME_TLS_NAME.to_string(),
296                    mount_path: VOLUME_TLS_PATH.to_string(),
297                    read_only: Some(true),
298                    ..VolumeMount::default()
299                },
300            ])
301            .chain(
302                self.is_replication_enabled()
303                    .then(|| self.generate_config_volume_mount()),
304            )
305            .collect()
306    }
307
308    fn generate_init_containers(&self, replica_group: &ReplicaGroup) -> Vec<Container> {
309        if self.is_replication_enabled() {
310            let external_replica_nodes_envs = self
311                .spec
312                .external_replication_nodes
313                .iter()
314                .flat_map(|ern| {
315                    [
316                        EnvVar {
317                            name: format!("EXTERNAL_REPLICATION_NODE_{}", ern.name),
318                            value: Some(format!(
319                                "repl://{host}:{port}",
320                                host = ern.hostname.clone(),
321                                port = ern.port
322                            )),
323                            ..EnvVar::default()
324                        },
325                        EnvVar {
326                            name: format!("EXTERNAL_REPLICATION_NODE_{}_CERT", ern.name),
327                            value_from: Some(EnvVarSource {
328                                secret_key_ref: Some(ern.certificate.clone()),
329                                ..EnvVarSource::default()
330                            }),
331                            ..EnvVar::default()
332                        },
333                        EnvVar {
334                            name: format!("EXTERNAL_REPLICATION_NODE_{}_TYPE", ern.name),
335                            value: serde_plain::to_string(&ern._type).ok(),
336                            ..EnvVar::default()
337                        },
338                        EnvVar {
339                            name: format!(
340                                "EXTERNAL_REPLICATION_NODE_{}_AUTOMATIC_REFRESH",
341                                ern.name
342                            ),
343                            value: Some(ern.automatic_refresh.to_string()),
344                            ..EnvVar::default()
345                        },
346                    ]
347                })
348                .collect::<Vec<EnvVar>>();
349            let replica_secrets_envs = self
350                .spec
351                .replica_groups
352                .iter()
353                .flat_map(|rg| {
354                    let sts_name = self.statefulset_name(&rg.name);
355                    (0..rg.replicas).flat_map(move |i| {
356                        let pod_name = format!("{sts_name}-{i}");
357                        let name = pod_name.to_uppercase().replace("-", "_");
358                        [
359                            EnvVar {
360                                name: name.clone(),
361                                value_from: Some(EnvVarSource {
362                                    secret_key_ref: Some(SecretKeySelector {
363                                        name: self.replica_secret_name(&pod_name),
364                                        key: REPLICA_SECRET_KEY.to_string(),
365                                        optional: Some(true),
366                                    }),
367                                    ..EnvVarSource::default()
368                                }),
369                                ..EnvVar::default()
370                            },
371                            EnvVar {
372                                name: format!("{name}_TYPE"),
373                                value: replication_type(
374                                    replica_group.role.clone(),
375                                    rg.role.clone(),
376                                )
377                                .and_then(|t| serde_plain::to_string(&t).ok()),
378                                ..EnvVar::default()
379                            },
380                        ]
381                    })
382                })
383                .collect::<Vec<EnvVar>>();
384
385            let primary_node = self
386                .spec
387                .replica_groups
388                .iter()
389                .find(|rg| rg.primary_node)
390                .map(|rg| format!("{}-0", self.statefulset_name(&rg.name)));
391            let env = external_replica_nodes_envs
392                .into_iter()
393                .chain(replica_secrets_envs)
394                .chain([
395                    EnvVar {
396                        name: "POD_NAME".to_string(),
397                        value_from: Some(EnvVarSource {
398                            field_ref: Some(ObjectFieldSelector {
399                                api_version: Some("v1".to_string()),
400                                field_path: "metadata.name".to_string(),
401                            }),
402                            ..EnvVarSource::default()
403                        }),
404                        ..EnvVar::default()
405                    },
406                    EnvVar {
407                        name: "REPLICATION_PORT".to_string(),
408                        value: Some(CONTAINER_REPLICATION_PORT.to_string()),
409                        ..EnvVar::default()
410                    },
411                    EnvVar {
412                        name: "KANIDM_CONFIG_PATH".to_string(),
413                        value: Some(KANIDM_CONFIG_PATH.to_string()),
414                        ..EnvVar::default()
415                    },
416                    EnvVar {
417                        name: "KANIDM_SERVICE_NAME".to_string(),
418                        value: Some(self.service_name()),
419                        ..EnvVar::default()
420                    },
421                ])
422                .chain(primary_node.map(|pn| EnvVar {
423                    name: "KANIDM_PRIMARY_NODE".to_string(),
424                    value: Some(pn),
425                    ..EnvVar::default()
426                }))
427                .collect::<Vec<EnvVar>>();
428
429            let init_container = Container {
430                name: "kanidm-generate-replication-config".to_string(),
431                image: Some(REPLICATION_CONFIG_IMAGE.to_string()),
432                env: Some(env),
433                args: Some(vec![
434                    "--script".to_string(),
435                    REPLICATION_CONFIG_SCRIPT.to_string(),
436                ]),
437                volume_mounts: Some(vec![self.generate_config_volume_mount()]),
438                ..Container::default()
439            };
440
441            merge_containers(self.spec.init_containers.clone(), &init_container)
442        } else {
443            self.spec.init_containers.clone().unwrap_or_default()
444        }
445    }
446
447    fn generate_container_ports(&self) -> Vec<ContainerPort> {
448        std::iter::once(ContainerPort {
449            name: Some(self.spec.port_name.clone()),
450            container_port: CONTAINER_HTTPS_PORT,
451            ..ContainerPort::default()
452        })
453        .chain(
454            self.spec
455                .ldap_port_name
456                .clone()
457                .into_iter()
458                .map(|port_name| ContainerPort {
459                    name: Some(port_name.clone()),
460                    container_port: CONTAINER_LDAP_PORT,
461                    ..ContainerPort::default()
462                }),
463        )
464        .chain(self.is_replication_enabled().then(|| ContainerPort {
465            name: Some("replication".to_string()),
466            container_port: CONTAINER_REPLICATION_PORT,
467            ..ContainerPort::default()
468        }))
469        .collect()
470    }
471
472    fn generate_probe(&self) -> Probe {
473        Probe {
474            http_get: Some(HTTPGetAction {
475                path: Some("/status".to_string()),
476                port: IntOrString::String(self.spec.port_name.clone()),
477                scheme: Some("HTTPS".to_string()),
478                ..HTTPGetAction::default()
479            }),
480            ..Probe::default()
481        }
482    }
483
484    fn generate_containers(
485        &self,
486        env: &Vec<EnvVar>,
487        volume_mounts: &Vec<VolumeMount>,
488        ports: &Vec<ContainerPort>,
489        probe: &Probe,
490        replica_group: &ReplicaGroup,
491    ) -> Vec<Container> {
492        let command = vec!["kanidmd".to_string(), "server".to_string()]
493            .into_iter()
494            .chain(
495                self.is_replication_enabled()
496                    .then(|| vec!["-c".to_string(), KANIDM_CONFIG_PATH.to_string()])
497                    .into_iter()
498                    .flatten(),
499            )
500            .collect::<Vec<String>>();
501        let kanidm_container = Container {
502            name: "kanidm".to_string(),
503            image: Some(self.spec.image.clone()),
504            image_pull_policy: self.spec.image_pull_policy.clone(),
505            command: Some(command),
506            env: Some(env.clone()),
507            ports: Some(ports.clone()),
508            volume_mounts: Some(volume_mounts.clone()),
509            resources: replica_group.resources.clone(),
510            readiness_probe: Some(probe.clone()),
511            liveness_probe: Some(probe.clone()),
512            ..Container::default()
513        };
514
515        merge_containers(self.spec.containers.clone(), &kanidm_container)
516    }
517
518    fn generate_dns_policy(&self) -> Option<String> {
519        match self.spec.host_network {
520            Some(true) => Some("ClusterFirstWithHostNet".to_string()),
521            _ => self.spec.dns_policy.clone(),
522        }
523    }
524
525    fn generate_volumes(&self) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
526        let secret_name = self.spec.tls_secret_name.clone().unwrap_or_else(|| {
527            self.spec
528                .ingress
529                .as_ref()
530                .and_then(|i| i.tls_secret_name.clone())
531                .unwrap_or_else(|| self.get_tls_secret_name())
532        });
533
534        self.expand_storage(
535            self.spec
536                .volumes
537                .clone()
538                .unwrap_or_default()
539                .into_iter()
540                .chain(std::iter::once(Volume {
541                    name: VOLUME_TLS_NAME.to_string(),
542                    secret: Some(SecretVolumeSource {
543                        secret_name: Some(secret_name),
544                        ..SecretVolumeSource::default()
545                    }),
546                    ..Volume::default()
547                }))
548                .chain(self.is_replication_enabled().then(|| Volume {
549                    name: VOLUME_CONFIG_NAME.to_string(),
550                    empty_dir: Some(EmptyDirVolumeSource {
551                        medium: None,
552                        size_limit: None,
553                    }),
554                    ..Volume::default()
555                }))
556                .collect(),
557        )
558    }
559
560    fn expand_storage(
561        &self,
562        volumes: Vec<Volume>,
563    ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
564        let default_expand_storage = |volumes: Vec<Volume>| {
565            (
566                volumes
567                    .into_iter()
568                    .chain(std::iter::once(Volume {
569                        name: VOLUME_DATA_NAME.to_string(),
570                        empty_dir: Some(EmptyDirVolumeSource {
571                            medium: None,
572                            size_limit: None,
573                        }),
574                        ..Volume::default()
575                    }))
576                    .collect(),
577                None,
578            )
579        };
580
581        match self.spec.storage.clone() {
582            Some(storage) => {
583                if let Some(empty_dir) = storage.empty_dir {
584                    (
585                        volumes
586                            .into_iter()
587                            .chain(std::iter::once(Volume {
588                                name: VOLUME_DATA_NAME.to_string(),
589                                empty_dir: Some(empty_dir),
590                                ..Volume::default()
591                            }))
592                            .collect(),
593                        None,
594                    )
595                } else if let Some(ephemeral) = storage.ephemeral {
596                    (
597                        volumes
598                            .into_iter()
599                            .chain(std::iter::once(Volume {
600                                name: VOLUME_DATA_NAME.to_string(),
601                                ephemeral: Some(ephemeral),
602                                ..Volume::default()
603                            }))
604                            .collect(),
605                        None,
606                    )
607                } else if let Some(volume_claim_template) = storage.volume_claim_template {
608                    let pvc = volume_claim_template.to_persistent_volume_claim();
609                    let named_template = PersistentVolumeClaim {
610                        metadata: ObjectMeta {
611                            name: Some(VOLUME_DATA_NAME.to_string()),
612                            ..pvc.metadata
613                        },
614                        spec: pvc.spec,
615                        ..pvc
616                    };
617                    (volumes, Some(vec![named_template]))
618                } else {
619                    default_expand_storage(volumes)
620                }
621            }
622            None => default_expand_storage(volumes),
623        }
624    }
625
626    fn generate_metadata(
627        &self,
628        labels: &BTreeMap<String, String>,
629        replica_group_name: &str,
630    ) -> ObjectMeta {
631        ObjectMeta {
632            name: Some(self.statefulset_name(replica_group_name)),
633            namespace: self.namespace(),
634            labels: Some(labels.clone()),
635            owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
636            annotations: Some(self.annotations().to_owned()),
637            ..ObjectMeta::default()
638        }
639    }
640}
641
642fn replication_type(
643    source_role: KanidmServerRole,
644    target_role: KanidmServerRole,
645) -> Option<ReplicationType> {
646    match (source_role, target_role) {
647        (
648            KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
649            KanidmServerRole::WriteReplicaNoUI | KanidmServerRole::WriteReplica,
650        ) => Some(ReplicationType::MutualPull),
651
652        (
653            KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
654            KanidmServerRole::ReadOnlyReplica,
655        ) => Some(ReplicationType::AllowPull),
656        (
657            KanidmServerRole::ReadOnlyReplica,
658            KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
659        ) => Some(ReplicationType::Pull),
660        (KanidmServerRole::ReadOnlyReplica, KanidmServerRole::ReadOnlyReplica) => None,
661    }
662}
663
664#[cfg(test)]
665mod tests {
666    use super::StatefulSetExtPrivate;
667
668    use crate::kanidm::crd::{Kanidm, KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate};
669    use k8s_openapi::api::core::v1::{EmptyDirVolumeSource, EphemeralVolumeSource, Volume};
670
671    fn create_kanidm_with_storage(storage: Option<KanidmStorage>) -> Kanidm {
672        Kanidm {
673            spec: KanidmSpec {
674                storage,
675                ..Default::default()
676            },
677            ..Default::default()
678        }
679    }
680
681    #[test]
682    fn test_generate_volumes_without_storage() {
683        let kanidm = create_kanidm_with_storage(None);
684        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
685
686        assert_eq!(volumes.clone().len(), 1);
687        assert_eq!(volumes.clone().first().unwrap().name, "kanidm-data");
688        assert!(volumes.first().unwrap().empty_dir.is_some());
689        assert!(volume_claim_template.is_none());
690    }
691
692    #[test]
693    fn test_generate_volumes_with_emptydir() {
694        let storage = Some(KanidmStorage {
695            empty_dir: Some(EmptyDirVolumeSource::default()),
696            ..Default::default()
697        });
698        let kanidm = create_kanidm_with_storage(storage);
699        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
700
701        assert_eq!(volumes.clone().len(), 1);
702        assert!(
703            volumes
704                .iter()
705                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
706        );
707        assert!(volume_claim_template.is_none());
708    }
709
710    #[test]
711    fn test_generate_volumes_with_emptydir_and_ephemeral() {
712        let storage = Some(KanidmStorage {
713            empty_dir: Some(EmptyDirVolumeSource::default()),
714            ephemeral: Some(EphemeralVolumeSource::default()),
715            ..Default::default()
716        });
717        let kanidm = create_kanidm_with_storage(storage);
718        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
719
720        assert_eq!(volumes.clone().len(), 1);
721        assert!(
722            volumes
723                .iter()
724                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
725        );
726        assert!(volume_claim_template.is_none());
727    }
728
729    #[test]
730    fn test_generate_volumes_with_emptydir_ephemeral_and_volumeclaimtemplate() {
731        let storage = Some(KanidmStorage {
732            empty_dir: Some(EmptyDirVolumeSource::default()),
733            ephemeral: Some(EphemeralVolumeSource::default()),
734            volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
735        });
736        let kanidm = create_kanidm_with_storage(storage);
737        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
738
739        assert_eq!(volumes.len(), 1);
740        assert!(
741            volumes
742                .iter()
743                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
744        );
745        assert!(volume_claim_template.is_none());
746    }
747
748    #[test]
749    fn test_generate_volumes_with_ephemeral() {
750        let storage = Some(KanidmStorage {
751            ephemeral: Some(EphemeralVolumeSource::default()),
752            ..Default::default()
753        });
754        let kanidm = create_kanidm_with_storage(storage);
755        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
756
757        assert_eq!(volumes.len(), 1);
758        assert!(
759            volumes
760                .iter()
761                .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
762        );
763        assert!(volume_claim_template.is_none());
764    }
765
766    #[test]
767    fn test_generate_volumes_with_ephemeral_and_volumeclaimtemplate() {
768        let storage = Some(KanidmStorage {
769            ephemeral: Some(EphemeralVolumeSource::default()),
770            volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
771            ..Default::default()
772        });
773        let kanidm = create_kanidm_with_storage(storage);
774        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
775
776        assert_eq!(volumes.len(), 1);
777        assert!(
778            volumes
779                .iter()
780                .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
781        );
782        assert!(volume_claim_template.is_none());
783    }
784
785    #[test]
786    fn test_generate_volumes_with_volumeclaimtemplate() {
787        let storage = Some(KanidmStorage {
788            volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
789            ..Default::default()
790        });
791        let kanidm = create_kanidm_with_storage(storage);
792        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
793
794        assert!(volumes.is_empty());
795        assert!(volume_claim_template.is_some());
796    }
797
798    #[test]
799    fn test_generate_volumes_with_existing_volumes() {
800        let existing_volume = Volume {
801            name: "existing-volume".to_string(),
802            ..Volume::default()
803        };
804        let kanidm = create_kanidm_with_storage(None);
805        let (volumes, volume_claim_template) = kanidm.expand_storage(vec![existing_volume.clone()]);
806
807        assert_eq!(volumes.len(), 2);
808        assert!(volumes.clone().iter().any(|v| v.name == "existing-volume"));
809        assert!(
810            volumes
811                .iter()
812                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
813        );
814        assert!(volume_claim_template.is_none());
815    }
816
817    #[test]
818    fn test_generate_volumes_with_multiple_existing_volumes() {
819        let existing_volume1 = Volume {
820            name: "existing-volume-1".to_string(),
821            ..Volume::default()
822        };
823        let existing_volume2 = Volume {
824            name: "existing-volume-2".to_string(),
825            ..Volume::default()
826        };
827        let kanidm = create_kanidm_with_storage(None);
828        let (volumes, volume_claim_template) =
829            kanidm.expand_storage(vec![existing_volume1.clone(), existing_volume2.clone()]);
830
831        assert_eq!(volumes.len(), 3);
832        assert!(
833            volumes
834                .clone()
835                .iter()
836                .any(|v| v.name == "existing-volume-1")
837        );
838        assert!(
839            volumes
840                .clone()
841                .iter()
842                .any(|v| v.name == "existing-volume-2")
843        );
844        assert!(
845            volumes
846                .iter()
847                .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
848        );
849        assert!(volume_claim_template.is_none());
850    }
851}
852
853#[cfg(all(test, feature = "integration-test"))]
854mod integration_test {
855    use super::{REPLICATION_CONFIG_IMAGE, REPLICATION_CONFIG_SCRIPT};
856
857    use std::fs;
858    use std::path::Path;
859
860    use tempfile::tempdir;
861    use testcontainers::ContainerRequest;
862    use testcontainers::GenericImage;
863    use testcontainers::ImageExt;
864    use testcontainers::core::Mount;
865    use testcontainers::runners::AsyncRunner;
866    use tokio::io::{AsyncBufReadExt, BufReader};
867
868    struct TestCase<'a> {
869        env_vars: Vec<(&'a str, &'a str)>,
870        expected_result: &'a str,
871    }
872
873    async fn run_test_case(
874        image_parts: &[&str],
875        cmd: &[&str],
876        tmp_dir_path: &str,
877        env_vars: &[(&str, &str)],
878        expected_result: &str,
879    ) {
880        let container = GenericImage::new(image_parts[0], image_parts[1]);
881        let mut container_request: ContainerRequest<GenericImage> = container.clone().into();
882
883        for (key, value) in env_vars {
884            container_request =
885                container_request.with_env_var((*key).to_string(), (*value).to_string());
886        }
887
888        let container = container_request
889            .with_cmd(cmd.iter().map(|&s| s.to_string()))
890            .with_mount(Mount::bind_mount(tmp_dir_path.to_string(), "/tmp"))
891            .start()
892            .await
893            .unwrap();
894
895        let stdout = container.stdout(true);
896        let mut stdout_reader = BufReader::new(stdout).lines();
897        let mut stdout_lines = Vec::new();
898        while let Some(l) = stdout_reader.next_line().await.unwrap() {
899            stdout_lines.push(l);
900        }
901        dbg!(stdout_lines.join("\n"));
902
903        let stderr = container.stderr(true);
904        let mut stderr_reader = BufReader::new(stderr).lines();
905        let mut stderr_lines = Vec::new();
906        while let Some(l) = stderr_reader.next_line().await.unwrap() {
907            stderr_lines.push(l);
908        }
909        dbg!(stderr_lines.join("\n"));
910
911        let server_toml_path = Path::new(tmp_dir_path).join("server.toml");
912        let content = fs::read_to_string(server_toml_path).expect("Unable to read server.toml");
913        assert_eq!(content, expected_result);
914    }
915
916    #[tokio::test]
917    async fn test_replication_config_generation() {
918        let image_parts = REPLICATION_CONFIG_IMAGE.split(':').collect::<Vec<&str>>();
919        let cmd = ["--script", REPLICATION_CONFIG_SCRIPT];
920        let tmp_dir = tempdir().unwrap();
921        let tmp_dir_path = tmp_dir.path().to_str().unwrap().to_string();
922
923        let test_cases = vec![
924            TestCase {
925                env_vars: vec![
926                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
927                    ("REPLICATION_PORT", "8444"),
928                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
929                    ("POD_NAME", "kanidm-test-default-0"),
930                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
931                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
932                ],
933                expected_result: r#"version = "2"
934
935[replication]
936origin = "repl://kanidm-test-default-0.kanidm-test:8444"
937bindaddress = "0.0.0.0:8444"
938
939"#,
940            },
941            TestCase {
942                env_vars: vec![
943                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
944                    ("REPLICATION_PORT", "8444"),
945                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
946                    ("POD_NAME", "kanidm-test-default-0"),
947                    (
948                        "EXTERNAL_REPLICATION_NODE_HOST_0",
949                        "repl://external-host-0:8444",
950                    ),
951                    (
952                        "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
953                        "dummy-cert-external-host-0",
954                    ),
955                    ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
956                    ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
957                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
958                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
959                ],
960                expected_result: r#"version = "2"
961
962[replication]
963origin = "repl://kanidm-test-default-0.kanidm-test:8444"
964bindaddress = "0.0.0.0:8444"
965
966[replication."repl://external-host-0:8444"]
967type = "mutual-pull"
968partner_cert = "dummy-cert-external-host-0"
969automatic_refresh = true
970
971"#,
972            },
973            TestCase {
974                env_vars: vec![
975                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
976                    ("REPLICATION_PORT", "8444"),
977                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
978                    ("POD_NAME", "kanidm-test-default-0"),
979                    (
980                        "EXTERNAL_REPLICATION_NODE_HOST_0",
981                        "repl://external-host-0:8444",
982                    ),
983                    ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
984                    ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
985                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
986                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
987                ],
988                expected_result: r#"version = "2"
989
990[replication]
991origin = "repl://kanidm-test-default-0.kanidm-test:8444"
992bindaddress = "0.0.0.0:8444"
993
994"#,
995            },
996            TestCase {
997                env_vars: vec![
998                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
999                    ("REPLICATION_PORT", "8444"),
1000                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
1001                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1002                    ("POD_NAME", "kanidm-test-default-0"),
1003                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1004                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1005                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1006                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1007                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1008                    ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1009                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1010                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1011                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1012                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1013                ],
1014                expected_result: r#"version = "2"
1015
1016[replication]
1017origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1018bindaddress = "0.0.0.0:8444"
1019
1020[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1021type = "mutual-pull"
1022partner_cert = "dummy-cert-default-1"
1023automatic_refresh = false
1024
1025[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1026type = "mutual-pull"
1027partner_cert = "dummy-cert-default-3"
1028automatic_refresh = false
1029
1030[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1031type = "allow-pull"
1032consumer_cert = "dummy-cert-read-replica-0"
1033
1034[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1035type = "allow-pull"
1036consumer_cert = "dummy-cert-read-replica-1"
1037
1038"#,
1039            },
1040            TestCase {
1041                env_vars: vec![
1042                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1043                    ("REPLICATION_PORT", "8444"),
1044                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
1045                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1046                    ("POD_NAME", "kanidm-test-default-1"),
1047                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1048                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1049                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1050                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1051                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1052                    ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1053                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1054                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1055                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1056                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1057                ],
1058                expected_result: r#"version = "2"
1059
1060[replication]
1061origin = "repl://kanidm-test-default-1.kanidm-test:8444"
1062bindaddress = "0.0.0.0:8444"
1063
1064[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1065type = "mutual-pull"
1066partner_cert = "dummy-cert-default-0"
1067automatic_refresh = true
1068
1069[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1070type = "mutual-pull"
1071partner_cert = "dummy-cert-default-3"
1072automatic_refresh = false
1073
1074[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1075type = "allow-pull"
1076consumer_cert = "dummy-cert-read-replica-0"
1077
1078[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1079type = "allow-pull"
1080consumer_cert = "dummy-cert-read-replica-1"
1081
1082"#,
1083            },
1084            TestCase {
1085                env_vars: vec![
1086                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1087                    ("REPLICATION_PORT", "8444"),
1088                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
1089                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1090                    ("POD_NAME", "kanidm-test-default-3"),
1091                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1092                    ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1093                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1094                    ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1095                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1096                    ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1097                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1098                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1099                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1100                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1101                ],
1102                expected_result: r#"version = "2"
1103
1104[replication]
1105origin = "repl://kanidm-test-default-3.kanidm-test:8444"
1106bindaddress = "0.0.0.0:8444"
1107
1108[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1109type = "mutual-pull"
1110partner_cert = "dummy-cert-default-0"
1111automatic_refresh = true
1112
1113[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1114type = "mutual-pull"
1115partner_cert = "dummy-cert-default-1"
1116automatic_refresh = false
1117
1118[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1119type = "allow-pull"
1120consumer_cert = "dummy-cert-read-replica-0"
1121
1122[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1123type = "allow-pull"
1124consumer_cert = "dummy-cert-read-replica-1"
1125
1126"#,
1127            },
1128            TestCase {
1129                env_vars: vec![
1130                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1131                    ("REPLICATION_PORT", "8444"),
1132                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
1133                    ("REPLICA_GROUP", "read-replica"),
1134                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1135                    ("POD_NAME", "kanidm-test-read-replica-0"),
1136                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1137                    ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1138                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1139                    ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1140                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1141                    ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1142                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1143                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1144                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1145                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1146                ],
1147                expected_result: r#"version = "2"
1148
1149[replication]
1150origin = "repl://kanidm-test-read-replica-0.kanidm-test:8444"
1151bindaddress = "0.0.0.0:8444"
1152
1153[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1154type = "pull"
1155supplier_cert = "dummy-cert-default-0"
1156automatic_refresh = true
1157
1158[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1159type = "pull"
1160supplier_cert = "dummy-cert-default-1"
1161automatic_refresh = false
1162
1163[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1164type = "pull"
1165supplier_cert = "dummy-cert-default-3"
1166automatic_refresh = false
1167
1168"#,
1169            },
1170            TestCase {
1171                env_vars: vec![
1172                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1173                    ("REPLICATION_PORT", "8444"),
1174                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
1175                    ("REPLICA_GROUP", "read-replica"),
1176                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1177                    ("POD_NAME", "kanidm-test-read-replica-1"),
1178                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1179                    ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1180                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1181                    ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1182                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1183                    ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1184                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1185                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1186                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1187                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1188                ],
1189                expected_result: r#"version = "2"
1190
1191[replication]
1192origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1193bindaddress = "0.0.0.0:8444"
1194
1195[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1196type = "pull"
1197supplier_cert = "dummy-cert-default-0"
1198automatic_refresh = true
1199
1200[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1201type = "pull"
1202supplier_cert = "dummy-cert-default-1"
1203automatic_refresh = false
1204
1205[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1206type = "pull"
1207supplier_cert = "dummy-cert-default-3"
1208automatic_refresh = false
1209
1210"#,
1211            },
1212            TestCase {
1213                env_vars: vec![
1214                    ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1215                    ("REPLICATION_PORT", "8444"),
1216                    ("KANIDM_SERVICE_NAME", "kanidm-test"),
1217                    ("REPLICA_GROUP", "read-replica"),
1218                    ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1219                    ("POD_NAME", "kanidm-test-read-replica-1"),
1220                    (
1221                        "EXTERNAL_REPLICATION_NODE_HOST_0",
1222                        "repl://external-host-0:8444",
1223                    ),
1224                    (
1225                        "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1226                        "dummy-cert-external-host-0",
1227                    ),
1228                    ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1229                    ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1230                    ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1231                    ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1232                    ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1233                    ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1234                    ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1235                    ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1236                    ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1237                    ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1238                    ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1239                    ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1240                ],
1241                expected_result: r#"version = "2"
1242
1243[replication]
1244origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1245bindaddress = "0.0.0.0:8444"
1246
1247[replication."repl://external-host-0:8444"]
1248type = "mutual-pull"
1249partner_cert = "dummy-cert-external-host-0"
1250automatic_refresh = true
1251
1252[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1253type = "pull"
1254supplier_cert = "dummy-cert-default-0"
1255automatic_refresh = true
1256
1257[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1258type = "pull"
1259supplier_cert = "dummy-cert-default-1"
1260automatic_refresh = false
1261
1262[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1263type = "pull"
1264supplier_cert = "dummy-cert-default-3"
1265automatic_refresh = false
1266
1267"#,
1268            },
1269        ];
1270
1271        for test_case in test_cases {
1272            run_test_case(
1273                &image_parts,
1274                &cmd,
1275                &tmp_dir_path,
1276                &test_case.env_vars,
1277                test_case.expected_result,
1278            )
1279            .await;
1280        }
1281    }
1282}