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