kaniop_operator/kanidm/reconcile/
statefulset.rs

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