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