kaniop_operator/kanidm/reconcile/
statefulset.rs

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