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