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