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