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