Skip to main content

kaniop_operator/kanidm/reconcile/
statefulset.rs

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