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