kaniop_operator/kanidm/reconcile/
statefulset.rs

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