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