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