Skip to main content

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