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