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