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