1use super::secret::{REPLICA_SECRET_KEY, SecretExt};
2use super::service::ServiceExt;
3
4use crate::kanidm::crd::{Kanidm, KanidmServerRole, ReplicaGroup, ReplicationType};
5
6use kaniop_k8s_util::resources::merge_containers;
7
8use std::collections::BTreeMap;
9
10use k8s_openapi::api::apps::v1::{StatefulSet, StatefulSetSpec};
11use k8s_openapi::api::core::v1::{
12 Container, ContainerPort, EmptyDirVolumeSource, EnvVar, EnvVarSource, HTTPGetAction,
13 ObjectFieldSelector, PersistentVolumeClaim, PodSpec, PodTemplateSpec, Probe, SecretKeySelector,
14 SecretVolumeSource, Volume, VolumeMount,
15};
16use k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector;
17use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
18use kube::ResourceExt;
19use kube::api::{ObjectMeta, Resource};
20
21pub const REPLICA_GROUP_LABEL: &str = "kanidm.kaniop.rs/replica-group";
22
23const REPLICATION_CONFIG_IMAGE: &str = "ghcr.io/rash-sh/rash:2.16.1";
25const REPLICATION_CONFIG_SCRIPT: &str = r#"
26- copy:
27 content: |
28 version = "2"
29
30 [replication]
31 origin = "repl://{{ env.POD_NAME }}.{{ env.KANIDM_SERVICE_NAME }}:{{ env.REPLICATION_PORT }}"
32 bindaddress = "0.0.0.0:{{ env.REPLICATION_PORT }}"
33
34 {% for e in env -%}
35 {% if e is startingwith(env.KANIDM_SERVICE_NAME| upper | replace('-', '_')) -%}
36 {% if e == env.POD_NAME | upper | replace('-','_') or e is endingwith("_TYPE") or
37 e + '_TYPE' not in env or env[e + '_TYPE'] == "" -%}
38 {% continue -%}
39 {% endif -%}
40 {% set replica = e | lower | replace('_', '-') -%}
41 [replication."repl://{{ replica }}.{{ env.KANIDM_SERVICE_NAME }}:{{ env.REPLICATION_PORT }}"]
42 {% set type = env[e + '_TYPE'] -%}
43 type = "{{ type }}"
44 {% if type == "mutual-pull" -%}
45 partner_cert = "{{ env[e] }}"
46 {% elif type == "pull" -%}
47 supplier_cert = "{{ env[e] }}"
48 {% else -%}
49 consumer_cert = "{{ env[e] }}"
50 {% endif -%}
51 {% if type != "allow-pull" -%}
52 {% if replica == env.KANIDM_PRIMARY_NODE -%}
53 automatic_refresh = true
54 {% else -%}
55 automatic_refresh = false
56 {% endif -%}
57 {% endif %}
58 {% elif e is startingwith("EXTERNAL_REPLICATION_NODE") -%}
59 {% if e + '_CERT' not in env or e is endingwith("_TYPE") or e is endingwith("_CERT") or e is endingwith("_AUTOMATIC_REFRESH") -%}
60 {% continue -%}
61 {% endif -%}
62 [replication."{{ env[e] }}"]
63 {% set type = env[e + '_TYPE'] -%}
64 type = "{{ type }}"
65 {% if type == "mutual-pull" -%}
66 partner_cert = "{{ env[e + '_CERT'] }}"
67 {% elif type == "pull" -%}
68 supplier_cert = "{{ env[e + '_CERT'] }}"
69 {% else -%}
70 consumer_cert = "{{ env[e + '_CERT'] }}"
71 {% endif -%}
72 {% if type != "allow-pull" -%}
73 automatic_refresh = {{ env[e + '_AUTOMATIC_REFRESH'] }}
74 {% endif %}
75 {% endif %}
76 {%- endfor -%}
77 dest: "{{ env.KANIDM_CONFIG_PATH }}"
78"#;
79const CONTAINER_HTTPS_PORT: i32 = 8443;
80const CONTAINER_REPLICATION_PORT: i32 = 8444;
81const CONTAINER_LDAP_PORT: i32 = 3636;
82const KANIDM_CONFIG_PATH: &str = "/run/kanidm/server.toml";
83const VOLUME_CONFIG_NAME: &str = "kanidm-config";
84const VOLUME_CONFIG_PATH: &str = "/run/kanidm";
85const VOLUME_DATA_NAME: &str = "kanidm-data";
86const VOLUME_DATA_PATH: &str = "/data";
87const VOLUME_TLS_NAME: &str = "kanidm-certs";
88const VOLUME_TLS_PATH: &str = "/etc/kanidm/tls";
89
90pub trait StatefulSetExt {
91 fn statefulset_name(&self, rg_name: &str) -> String;
92 fn create_statefulset(&self, replica_group: &ReplicaGroup) -> StatefulSet;
93}
94
95trait StatefulSetExtPrivate {
96 fn expand_storage(
97 &self,
98 volumes: Vec<Volume>,
99 ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>);
100 fn generate_pod_labels(&self, replica_group: &ReplicaGroup) -> BTreeMap<String, String>;
101 fn generate_labels(&self, pod_labels: &BTreeMap<String, String>) -> BTreeMap<String, String>;
102 fn generate_env_vars(&self, replica_group: &ReplicaGroup) -> Vec<EnvVar>;
103 fn generate_config_volume_mount(&self) -> VolumeMount;
104 fn generate_volume_mounts(&self) -> Vec<VolumeMount>;
105 #[allow(clippy::ptr_arg)]
106 fn generate_init_containers(&self, replica_group: &ReplicaGroup) -> Vec<Container>;
107 fn generate_container_ports(&self) -> Vec<ContainerPort>;
108 fn generate_probe(&self) -> Probe;
109 #[allow(clippy::ptr_arg)]
110 fn generate_containers(
111 &self,
112 env: &Vec<EnvVar>,
113 volume_mounts: &Vec<VolumeMount>,
114 ports: &Vec<ContainerPort>,
115 probe: &Probe,
116 replica_group: &ReplicaGroup,
117 ) -> Vec<Container>;
118 fn generate_dns_policy(&self) -> Option<String>;
119 fn generate_volumes(&self) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>);
120 fn generate_metadata(
121 &self,
122 labels: &BTreeMap<String, String>,
123 replica_group_name: &str,
124 ) -> ObjectMeta;
125}
126
127impl StatefulSetExt for Kanidm {
128 #[inline]
129 fn statefulset_name(&self, rg_name: &str) -> String {
130 format!("{kanidm_name}-{rg_name}", kanidm_name = self.name_any())
131 }
132
133 fn create_statefulset(&self, replica_group: &ReplicaGroup) -> StatefulSet {
134 let pod_labels = self.generate_pod_labels(replica_group);
135 let labels = self.generate_labels(&pod_labels);
136 let env = self.generate_env_vars(replica_group);
137 let init_containers = self.generate_init_containers(replica_group);
138 let ports = self.generate_container_ports();
139 let probe = self.generate_probe();
140 let volume_mounts = self.generate_volume_mounts();
141 let containers =
142 self.generate_containers(&env, &volume_mounts, &ports, &probe, replica_group);
143 let dns_policy = self.generate_dns_policy();
144 let (volumes, volume_claim_templates) = self.generate_volumes();
145
146 StatefulSet {
147 metadata: self.generate_metadata(&labels, &replica_group.name),
148 spec: Some(StatefulSetSpec {
149 replicas: Some(replica_group.replicas),
150 selector: LabelSelector {
151 match_expressions: None,
152 match_labels: Some(pod_labels.clone()),
153 },
154 template: PodTemplateSpec {
155 metadata: Some(ObjectMeta {
156 labels: Some(pod_labels),
157 ..ObjectMeta::default()
158 }),
159 spec: Some(PodSpec {
160 containers,
161 volumes: Some(volumes),
162 node_selector: replica_group.node_selector.clone(),
163 affinity: replica_group.affinity.clone(),
164 tolerations: replica_group.tolerations.clone(),
165 topology_spread_constraints: replica_group
166 .topology_spread_constraints
167 .clone(),
168 security_context: self.spec.security_context.clone(),
169 dns_policy,
170 dns_config: self.spec.dns_config.clone(),
171 init_containers: Some(init_containers),
172 host_aliases: self.spec.host_aliases.clone(),
173 enable_service_links: Some(false),
174 ..PodSpec::default()
175 }),
176 },
177 service_name: Some(self.service_name()),
178 persistent_volume_claim_retention_policy: self
179 .spec
180 .persistent_volume_claim_retention_policy
181 .clone(),
182 min_ready_seconds: self.spec.min_ready_seconds,
183 volume_claim_templates,
184 ..StatefulSetSpec::default()
185 }),
186 ..StatefulSet::default()
187 }
188 }
189}
190
191impl StatefulSetExtPrivate for Kanidm {
192 fn generate_pod_labels(&self, replica_group: &ReplicaGroup) -> BTreeMap<String, String> {
193 self.generate_resource_labels()
194 .into_iter()
195 .chain(std::iter::once((
196 REPLICA_GROUP_LABEL.to_string(),
197 replica_group.name.clone(),
198 )))
199 .collect()
200 }
201
202 fn generate_labels(&self, pod_labels: &BTreeMap<String, String>) -> BTreeMap<String, String> {
203 self.labels()
204 .clone()
205 .into_iter()
206 .chain(pod_labels.clone())
207 .collect()
208 }
209
210 fn generate_env_vars(&self, replica_group: &ReplicaGroup) -> Vec<EnvVar> {
211 let origin = match self.spec.origin.clone() {
212 Some(o) => o,
213 None => format!("https://{}", self.spec.domain.clone()),
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!("0.0.0.0:{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!("0.0.0.0:{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
289 .volume_mounts
290 .clone()
291 .unwrap_or_default()
292 .into_iter()
293 .chain([
294 VolumeMount {
295 name: VOLUME_DATA_NAME.to_string(),
296 mount_path: VOLUME_DATA_PATH.to_string(),
297 ..VolumeMount::default()
298 },
299 VolumeMount {
300 name: VOLUME_TLS_NAME.to_string(),
301 mount_path: VOLUME_TLS_PATH.to_string(),
302 read_only: Some(true),
303 ..VolumeMount::default()
304 },
305 ])
306 .chain(
307 self.is_replication_enabled()
308 .then(|| self.generate_config_volume_mount()),
309 )
310 .collect()
311 }
312
313 fn generate_init_containers(&self, replica_group: &ReplicaGroup) -> Vec<Container> {
314 if self.is_replication_enabled() {
315 let external_replica_nodes_envs = self
316 .spec
317 .external_replication_nodes
318 .iter()
319 .flat_map(|ern| {
320 [
321 EnvVar {
322 name: format!("EXTERNAL_REPLICATION_NODE_{}", ern.name),
323 value: Some(format!(
324 "repl://{host}:{port}",
325 host = ern.hostname.clone(),
326 port = ern.port
327 )),
328 ..EnvVar::default()
329 },
330 EnvVar {
331 name: format!("EXTERNAL_REPLICATION_NODE_{}_CERT", ern.name),
332 value_from: Some(EnvVarSource {
333 secret_key_ref: Some(ern.certificate.clone()),
334 ..EnvVarSource::default()
335 }),
336 ..EnvVar::default()
337 },
338 EnvVar {
339 name: format!("EXTERNAL_REPLICATION_NODE_{}_TYPE", ern.name),
340 value: serde_plain::to_string(&ern._type).ok(),
341 ..EnvVar::default()
342 },
343 EnvVar {
344 name: format!(
345 "EXTERNAL_REPLICATION_NODE_{}_AUTOMATIC_REFRESH",
346 ern.name
347 ),
348 value: Some(ern.automatic_refresh.to_string()),
349 ..EnvVar::default()
350 },
351 ]
352 })
353 .collect::<Vec<EnvVar>>();
354 let replica_secrets_envs = self
355 .spec
356 .replica_groups
357 .iter()
358 .flat_map(|rg| {
359 let sts_name = self.statefulset_name(&rg.name);
360 (0..rg.replicas).flat_map(move |i| {
361 let pod_name = format!("{sts_name}-{i}");
362 let name = pod_name.to_uppercase().replace("-", "_");
363 [
364 EnvVar {
365 name: name.clone(),
366 value_from: Some(EnvVarSource {
367 secret_key_ref: Some(SecretKeySelector {
368 name: self.replica_secret_name(&pod_name),
369 key: REPLICA_SECRET_KEY.to_string(),
370 optional: Some(true),
371 }),
372 ..EnvVarSource::default()
373 }),
374 ..EnvVar::default()
375 },
376 EnvVar {
377 name: format!("{name}_TYPE"),
378 value: replication_type(
379 replica_group.role.clone(),
380 rg.role.clone(),
381 )
382 .and_then(|t| serde_plain::to_string(&t).ok()),
383 ..EnvVar::default()
384 },
385 ]
386 })
387 })
388 .collect::<Vec<EnvVar>>();
389
390 let primary_node = self
391 .spec
392 .replica_groups
393 .iter()
394 .find(|rg| rg.primary_node)
395 .map(|rg| format!("{}-0", self.statefulset_name(&rg.name)));
396 let env = external_replica_nodes_envs
397 .into_iter()
398 .chain(replica_secrets_envs)
399 .chain([
400 EnvVar {
401 name: "POD_NAME".to_string(),
402 value_from: Some(EnvVarSource {
403 field_ref: Some(ObjectFieldSelector {
404 api_version: Some("v1".to_string()),
405 field_path: "metadata.name".to_string(),
406 }),
407 ..EnvVarSource::default()
408 }),
409 ..EnvVar::default()
410 },
411 EnvVar {
412 name: "REPLICATION_PORT".to_string(),
413 value: Some(CONTAINER_REPLICATION_PORT.to_string()),
414 ..EnvVar::default()
415 },
416 EnvVar {
417 name: "KANIDM_CONFIG_PATH".to_string(),
418 value: Some(KANIDM_CONFIG_PATH.to_string()),
419 ..EnvVar::default()
420 },
421 EnvVar {
422 name: "KANIDM_SERVICE_NAME".to_string(),
423 value: Some(self.service_name()),
424 ..EnvVar::default()
425 },
426 ])
427 .chain(primary_node.map(|pn| EnvVar {
428 name: "KANIDM_PRIMARY_NODE".to_string(),
429 value: Some(pn),
430 ..EnvVar::default()
431 }))
432 .collect::<Vec<EnvVar>>();
433
434 let init_container = Container {
435 name: "kanidm-generate-replication-config".to_string(),
436 image: Some(REPLICATION_CONFIG_IMAGE.to_string()),
437 env: Some(env),
438 args: Some(vec![
439 "--script".to_string(),
440 REPLICATION_CONFIG_SCRIPT.to_string(),
441 ]),
442 volume_mounts: Some(vec![self.generate_config_volume_mount()]),
443 ..Container::default()
444 };
445
446 merge_containers(self.spec.init_containers.clone(), &init_container)
447 } else {
448 self.spec.init_containers.clone().unwrap_or_default()
449 }
450 }
451
452 fn generate_container_ports(&self) -> Vec<ContainerPort> {
453 std::iter::once(ContainerPort {
454 name: Some(self.spec.port_name.clone()),
455 container_port: CONTAINER_HTTPS_PORT,
456 ..ContainerPort::default()
457 })
458 .chain(
459 self.spec
460 .ldap_port_name
461 .clone()
462 .into_iter()
463 .map(|port_name| ContainerPort {
464 name: Some(port_name.clone()),
465 container_port: CONTAINER_LDAP_PORT,
466 ..ContainerPort::default()
467 }),
468 )
469 .chain(self.is_replication_enabled().then(|| ContainerPort {
470 name: Some("replication".to_string()),
471 container_port: CONTAINER_REPLICATION_PORT,
472 ..ContainerPort::default()
473 }))
474 .collect()
475 }
476
477 fn generate_probe(&self) -> Probe {
478 Probe {
479 http_get: Some(HTTPGetAction {
480 path: Some("/status".to_string()),
481 port: IntOrString::String(self.spec.port_name.clone()),
482 scheme: Some("HTTPS".to_string()),
483 ..HTTPGetAction::default()
484 }),
485 ..Probe::default()
486 }
487 }
488
489 fn generate_containers(
490 &self,
491 env: &Vec<EnvVar>,
492 volume_mounts: &Vec<VolumeMount>,
493 ports: &Vec<ContainerPort>,
494 probe: &Probe,
495 replica_group: &ReplicaGroup,
496 ) -> Vec<Container> {
497 let command = vec!["kanidmd".to_string(), "server".to_string()]
498 .into_iter()
499 .chain(
500 self.is_replication_enabled()
501 .then(|| vec!["-c".to_string(), KANIDM_CONFIG_PATH.to_string()])
502 .into_iter()
503 .flatten(),
504 )
505 .collect::<Vec<String>>();
506 let kanidm_container = Container {
507 name: "kanidm".to_string(),
508 image: Some(self.spec.image.clone()),
509 image_pull_policy: self.spec.image_pull_policy.clone(),
510 command: Some(command),
511 env: Some(env.clone()),
512 ports: Some(ports.clone()),
513 volume_mounts: Some(volume_mounts.clone()),
514 resources: replica_group.resources.clone(),
515 readiness_probe: Some(probe.clone()),
516 liveness_probe: Some(probe.clone()),
517 ..Container::default()
518 };
519
520 merge_containers(self.spec.containers.clone(), &kanidm_container)
521 }
522
523 fn generate_dns_policy(&self) -> Option<String> {
524 match self.spec.host_network {
525 Some(true) => Some("ClusterFirstWithHostNet".to_string()),
526 _ => self.spec.dns_policy.clone(),
527 }
528 }
529
530 fn generate_volumes(&self) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
531 let secret_name = self.spec.tls_secret_name.clone().unwrap_or_else(|| {
532 self.spec
533 .ingress
534 .as_ref()
535 .and_then(|i| i.tls_secret_name.clone())
536 .unwrap_or_else(|| self.get_tls_secret_name())
537 });
538
539 self.expand_storage(
540 self.spec
541 .volumes
542 .clone()
543 .unwrap_or_default()
544 .into_iter()
545 .chain(std::iter::once(Volume {
546 name: VOLUME_TLS_NAME.to_string(),
547 secret: Some(SecretVolumeSource {
548 secret_name: Some(secret_name),
549 ..SecretVolumeSource::default()
550 }),
551 ..Volume::default()
552 }))
553 .chain(self.is_replication_enabled().then(|| Volume {
554 name: VOLUME_CONFIG_NAME.to_string(),
555 empty_dir: Some(EmptyDirVolumeSource {
556 medium: None,
557 size_limit: None,
558 }),
559 ..Volume::default()
560 }))
561 .collect(),
562 )
563 }
564
565 fn expand_storage(
566 &self,
567 volumes: Vec<Volume>,
568 ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
569 let default_expand_storage = |volumes: Vec<Volume>| {
570 (
571 volumes
572 .into_iter()
573 .chain(std::iter::once(Volume {
574 name: VOLUME_DATA_NAME.to_string(),
575 empty_dir: Some(EmptyDirVolumeSource {
576 medium: None,
577 size_limit: None,
578 }),
579 ..Volume::default()
580 }))
581 .collect(),
582 None,
583 )
584 };
585
586 match self.spec.storage.clone() {
587 Some(storage) => {
588 if let Some(empty_dir) = storage.empty_dir {
589 (
590 volumes
591 .into_iter()
592 .chain(std::iter::once(Volume {
593 name: VOLUME_DATA_NAME.to_string(),
594 empty_dir: Some(empty_dir),
595 ..Volume::default()
596 }))
597 .collect(),
598 None,
599 )
600 } else if let Some(ephemeral) = storage.ephemeral {
601 (
602 volumes
603 .into_iter()
604 .chain(std::iter::once(Volume {
605 name: VOLUME_DATA_NAME.to_string(),
606 ephemeral: Some(ephemeral),
607 ..Volume::default()
608 }))
609 .collect(),
610 None,
611 )
612 } else if let Some(volume_claim_template) = storage.volume_claim_template {
613 let pvc = volume_claim_template.to_persistent_volume_claim();
614 let named_template = PersistentVolumeClaim {
615 metadata: ObjectMeta {
616 name: Some(VOLUME_DATA_NAME.to_string()),
617 ..pvc.metadata
618 },
619 spec: pvc.spec,
620 ..pvc
621 };
622 (volumes, Some(vec![named_template]))
623 } else {
624 default_expand_storage(volumes)
625 }
626 }
627 None => default_expand_storage(volumes),
628 }
629 }
630
631 fn generate_metadata(
632 &self,
633 labels: &BTreeMap<String, String>,
634 replica_group_name: &str,
635 ) -> ObjectMeta {
636 ObjectMeta {
637 name: Some(self.statefulset_name(replica_group_name)),
638 namespace: self.namespace(),
639 labels: Some(labels.clone()),
640 owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
641 annotations: Some(self.annotations().to_owned()),
642 ..ObjectMeta::default()
643 }
644 }
645}
646
647fn replication_type(
648 source_role: KanidmServerRole,
649 target_role: KanidmServerRole,
650) -> Option<ReplicationType> {
651 match (source_role, target_role) {
652 (
653 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
654 KanidmServerRole::WriteReplicaNoUI | KanidmServerRole::WriteReplica,
655 ) => Some(ReplicationType::MutualPull),
656
657 (
658 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
659 KanidmServerRole::ReadOnlyReplica,
660 ) => Some(ReplicationType::AllowPull),
661 (
662 KanidmServerRole::ReadOnlyReplica,
663 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
664 ) => Some(ReplicationType::Pull),
665 (KanidmServerRole::ReadOnlyReplica, KanidmServerRole::ReadOnlyReplica) => None,
666 }
667}
668
669#[cfg(test)]
670mod tests {
671 use super::StatefulSetExtPrivate;
672
673 use crate::kanidm::crd::{Kanidm, KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate};
674 use k8s_openapi::api::core::v1::{EmptyDirVolumeSource, EphemeralVolumeSource, Volume};
675
676 fn create_kanidm_with_storage(storage: Option<KanidmStorage>) -> Kanidm {
677 Kanidm {
678 spec: KanidmSpec {
679 storage,
680 ..Default::default()
681 },
682 ..Default::default()
683 }
684 }
685
686 #[test]
687 fn test_generate_volumes_without_storage() {
688 let kanidm = create_kanidm_with_storage(None);
689 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
690
691 assert_eq!(volumes.clone().len(), 1);
692 assert_eq!(volumes.clone().first().unwrap().name, "kanidm-data");
693 assert!(volumes.first().unwrap().empty_dir.is_some());
694 assert!(volume_claim_template.is_none());
695 }
696
697 #[test]
698 fn test_generate_volumes_with_emptydir() {
699 let storage = Some(KanidmStorage {
700 empty_dir: Some(EmptyDirVolumeSource::default()),
701 ..Default::default()
702 });
703 let kanidm = create_kanidm_with_storage(storage);
704 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
705
706 assert_eq!(volumes.clone().len(), 1);
707 assert!(
708 volumes
709 .iter()
710 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
711 );
712 assert!(volume_claim_template.is_none());
713 }
714
715 #[test]
716 fn test_generate_volumes_with_emptydir_and_ephemeral() {
717 let storage = Some(KanidmStorage {
718 empty_dir: Some(EmptyDirVolumeSource::default()),
719 ephemeral: Some(EphemeralVolumeSource::default()),
720 ..Default::default()
721 });
722 let kanidm = create_kanidm_with_storage(storage);
723 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
724
725 assert_eq!(volumes.clone().len(), 1);
726 assert!(
727 volumes
728 .iter()
729 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
730 );
731 assert!(volume_claim_template.is_none());
732 }
733
734 #[test]
735 fn test_generate_volumes_with_emptydir_ephemeral_and_volumeclaimtemplate() {
736 let storage = Some(KanidmStorage {
737 empty_dir: Some(EmptyDirVolumeSource::default()),
738 ephemeral: Some(EphemeralVolumeSource::default()),
739 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
740 });
741 let kanidm = create_kanidm_with_storage(storage);
742 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
743
744 assert_eq!(volumes.len(), 1);
745 assert!(
746 volumes
747 .iter()
748 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
749 );
750 assert!(volume_claim_template.is_none());
751 }
752
753 #[test]
754 fn test_generate_volumes_with_ephemeral() {
755 let storage = Some(KanidmStorage {
756 ephemeral: Some(EphemeralVolumeSource::default()),
757 ..Default::default()
758 });
759 let kanidm = create_kanidm_with_storage(storage);
760 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
761
762 assert_eq!(volumes.len(), 1);
763 assert!(
764 volumes
765 .iter()
766 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
767 );
768 assert!(volume_claim_template.is_none());
769 }
770
771 #[test]
772 fn test_generate_volumes_with_ephemeral_and_volumeclaimtemplate() {
773 let storage = Some(KanidmStorage {
774 ephemeral: Some(EphemeralVolumeSource::default()),
775 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
776 ..Default::default()
777 });
778 let kanidm = create_kanidm_with_storage(storage);
779 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
780
781 assert_eq!(volumes.len(), 1);
782 assert!(
783 volumes
784 .iter()
785 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
786 );
787 assert!(volume_claim_template.is_none());
788 }
789
790 #[test]
791 fn test_generate_volumes_with_volumeclaimtemplate() {
792 let storage = Some(KanidmStorage {
793 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
794 ..Default::default()
795 });
796 let kanidm = create_kanidm_with_storage(storage);
797 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
798
799 assert!(volumes.is_empty());
800 assert!(volume_claim_template.is_some());
801 }
802
803 #[test]
804 fn test_generate_volumes_with_existing_volumes() {
805 let existing_volume = Volume {
806 name: "existing-volume".to_string(),
807 ..Volume::default()
808 };
809 let kanidm = create_kanidm_with_storage(None);
810 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![existing_volume.clone()]);
811
812 assert_eq!(volumes.len(), 2);
813 assert!(volumes.clone().iter().any(|v| v.name == "existing-volume"));
814 assert!(
815 volumes
816 .iter()
817 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
818 );
819 assert!(volume_claim_template.is_none());
820 }
821
822 #[test]
823 fn test_generate_volumes_with_multiple_existing_volumes() {
824 let existing_volume1 = Volume {
825 name: "existing-volume-1".to_string(),
826 ..Volume::default()
827 };
828 let existing_volume2 = Volume {
829 name: "existing-volume-2".to_string(),
830 ..Volume::default()
831 };
832 let kanidm = create_kanidm_with_storage(None);
833 let (volumes, volume_claim_template) =
834 kanidm.expand_storage(vec![existing_volume1.clone(), existing_volume2.clone()]);
835
836 assert_eq!(volumes.len(), 3);
837 assert!(
838 volumes
839 .clone()
840 .iter()
841 .any(|v| v.name == "existing-volume-1")
842 );
843 assert!(
844 volumes
845 .clone()
846 .iter()
847 .any(|v| v.name == "existing-volume-2")
848 );
849 assert!(
850 volumes
851 .iter()
852 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
853 );
854 assert!(volume_claim_template.is_none());
855 }
856}
857
858#[cfg(all(test, feature = "integration-test"))]
859mod integration_test {
860 use super::{REPLICATION_CONFIG_IMAGE, REPLICATION_CONFIG_SCRIPT};
861
862 use std::fs;
863 use std::path::Path;
864
865 use tempfile::tempdir;
866 use testcontainers::ContainerRequest;
867 use testcontainers::GenericImage;
868 use testcontainers::ImageExt;
869 use testcontainers::core::Mount;
870 use testcontainers::runners::AsyncRunner;
871 use tokio::io::{AsyncBufReadExt, BufReader};
872
873 struct TestCase<'a> {
874 env_vars: Vec<(&'a str, &'a str)>,
875 expected_result: &'a str,
876 }
877
878 async fn run_test_case(
879 image_parts: &[&str],
880 cmd: &[&str],
881 tmp_dir_path: &str,
882 env_vars: &[(&str, &str)],
883 expected_result: &str,
884 ) {
885 let container = GenericImage::new(image_parts[0], image_parts[1]);
886 let mut container_request: ContainerRequest<GenericImage> = container.clone().into();
887
888 for (key, value) in env_vars {
889 container_request =
890 container_request.with_env_var((*key).to_string(), (*value).to_string());
891 }
892
893 let container = container_request
894 .with_cmd(cmd.iter().map(|&s| s.to_string()))
895 .with_mount(Mount::bind_mount(tmp_dir_path.to_string(), "/tmp"))
896 .start()
897 .await
898 .unwrap();
899
900 let stdout = container.stdout(true);
901 let mut stdout_reader = BufReader::new(stdout).lines();
902 let mut stdout_lines = Vec::new();
903 while let Some(l) = stdout_reader.next_line().await.unwrap() {
904 stdout_lines.push(l);
905 }
906 dbg!(stdout_lines.join("\n"));
907
908 let stderr = container.stderr(true);
909 let mut stderr_reader = BufReader::new(stderr).lines();
910 let mut stderr_lines = Vec::new();
911 while let Some(l) = stderr_reader.next_line().await.unwrap() {
912 stderr_lines.push(l);
913 }
914 dbg!(stderr_lines.join("\n"));
915
916 let server_toml_path = Path::new(tmp_dir_path).join("server.toml");
917 let content = fs::read_to_string(server_toml_path).expect("Unable to read server.toml");
918 assert_eq!(content, expected_result);
919 }
920
921 #[tokio::test]
922 async fn test_replication_config_generation() {
923 let image_parts = REPLICATION_CONFIG_IMAGE.split(':').collect::<Vec<&str>>();
924 let cmd = ["--script", REPLICATION_CONFIG_SCRIPT];
925 let tmp_dir = tempdir().unwrap();
926 let tmp_dir_path = tmp_dir.path().to_str().unwrap().to_string();
927
928 let test_cases = vec![
929 TestCase {
930 env_vars: vec![
931 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
932 ("REPLICATION_PORT", "8444"),
933 ("KANIDM_SERVICE_NAME", "kanidm-test"),
934 ("POD_NAME", "kanidm-test-default-0"),
935 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
936 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
937 ],
938 expected_result: r#"version = "2"
939
940[replication]
941origin = "repl://kanidm-test-default-0.kanidm-test:8444"
942bindaddress = "0.0.0.0:8444"
943
944"#,
945 },
946 TestCase {
947 env_vars: vec![
948 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
949 ("REPLICATION_PORT", "8444"),
950 ("KANIDM_SERVICE_NAME", "kanidm-test"),
951 ("POD_NAME", "kanidm-test-default-0"),
952 (
953 "EXTERNAL_REPLICATION_NODE_HOST_0",
954 "repl://external-host-0:8444",
955 ),
956 (
957 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
958 "dummy-cert-external-host-0",
959 ),
960 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
961 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
962 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
963 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
964 ],
965 expected_result: r#"version = "2"
966
967[replication]
968origin = "repl://kanidm-test-default-0.kanidm-test:8444"
969bindaddress = "0.0.0.0:8444"
970
971[replication."repl://external-host-0:8444"]
972type = "mutual-pull"
973partner_cert = "dummy-cert-external-host-0"
974automatic_refresh = true
975
976"#,
977 },
978 TestCase {
979 env_vars: vec![
980 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
981 ("REPLICATION_PORT", "8444"),
982 ("KANIDM_SERVICE_NAME", "kanidm-test"),
983 ("POD_NAME", "kanidm-test-default-0"),
984 (
985 "EXTERNAL_REPLICATION_NODE_HOST_0",
986 "repl://external-host-0:8444",
987 ),
988 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
989 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
990 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
991 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
992 ],
993 expected_result: r#"version = "2"
994
995[replication]
996origin = "repl://kanidm-test-default-0.kanidm-test:8444"
997bindaddress = "0.0.0.0:8444"
998
999"#,
1000 },
1001 TestCase {
1002 env_vars: vec![
1003 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1004 ("REPLICATION_PORT", "8444"),
1005 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1006 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1007 ("POD_NAME", "kanidm-test-default-0"),
1008 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1009 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1010 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1011 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1012 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1013 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1014 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1015 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1016 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1017 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1018 ],
1019 expected_result: r#"version = "2"
1020
1021[replication]
1022origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1023bindaddress = "0.0.0.0:8444"
1024
1025[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1026type = "mutual-pull"
1027partner_cert = "dummy-cert-default-1"
1028automatic_refresh = false
1029
1030[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1031type = "mutual-pull"
1032partner_cert = "dummy-cert-default-3"
1033automatic_refresh = false
1034
1035[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1036type = "allow-pull"
1037consumer_cert = "dummy-cert-read-replica-0"
1038
1039[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1040type = "allow-pull"
1041consumer_cert = "dummy-cert-read-replica-1"
1042
1043"#,
1044 },
1045 TestCase {
1046 env_vars: vec![
1047 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1048 ("REPLICATION_PORT", "8444"),
1049 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1050 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1051 ("POD_NAME", "kanidm-test-default-1"),
1052 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1053 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1054 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1055 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1056 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1057 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1058 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1059 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1060 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1061 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1062 ],
1063 expected_result: r#"version = "2"
1064
1065[replication]
1066origin = "repl://kanidm-test-default-1.kanidm-test:8444"
1067bindaddress = "0.0.0.0:8444"
1068
1069[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1070type = "mutual-pull"
1071partner_cert = "dummy-cert-default-0"
1072automatic_refresh = true
1073
1074[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1075type = "mutual-pull"
1076partner_cert = "dummy-cert-default-3"
1077automatic_refresh = false
1078
1079[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1080type = "allow-pull"
1081consumer_cert = "dummy-cert-read-replica-0"
1082
1083[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1084type = "allow-pull"
1085consumer_cert = "dummy-cert-read-replica-1"
1086
1087"#,
1088 },
1089 TestCase {
1090 env_vars: vec![
1091 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1092 ("REPLICATION_PORT", "8444"),
1093 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1094 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1095 ("POD_NAME", "kanidm-test-default-3"),
1096 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1097 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1098 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1099 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1100 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1101 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1102 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1103 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1104 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1105 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1106 ],
1107 expected_result: r#"version = "2"
1108
1109[replication]
1110origin = "repl://kanidm-test-default-3.kanidm-test:8444"
1111bindaddress = "0.0.0.0:8444"
1112
1113[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1114type = "mutual-pull"
1115partner_cert = "dummy-cert-default-0"
1116automatic_refresh = true
1117
1118[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1119type = "mutual-pull"
1120partner_cert = "dummy-cert-default-1"
1121automatic_refresh = false
1122
1123[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1124type = "allow-pull"
1125consumer_cert = "dummy-cert-read-replica-0"
1126
1127[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1128type = "allow-pull"
1129consumer_cert = "dummy-cert-read-replica-1"
1130
1131"#,
1132 },
1133 TestCase {
1134 env_vars: vec![
1135 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1136 ("REPLICATION_PORT", "8444"),
1137 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1138 ("REPLICA_GROUP", "read-replica"),
1139 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1140 ("POD_NAME", "kanidm-test-read-replica-0"),
1141 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1142 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1143 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1144 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1145 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1146 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1147 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1148 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1149 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1150 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1151 ],
1152 expected_result: r#"version = "2"
1153
1154[replication]
1155origin = "repl://kanidm-test-read-replica-0.kanidm-test:8444"
1156bindaddress = "0.0.0.0:8444"
1157
1158[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1159type = "pull"
1160supplier_cert = "dummy-cert-default-0"
1161automatic_refresh = true
1162
1163[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1164type = "pull"
1165supplier_cert = "dummy-cert-default-1"
1166automatic_refresh = false
1167
1168[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1169type = "pull"
1170supplier_cert = "dummy-cert-default-3"
1171automatic_refresh = false
1172
1173"#,
1174 },
1175 TestCase {
1176 env_vars: vec![
1177 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1178 ("REPLICATION_PORT", "8444"),
1179 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1180 ("REPLICA_GROUP", "read-replica"),
1181 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1182 ("POD_NAME", "kanidm-test-read-replica-1"),
1183 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1184 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1185 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1186 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1187 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1188 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1189 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1190 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1191 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1192 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1193 ],
1194 expected_result: r#"version = "2"
1195
1196[replication]
1197origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1198bindaddress = "0.0.0.0:8444"
1199
1200[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1201type = "pull"
1202supplier_cert = "dummy-cert-default-0"
1203automatic_refresh = true
1204
1205[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1206type = "pull"
1207supplier_cert = "dummy-cert-default-1"
1208automatic_refresh = false
1209
1210[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1211type = "pull"
1212supplier_cert = "dummy-cert-default-3"
1213automatic_refresh = false
1214
1215"#,
1216 },
1217 TestCase {
1218 env_vars: vec![
1219 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1220 ("REPLICATION_PORT", "8444"),
1221 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1222 ("REPLICA_GROUP", "read-replica"),
1223 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1224 ("POD_NAME", "kanidm-test-read-replica-1"),
1225 (
1226 "EXTERNAL_REPLICATION_NODE_HOST_0",
1227 "repl://external-host-0:8444",
1228 ),
1229 (
1230 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1231 "dummy-cert-external-host-0",
1232 ),
1233 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1234 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1235 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1236 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1237 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1238 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1239 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1240 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1241 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1242 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1243 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1244 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1245 ],
1246 expected_result: r#"version = "2"
1247
1248[replication]
1249origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1250bindaddress = "0.0.0.0:8444"
1251
1252[replication."repl://external-host-0:8444"]
1253type = "mutual-pull"
1254partner_cert = "dummy-cert-external-host-0"
1255automatic_refresh = true
1256
1257[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1258type = "pull"
1259supplier_cert = "dummy-cert-default-0"
1260automatic_refresh = true
1261
1262[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1263type = "pull"
1264supplier_cert = "dummy-cert-default-1"
1265automatic_refresh = false
1266
1267[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1268type = "pull"
1269supplier_cert = "dummy-cert-default-3"
1270automatic_refresh = false
1271
1272"#,
1273 },
1274 ];
1275
1276 for test_case in test_cases {
1277 run_test_case(
1278 &image_parts,
1279 &cmd,
1280 &tmp_dir_path,
1281 &test_case.env_vars,
1282 test_case.expected_result,
1283 )
1284 .await;
1285 }
1286 }
1287}