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