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