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.2";
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
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) -> 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 let sts_name = self.statefulset_name(&rg.name);
359 (0..rg.replicas).flat_map(move |i| {
360 let pod_name = format!("{sts_name}-{i}");
361 let name = pod_name.to_uppercase().replace("-", "_");
362 [
363 EnvVar {
364 name: name.clone(),
365 value_from: Some(EnvVarSource {
366 secret_key_ref: Some(SecretKeySelector {
367 name: self.replica_secret_name(&pod_name),
368 key: REPLICA_SECRET_KEY.to_string(),
369 optional: Some(true),
370 }),
371 ..EnvVarSource::default()
372 }),
373 ..EnvVar::default()
374 },
375 EnvVar {
376 name: format!("{name}_TYPE"),
377 value: replication_type(
378 replica_group.role.clone(),
379 rg.role.clone(),
380 )
381 .and_then(|t| serde_plain::to_string(&t).ok()),
382 ..EnvVar::default()
383 },
384 ]
385 })
386 })
387 .collect::<Vec<EnvVar>>();
388
389 let primary_node = self
390 .spec
391 .replica_groups
392 .iter()
393 .find(|rg| rg.primary_node)
394 .map(|rg| format!("{}-0", self.statefulset_name(&rg.name)));
395 let env = external_replica_nodes_envs
396 .into_iter()
397 .chain(replica_secrets_envs)
398 .chain([
399 EnvVar {
400 name: "POD_NAME".to_string(),
401 value_from: Some(EnvVarSource {
402 field_ref: Some(ObjectFieldSelector {
403 api_version: Some("v1".to_string()),
404 field_path: "metadata.name".to_string(),
405 }),
406 ..EnvVarSource::default()
407 }),
408 ..EnvVar::default()
409 },
410 EnvVar {
411 name: "REPLICATION_PORT".to_string(),
412 value: Some(CONTAINER_REPLICATION_PORT.to_string()),
413 ..EnvVar::default()
414 },
415 EnvVar {
416 name: "KANIDM_CONFIG_PATH".to_string(),
417 value: Some(KANIDM_CONFIG_PATH.to_string()),
418 ..EnvVar::default()
419 },
420 EnvVar {
421 name: "KANIDM_SERVICE_NAME".to_string(),
422 value: Some(self.service_name()),
423 ..EnvVar::default()
424 },
425 ])
426 .chain(primary_node.map(|pn| EnvVar {
427 name: "KANIDM_PRIMARY_NODE".to_string(),
428 value: Some(pn),
429 ..EnvVar::default()
430 }))
431 .collect::<Vec<EnvVar>>();
432
433 let init_container = Container {
434 name: "kanidm-generate-replication-config".to_string(),
435 image: Some(REPLICATION_CONFIG_IMAGE.to_string()),
436 env: Some(env),
437 args: Some(vec![
438 "--script".to_string(),
439 REPLICATION_CONFIG_SCRIPT.to_string(),
440 ]),
441 volume_mounts: Some(vec![self.generate_config_volume_mount()]),
442 ..Container::default()
443 };
444
445 merge_containers(self.spec.init_containers.clone(), &init_container)
446 } else {
447 self.spec.init_containers.clone().unwrap_or_default()
448 }
449 }
450
451 fn generate_container_ports(&self) -> Vec<ContainerPort> {
452 std::iter::once(ContainerPort {
453 name: Some(self.spec.port_name.clone()),
454 container_port: CONTAINER_HTTPS_PORT,
455 ..ContainerPort::default()
456 })
457 .chain(
458 self.spec
459 .ldap_port_name
460 .clone()
461 .into_iter()
462 .map(|port_name| ContainerPort {
463 name: Some(port_name.clone()),
464 container_port: CONTAINER_LDAP_PORT,
465 ..ContainerPort::default()
466 }),
467 )
468 .chain(self.is_replication_enabled().then(|| ContainerPort {
469 name: Some("replication".to_string()),
470 container_port: CONTAINER_REPLICATION_PORT,
471 ..ContainerPort::default()
472 }))
473 .collect()
474 }
475
476 fn generate_probe(&self) -> Probe {
477 Probe {
478 http_get: Some(HTTPGetAction {
479 path: Some("/status".to_string()),
480 port: IntOrString::String(self.spec.port_name.clone()),
481 scheme: Some("HTTPS".to_string()),
482 ..HTTPGetAction::default()
483 }),
484 ..Probe::default()
485 }
486 }
487
488 fn generate_containers(
489 &self,
490 env: &Vec<EnvVar>,
491 volume_mounts: &Vec<VolumeMount>,
492 ports: &Vec<ContainerPort>,
493 probe: &Probe,
494 replica_group: &ReplicaGroup,
495 ) -> Vec<Container> {
496 let command = vec!["kanidmd".to_string(), "server".to_string()]
497 .into_iter()
498 .chain(
499 self.is_replication_enabled()
500 .then(|| vec!["-c".to_string(), KANIDM_CONFIG_PATH.to_string()])
501 .into_iter()
502 .flatten(),
503 )
504 .collect::<Vec<String>>();
505 let kanidm_container = Container {
506 name: "kanidm".to_string(),
507 image: Some(self.spec.image.clone()),
508 image_pull_policy: self.spec.image_pull_policy.clone(),
509 command: Some(command),
510 env: Some(env.clone()),
511 ports: Some(ports.clone()),
512 volume_mounts: Some(volume_mounts.clone()),
513 resources: replica_group.resources.clone(),
514 readiness_probe: Some(probe.clone()),
515 liveness_probe: Some(probe.clone()),
516 ..Container::default()
517 };
518
519 merge_containers(self.spec.containers.clone(), &kanidm_container)
520 }
521
522 fn generate_dns_policy(&self) -> Option<String> {
523 match self.spec.host_network {
524 Some(true) => Some("ClusterFirstWithHostNet".to_string()),
525 _ => self.spec.dns_policy.clone(),
526 }
527 }
528
529 fn generate_volumes(&self) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
530 let secret_name = self.spec.tls_secret_name.clone().unwrap_or_else(|| {
531 self.spec
532 .ingress
533 .as_ref()
534 .and_then(|i| i.tls_secret_name.clone())
535 .unwrap_or_else(|| self.get_tls_secret_name())
536 });
537
538 self.expand_storage(
539 self.spec
540 .volumes
541 .clone()
542 .unwrap_or_default()
543 .into_iter()
544 .chain(std::iter::once(Volume {
545 name: VOLUME_TLS_NAME.to_string(),
546 secret: Some(SecretVolumeSource {
547 secret_name: Some(secret_name),
548 ..SecretVolumeSource::default()
549 }),
550 ..Volume::default()
551 }))
552 .chain(self.is_replication_enabled().then(|| Volume {
553 name: VOLUME_CONFIG_NAME.to_string(),
554 empty_dir: Some(EmptyDirVolumeSource {
555 medium: None,
556 size_limit: None,
557 }),
558 ..Volume::default()
559 }))
560 .collect(),
561 )
562 }
563
564 fn expand_storage(
565 &self,
566 volumes: Vec<Volume>,
567 ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
568 let default_expand_storage = |volumes: Vec<Volume>| {
569 (
570 volumes
571 .into_iter()
572 .chain(std::iter::once(Volume {
573 name: VOLUME_DATA_NAME.to_string(),
574 empty_dir: Some(EmptyDirVolumeSource {
575 medium: None,
576 size_limit: None,
577 }),
578 ..Volume::default()
579 }))
580 .collect(),
581 None,
582 )
583 };
584
585 match self.spec.storage.clone() {
586 Some(storage) => {
587 if let Some(empty_dir) = storage.empty_dir {
588 (
589 volumes
590 .into_iter()
591 .chain(std::iter::once(Volume {
592 name: VOLUME_DATA_NAME.to_string(),
593 empty_dir: Some(empty_dir),
594 ..Volume::default()
595 }))
596 .collect(),
597 None,
598 )
599 } else if let Some(ephemeral) = storage.ephemeral {
600 (
601 volumes
602 .into_iter()
603 .chain(std::iter::once(Volume {
604 name: VOLUME_DATA_NAME.to_string(),
605 ephemeral: Some(ephemeral),
606 ..Volume::default()
607 }))
608 .collect(),
609 None,
610 )
611 } else if let Some(volume_claim_template) = storage.volume_claim_template {
612 let pvc = volume_claim_template.to_persistent_volume_claim();
613 let named_template = PersistentVolumeClaim {
614 metadata: ObjectMeta {
615 name: Some(VOLUME_DATA_NAME.to_string()),
616 ..pvc.metadata
617 },
618 spec: pvc.spec,
619 ..pvc
620 };
621 (volumes, Some(vec![named_template]))
622 } else {
623 default_expand_storage(volumes)
624 }
625 }
626 None => default_expand_storage(volumes),
627 }
628 }
629
630 fn generate_metadata(
631 &self,
632 labels: &BTreeMap<String, String>,
633 replica_group_name: &str,
634 ) -> ObjectMeta {
635 ObjectMeta {
636 name: Some(self.statefulset_name(replica_group_name)),
637 namespace: self.namespace(),
638 labels: Some(labels.clone()),
639 owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
640 annotations: Some(self.annotations().to_owned()),
641 ..ObjectMeta::default()
642 }
643 }
644}
645
646fn replication_type(
647 source_role: KanidmServerRole,
648 target_role: KanidmServerRole,
649) -> Option<ReplicationType> {
650 match (source_role, target_role) {
651 (
652 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
653 KanidmServerRole::WriteReplicaNoUI | KanidmServerRole::WriteReplica,
654 ) => Some(ReplicationType::MutualPull),
655
656 (
657 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
658 KanidmServerRole::ReadOnlyReplica,
659 ) => Some(ReplicationType::AllowPull),
660 (
661 KanidmServerRole::ReadOnlyReplica,
662 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUI,
663 ) => Some(ReplicationType::Pull),
664 (KanidmServerRole::ReadOnlyReplica, KanidmServerRole::ReadOnlyReplica) => None,
665 }
666}
667
668#[cfg(test)]
669mod tests {
670 use super::StatefulSetExtPrivate;
671
672 use crate::kanidm::crd::{Kanidm, KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate};
673 use k8s_openapi::api::core::v1::{EmptyDirVolumeSource, EphemeralVolumeSource, Volume};
674
675 fn create_kanidm_with_storage(storage: Option<KanidmStorage>) -> Kanidm {
676 Kanidm {
677 spec: KanidmSpec {
678 storage,
679 ..Default::default()
680 },
681 ..Default::default()
682 }
683 }
684
685 #[test]
686 fn test_generate_volumes_without_storage() {
687 let kanidm = create_kanidm_with_storage(None);
688 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
689
690 assert_eq!(volumes.clone().len(), 1);
691 assert_eq!(volumes.clone().first().unwrap().name, "kanidm-data");
692 assert!(volumes.first().unwrap().empty_dir.is_some());
693 assert!(volume_claim_template.is_none());
694 }
695
696 #[test]
697 fn test_generate_volumes_with_emptydir() {
698 let storage = Some(KanidmStorage {
699 empty_dir: Some(EmptyDirVolumeSource::default()),
700 ..Default::default()
701 });
702 let kanidm = create_kanidm_with_storage(storage);
703 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
704
705 assert_eq!(volumes.clone().len(), 1);
706 assert!(
707 volumes
708 .iter()
709 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
710 );
711 assert!(volume_claim_template.is_none());
712 }
713
714 #[test]
715 fn test_generate_volumes_with_emptydir_and_ephemeral() {
716 let storage = Some(KanidmStorage {
717 empty_dir: Some(EmptyDirVolumeSource::default()),
718 ephemeral: Some(EphemeralVolumeSource::default()),
719 ..Default::default()
720 });
721 let kanidm = create_kanidm_with_storage(storage);
722 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
723
724 assert_eq!(volumes.clone().len(), 1);
725 assert!(
726 volumes
727 .iter()
728 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
729 );
730 assert!(volume_claim_template.is_none());
731 }
732
733 #[test]
734 fn test_generate_volumes_with_emptydir_ephemeral_and_volumeclaimtemplate() {
735 let storage = Some(KanidmStorage {
736 empty_dir: Some(EmptyDirVolumeSource::default()),
737 ephemeral: Some(EphemeralVolumeSource::default()),
738 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
739 });
740 let kanidm = create_kanidm_with_storage(storage);
741 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
742
743 assert_eq!(volumes.len(), 1);
744 assert!(
745 volumes
746 .iter()
747 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
748 );
749 assert!(volume_claim_template.is_none());
750 }
751
752 #[test]
753 fn test_generate_volumes_with_ephemeral() {
754 let storage = Some(KanidmStorage {
755 ephemeral: Some(EphemeralVolumeSource::default()),
756 ..Default::default()
757 });
758 let kanidm = create_kanidm_with_storage(storage);
759 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
760
761 assert_eq!(volumes.len(), 1);
762 assert!(
763 volumes
764 .iter()
765 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
766 );
767 assert!(volume_claim_template.is_none());
768 }
769
770 #[test]
771 fn test_generate_volumes_with_ephemeral_and_volumeclaimtemplate() {
772 let storage = Some(KanidmStorage {
773 ephemeral: Some(EphemeralVolumeSource::default()),
774 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
775 ..Default::default()
776 });
777 let kanidm = create_kanidm_with_storage(storage);
778 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
779
780 assert_eq!(volumes.len(), 1);
781 assert!(
782 volumes
783 .iter()
784 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
785 );
786 assert!(volume_claim_template.is_none());
787 }
788
789 #[test]
790 fn test_generate_volumes_with_volumeclaimtemplate() {
791 let storage = Some(KanidmStorage {
792 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
793 ..Default::default()
794 });
795 let kanidm = create_kanidm_with_storage(storage);
796 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
797
798 assert!(volumes.is_empty());
799 assert!(volume_claim_template.is_some());
800 }
801
802 #[test]
803 fn test_generate_volumes_with_existing_volumes() {
804 let existing_volume = Volume {
805 name: "existing-volume".to_string(),
806 ..Volume::default()
807 };
808 let kanidm = create_kanidm_with_storage(None);
809 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![existing_volume.clone()]);
810
811 assert_eq!(volumes.len(), 2);
812 assert!(volumes.clone().iter().any(|v| v.name == "existing-volume"));
813 assert!(
814 volumes
815 .iter()
816 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
817 );
818 assert!(volume_claim_template.is_none());
819 }
820
821 #[test]
822 fn test_generate_volumes_with_multiple_existing_volumes() {
823 let existing_volume1 = Volume {
824 name: "existing-volume-1".to_string(),
825 ..Volume::default()
826 };
827 let existing_volume2 = Volume {
828 name: "existing-volume-2".to_string(),
829 ..Volume::default()
830 };
831 let kanidm = create_kanidm_with_storage(None);
832 let (volumes, volume_claim_template) =
833 kanidm.expand_storage(vec![existing_volume1.clone(), existing_volume2.clone()]);
834
835 assert_eq!(volumes.len(), 3);
836 assert!(
837 volumes
838 .clone()
839 .iter()
840 .any(|v| v.name == "existing-volume-1")
841 );
842 assert!(
843 volumes
844 .clone()
845 .iter()
846 .any(|v| v.name == "existing-volume-2")
847 );
848 assert!(
849 volumes
850 .iter()
851 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
852 );
853 assert!(volume_claim_template.is_none());
854 }
855}
856
857#[cfg(all(test, feature = "integration-test"))]
858mod integration_test {
859 use super::{REPLICATION_CONFIG_IMAGE, REPLICATION_CONFIG_SCRIPT};
860
861 use std::fs;
862 use std::path::Path;
863
864 use tempfile::tempdir;
865 use testcontainers::ContainerRequest;
866 use testcontainers::GenericImage;
867 use testcontainers::ImageExt;
868 use testcontainers::core::Mount;
869 use testcontainers::runners::AsyncRunner;
870 use tokio::io::{AsyncBufReadExt, BufReader};
871
872 struct TestCase<'a> {
873 env_vars: Vec<(&'a str, &'a str)>,
874 expected_result: &'a str,
875 }
876
877 async fn run_test_case(
878 image_parts: &[&str],
879 cmd: &[&str],
880 tmp_dir_path: &str,
881 env_vars: &[(&str, &str)],
882 expected_result: &str,
883 ) {
884 let container = GenericImage::new(image_parts[0], image_parts[1]);
885 let mut container_request: ContainerRequest<GenericImage> = container.clone().into();
886
887 for (key, value) in env_vars {
888 container_request =
889 container_request.with_env_var((*key).to_string(), (*value).to_string());
890 }
891
892 let container = container_request
893 .with_cmd(cmd.iter().map(|&s| s.to_string()))
894 .with_mount(Mount::bind_mount(tmp_dir_path.to_string(), "/tmp"))
895 .start()
896 .await
897 .unwrap();
898
899 let stdout = container.stdout(true);
900 let mut stdout_reader = BufReader::new(stdout).lines();
901 let mut stdout_lines = Vec::new();
902 while let Some(l) = stdout_reader.next_line().await.unwrap() {
903 stdout_lines.push(l);
904 }
905 dbg!(stdout_lines.join("\n"));
906
907 let stderr = container.stderr(true);
908 let mut stderr_reader = BufReader::new(stderr).lines();
909 let mut stderr_lines = Vec::new();
910 while let Some(l) = stderr_reader.next_line().await.unwrap() {
911 stderr_lines.push(l);
912 }
913 dbg!(stderr_lines.join("\n"));
914
915 let server_toml_path = Path::new(tmp_dir_path).join("server.toml");
916 let content = fs::read_to_string(server_toml_path).expect("Unable to read server.toml");
917 assert_eq!(content, expected_result);
918 }
919
920 #[tokio::test]
921 async fn test_replication_config_generation() {
922 let image_parts = REPLICATION_CONFIG_IMAGE.split(':').collect::<Vec<&str>>();
923 let cmd = ["--script", REPLICATION_CONFIG_SCRIPT];
924 let tmp_dir = tempdir().unwrap();
925 let tmp_dir_path = tmp_dir.path().to_str().unwrap().to_string();
926
927 let test_cases = vec![
928 TestCase {
929 env_vars: vec![
930 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
931 ("REPLICATION_PORT", "8444"),
932 ("KANIDM_SERVICE_NAME", "kanidm-test"),
933 ("POD_NAME", "kanidm-test-default-0"),
934 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
935 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
936 ],
937 expected_result: r#"version = "2"
938
939[replication]
940origin = "repl://kanidm-test-default-0.kanidm-test:8444"
941bindaddress = "0.0.0.0:8444"
942
943"#,
944 },
945 TestCase {
946 env_vars: vec![
947 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
948 ("REPLICATION_PORT", "8444"),
949 ("KANIDM_SERVICE_NAME", "kanidm-test"),
950 ("POD_NAME", "kanidm-test-default-0"),
951 (
952 "EXTERNAL_REPLICATION_NODE_HOST_0",
953 "repl://external-host-0:8444",
954 ),
955 (
956 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
957 "dummy-cert-external-host-0",
958 ),
959 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
960 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
961 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
962 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
963 ],
964 expected_result: r#"version = "2"
965
966[replication]
967origin = "repl://kanidm-test-default-0.kanidm-test:8444"
968bindaddress = "0.0.0.0:8444"
969
970[replication."repl://external-host-0:8444"]
971type = "mutual-pull"
972partner_cert = "dummy-cert-external-host-0"
973automatic_refresh = true
974
975"#,
976 },
977 TestCase {
978 env_vars: vec![
979 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
980 ("REPLICATION_PORT", "8444"),
981 ("KANIDM_SERVICE_NAME", "kanidm-test"),
982 ("POD_NAME", "kanidm-test-default-0"),
983 (
984 "EXTERNAL_REPLICATION_NODE_HOST_0",
985 "repl://external-host-0:8444",
986 ),
987 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
988 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
989 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
990 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
991 ],
992 expected_result: r#"version = "2"
993
994[replication]
995origin = "repl://kanidm-test-default-0.kanidm-test:8444"
996bindaddress = "0.0.0.0:8444"
997
998"#,
999 },
1000 TestCase {
1001 env_vars: vec![
1002 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1003 ("REPLICATION_PORT", "8444"),
1004 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1005 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1006 ("POD_NAME", "kanidm-test-default-0"),
1007 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1008 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1009 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1010 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1011 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1012 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1013 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1014 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1015 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1016 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1017 ],
1018 expected_result: r#"version = "2"
1019
1020[replication]
1021origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1022bindaddress = "0.0.0.0:8444"
1023
1024[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1025type = "mutual-pull"
1026partner_cert = "dummy-cert-default-1"
1027automatic_refresh = false
1028
1029[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1030type = "mutual-pull"
1031partner_cert = "dummy-cert-default-3"
1032automatic_refresh = false
1033
1034[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1035type = "allow-pull"
1036consumer_cert = "dummy-cert-read-replica-0"
1037
1038[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1039type = "allow-pull"
1040consumer_cert = "dummy-cert-read-replica-1"
1041
1042"#,
1043 },
1044 TestCase {
1045 env_vars: vec![
1046 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1047 ("REPLICATION_PORT", "8444"),
1048 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1049 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1050 ("POD_NAME", "kanidm-test-default-1"),
1051 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1052 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1053 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1054 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1055 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1056 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1057 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1058 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1059 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1060 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1061 ],
1062 expected_result: r#"version = "2"
1063
1064[replication]
1065origin = "repl://kanidm-test-default-1.kanidm-test:8444"
1066bindaddress = "0.0.0.0:8444"
1067
1068[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1069type = "mutual-pull"
1070partner_cert = "dummy-cert-default-0"
1071automatic_refresh = true
1072
1073[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1074type = "mutual-pull"
1075partner_cert = "dummy-cert-default-3"
1076automatic_refresh = false
1077
1078[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1079type = "allow-pull"
1080consumer_cert = "dummy-cert-read-replica-0"
1081
1082[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1083type = "allow-pull"
1084consumer_cert = "dummy-cert-read-replica-1"
1085
1086"#,
1087 },
1088 TestCase {
1089 env_vars: vec![
1090 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1091 ("REPLICATION_PORT", "8444"),
1092 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1093 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1094 ("POD_NAME", "kanidm-test-default-3"),
1095 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1096 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1097 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1098 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1099 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1100 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1101 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1102 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1103 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1104 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1105 ],
1106 expected_result: r#"version = "2"
1107
1108[replication]
1109origin = "repl://kanidm-test-default-3.kanidm-test:8444"
1110bindaddress = "0.0.0.0:8444"
1111
1112[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1113type = "mutual-pull"
1114partner_cert = "dummy-cert-default-0"
1115automatic_refresh = true
1116
1117[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1118type = "mutual-pull"
1119partner_cert = "dummy-cert-default-1"
1120automatic_refresh = false
1121
1122[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1123type = "allow-pull"
1124consumer_cert = "dummy-cert-read-replica-0"
1125
1126[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1127type = "allow-pull"
1128consumer_cert = "dummy-cert-read-replica-1"
1129
1130"#,
1131 },
1132 TestCase {
1133 env_vars: vec![
1134 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1135 ("REPLICATION_PORT", "8444"),
1136 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1137 ("REPLICA_GROUP", "read-replica"),
1138 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1139 ("POD_NAME", "kanidm-test-read-replica-0"),
1140 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1141 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1142 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1143 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1144 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1145 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1146 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1147 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1148 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1149 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1150 ],
1151 expected_result: r#"version = "2"
1152
1153[replication]
1154origin = "repl://kanidm-test-read-replica-0.kanidm-test:8444"
1155bindaddress = "0.0.0.0:8444"
1156
1157[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1158type = "pull"
1159supplier_cert = "dummy-cert-default-0"
1160automatic_refresh = true
1161
1162[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1163type = "pull"
1164supplier_cert = "dummy-cert-default-1"
1165automatic_refresh = false
1166
1167[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1168type = "pull"
1169supplier_cert = "dummy-cert-default-3"
1170automatic_refresh = false
1171
1172"#,
1173 },
1174 TestCase {
1175 env_vars: vec![
1176 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1177 ("REPLICATION_PORT", "8444"),
1178 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1179 ("REPLICA_GROUP", "read-replica"),
1180 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1181 ("POD_NAME", "kanidm-test-read-replica-1"),
1182 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1183 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1184 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1185 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1186 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1187 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1188 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1189 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1190 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1191 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1192 ],
1193 expected_result: r#"version = "2"
1194
1195[replication]
1196origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1197bindaddress = "0.0.0.0:8444"
1198
1199[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1200type = "pull"
1201supplier_cert = "dummy-cert-default-0"
1202automatic_refresh = true
1203
1204[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1205type = "pull"
1206supplier_cert = "dummy-cert-default-1"
1207automatic_refresh = false
1208
1209[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1210type = "pull"
1211supplier_cert = "dummy-cert-default-3"
1212automatic_refresh = false
1213
1214"#,
1215 },
1216 TestCase {
1217 env_vars: vec![
1218 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1219 ("REPLICATION_PORT", "8444"),
1220 ("KANIDM_SERVICE_NAME", "kanidm-test"),
1221 ("REPLICA_GROUP", "read-replica"),
1222 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1223 ("POD_NAME", "kanidm-test-read-replica-1"),
1224 (
1225 "EXTERNAL_REPLICATION_NODE_HOST_0",
1226 "repl://external-host-0:8444",
1227 ),
1228 (
1229 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1230 "dummy-cert-external-host-0",
1231 ),
1232 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1233 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1234 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1235 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1236 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1237 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1238 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1239 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1240 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1241 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1242 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1243 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1244 ],
1245 expected_result: r#"version = "2"
1246
1247[replication]
1248origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1249bindaddress = "0.0.0.0:8444"
1250
1251[replication."repl://external-host-0:8444"]
1252type = "mutual-pull"
1253partner_cert = "dummy-cert-external-host-0"
1254automatic_refresh = true
1255
1256[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1257type = "pull"
1258supplier_cert = "dummy-cert-default-0"
1259automatic_refresh = true
1260
1261[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1262type = "pull"
1263supplier_cert = "dummy-cert-default-1"
1264automatic_refresh = false
1265
1266[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1267type = "pull"
1268supplier_cert = "dummy-cert-default-3"
1269automatic_refresh = false
1270
1271"#,
1272 },
1273 ];
1274
1275 for test_case in test_cases {
1276 run_test_case(
1277 &image_parts,
1278 &cmd,
1279 &tmp_dir_path,
1280 &test_case.env_vars,
1281 test_case.expected_result,
1282 )
1283 .await;
1284 }
1285 }
1286}