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