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