kaniop_operator/kanidm/reconcile/
statefulset.rs

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