Skip to main content

kaniop_operator/kanidm/reconcile/
statefulset.rs

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