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 Ok(self.spec.init_containers.clone().unwrap_or_default())
497 }
498 }
499
500 fn generate_container_ports(&self) -> Vec<ContainerPort> {
501 std::iter::once(ContainerPort {
502 name: Some(self.spec.port_name.clone()),
503 container_port: CONTAINER_HTTPS_PORT,
504 ..ContainerPort::default()
505 })
506 .chain(
507 self.spec
508 .ldap_port_name
509 .clone()
510 .into_iter()
511 .map(|port_name| ContainerPort {
512 name: Some(port_name.clone()),
513 container_port: CONTAINER_LDAP_PORT,
514 ..ContainerPort::default()
515 }),
516 )
517 .chain(self.is_replication_enabled().then(|| ContainerPort {
518 name: Some(CONTAINER_REPLICATION_PORT_NAME.to_string()),
519 container_port: CONTAINER_REPLICATION_PORT,
520 ..ContainerPort::default()
521 }))
522 .collect()
523 }
524
525 fn generate_probe(&self) -> Probe {
526 Probe {
527 http_get: Some(HTTPGetAction {
528 path: Some("/status".to_string()),
529 port: IntOrString::String(self.spec.port_name.clone()),
530 scheme: Some("HTTPS".to_string()),
531 ..HTTPGetAction::default()
532 }),
533 ..Probe::default()
534 }
535 }
536
537 fn generate_containers(
538 &self,
539 env: &[EnvVar],
540 volume_mounts: &[VolumeMount],
541 ports: &[ContainerPort],
542 probe: &Probe,
543 replica_group: &ReplicaGroup,
544 ) -> Result<Vec<Container>> {
545 let command = vec!["kanidmd".to_string(), "server".to_string()]
546 .into_iter()
547 .chain(
548 self.is_replication_enabled()
549 .then(|| vec!["-c".to_string(), KANIDM_CONFIG_PATH.to_string()])
550 .into_iter()
551 .flatten(),
552 )
553 .collect::<Vec<String>>();
554 let kanidm_container = Container {
555 name: "kanidm".to_string(),
556 image: Some(self.spec.image.clone()),
557 image_pull_policy: self.spec.image_pull_policy.clone(),
558 command: Some(command),
559 env: Some(env.to_owned()),
560 ports: Some(ports.to_owned()),
561 volume_mounts: Some(volume_mounts.to_owned()),
562 resources: replica_group.resources.clone(),
563 readiness_probe: Some(probe.clone()),
564 liveness_probe: Some(probe.clone()),
565 ..Container::default()
566 };
567
568 merge_containers(self.spec.containers.clone(), &kanidm_container)
569 }
570
571 fn generate_dns_policy(&self) -> Option<String> {
572 match self.spec.host_network {
573 Some(true) => Some("ClusterFirstWithHostNet".to_string()),
574 _ => self.spec.dns_policy.clone(),
575 }
576 }
577
578 fn generate_volumes(&self) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
579 let secret_name = self.effective_tls_secret_name();
580
581 self.expand_storage(
582 self.spec
583 .volumes
584 .clone()
585 .unwrap_or_default()
586 .into_iter()
587 .chain(std::iter::once(Volume {
588 name: VOLUME_TLS_NAME.to_string(),
589 secret: Some(SecretVolumeSource {
590 secret_name: Some(secret_name),
591 default_mode: Some(0o400),
592 ..SecretVolumeSource::default()
593 }),
594 ..Volume::default()
595 }))
596 .chain(self.is_replication_enabled().then(|| Volume {
597 name: VOLUME_CONFIG_NAME.to_string(),
598 empty_dir: Some(EmptyDirVolumeSource {
599 medium: None,
600 size_limit: None,
601 }),
602 ..Volume::default()
603 }))
604 .collect(),
605 )
606 }
607
608 fn expand_storage(
609 &self,
610 volumes: Vec<Volume>,
611 ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
612 let default_expand_storage = |volumes: Vec<Volume>| {
613 (
614 volumes
615 .into_iter()
616 .chain(std::iter::once(Volume {
617 name: VOLUME_DATA_NAME.to_string(),
618 empty_dir: Some(EmptyDirVolumeSource {
619 medium: None,
620 size_limit: None,
621 }),
622 ..Volume::default()
623 }))
624 .collect(),
625 None,
626 )
627 };
628
629 match self.spec.storage.clone() {
630 Some(storage) => {
631 if let Some(empty_dir) = storage.empty_dir {
632 (
633 volumes
634 .into_iter()
635 .chain(std::iter::once(Volume {
636 name: VOLUME_DATA_NAME.to_string(),
637 empty_dir: Some(empty_dir),
638 ..Volume::default()
639 }))
640 .collect(),
641 None,
642 )
643 } else if let Some(ephemeral) = storage.ephemeral {
644 (
645 volumes
646 .into_iter()
647 .chain(std::iter::once(Volume {
648 name: VOLUME_DATA_NAME.to_string(),
649 ephemeral: Some(ephemeral),
650 ..Volume::default()
651 }))
652 .collect(),
653 None,
654 )
655 } else if let Some(volume_claim_template) = storage.volume_claim_template {
656 let pvc = volume_claim_template.to_persistent_volume_claim();
657 let named_template = PersistentVolumeClaim {
658 metadata: ObjectMeta {
659 name: Some(VOLUME_DATA_NAME.to_string()),
660 ..pvc.metadata
661 },
662 spec: pvc.spec,
663 ..pvc
664 };
665 (volumes, Some(vec![named_template]))
666 } else {
667 default_expand_storage(volumes)
668 }
669 }
670 None => default_expand_storage(volumes),
671 }
672 }
673
674 fn generate_metadata(
675 &self,
676 replica_group_name: &str,
677 annotations: &Option<BTreeMap<String, String>>,
678 labels: &BTreeMap<String, String>,
679 ) -> ObjectMeta {
680 ObjectMeta {
681 name: Some(self.statefulset_name(replica_group_name)),
682 namespace: self.namespace(),
683 labels: Some(labels.clone()),
684 owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
685 annotations: annotations.clone(),
686 ..ObjectMeta::default()
687 }
688 }
689}
690
691fn replication_type(
692 source_role: KanidmServerRole,
693 target_role: KanidmServerRole,
694) -> Option<ReplicationType> {
695 match (source_role, target_role) {
696 (
697 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
698 KanidmServerRole::WriteReplicaNoUi | KanidmServerRole::WriteReplica,
699 ) => Some(ReplicationType::MutualPull),
700
701 (
702 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
703 KanidmServerRole::ReadOnlyReplica,
704 ) => Some(ReplicationType::AllowPull),
705 (
706 KanidmServerRole::ReadOnlyReplica,
707 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
708 ) => Some(ReplicationType::Pull),
709 (KanidmServerRole::ReadOnlyReplica, KanidmServerRole::ReadOnlyReplica) => None,
710 }
711}
712
713#[cfg(test)]
714mod tests {
715 use super::{StatefulSetExt, TLS_SECRET_HASH_ANNOTATION};
716 use crate::kanidm::crd::{
717 Kanidm, KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
718 };
719 use k8s_openapi::api::core::v1::{EmptyDirVolumeSource, EphemeralVolumeSource, Volume};
720 use kube::api::ObjectMeta;
721
722 fn create_kanidm_with_storage(storage: Option<KanidmStorage>) -> Kanidm {
723 Kanidm {
724 spec: KanidmSpec {
725 storage,
726 ..Default::default()
727 },
728 ..Default::default()
729 }
730 }
731
732 fn create_kanidm_with_replica_group() -> (Kanidm, ReplicaGroup) {
733 let replica_group = ReplicaGroup {
734 name: "default".to_string(),
735 replicas: 1,
736 ..Default::default()
737 };
738 let kanidm = Kanidm {
739 metadata: ObjectMeta {
740 name: Some("test".to_string()),
741 namespace: Some("default".to_string()),
742 ..Default::default()
743 },
744 spec: KanidmSpec {
745 domain: "idm.example.com".to_string(),
746 replica_groups: vec![replica_group.clone()],
747 ..Default::default()
748 },
749 ..Default::default()
750 };
751 (kanidm, replica_group)
752 }
753
754 #[test]
755 fn test_create_statefulset_with_tls_secret_hash_annotation() {
756 let (kanidm, replica_group) = create_kanidm_with_replica_group();
757 let sts = kanidm
758 .create_statefulset(&replica_group, Some("abc123"))
759 .unwrap();
760
761 let annotations = sts
762 .spec
763 .unwrap()
764 .template
765 .metadata
766 .unwrap()
767 .annotations
768 .unwrap();
769 assert_eq!(
770 annotations.get(TLS_SECRET_HASH_ANNOTATION),
771 Some(&"abc123".to_string())
772 );
773 }
774
775 #[test]
776 fn test_create_statefulset_without_tls_secret_hash_annotation() {
777 let (kanidm, replica_group) = create_kanidm_with_replica_group();
778 let sts = kanidm.create_statefulset(&replica_group, None).unwrap();
779
780 let annotations = sts.spec.unwrap().template.metadata.unwrap().annotations;
781 assert!(annotations.is_none());
782 }
783
784 #[test]
785 fn test_generate_volumes_without_storage() {
786 let kanidm = create_kanidm_with_storage(None);
787 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
788
789 assert_eq!(volumes.clone().len(), 1);
790 assert_eq!(volumes.clone().first().unwrap().name, "kanidm-data");
791 assert!(volumes.first().unwrap().empty_dir.is_some());
792 assert!(volume_claim_template.is_none());
793 }
794
795 #[test]
796 fn test_generate_volumes_with_emptydir() {
797 let storage = Some(KanidmStorage {
798 empty_dir: Some(EmptyDirVolumeSource::default()),
799 ..Default::default()
800 });
801 let kanidm = create_kanidm_with_storage(storage);
802 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
803
804 assert_eq!(volumes.clone().len(), 1);
805 assert!(
806 volumes
807 .iter()
808 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
809 );
810 assert!(volume_claim_template.is_none());
811 }
812
813 #[test]
814 fn test_generate_volumes_with_emptydir_and_ephemeral() {
815 let storage = Some(KanidmStorage {
816 empty_dir: Some(EmptyDirVolumeSource::default()),
817 ephemeral: Some(EphemeralVolumeSource::default()),
818 ..Default::default()
819 });
820 let kanidm = create_kanidm_with_storage(storage);
821 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
822
823 assert_eq!(volumes.clone().len(), 1);
824 assert!(
825 volumes
826 .iter()
827 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
828 );
829 assert!(volume_claim_template.is_none());
830 }
831
832 #[test]
833 fn test_generate_volumes_with_emptydir_ephemeral_and_volumeclaimtemplate() {
834 let storage = Some(KanidmStorage {
835 empty_dir: Some(EmptyDirVolumeSource::default()),
836 ephemeral: Some(EphemeralVolumeSource::default()),
837 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
838 });
839 let kanidm = create_kanidm_with_storage(storage);
840 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
841
842 assert_eq!(volumes.len(), 1);
843 assert!(
844 volumes
845 .iter()
846 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
847 );
848 assert!(volume_claim_template.is_none());
849 }
850
851 #[test]
852 fn test_generate_volumes_with_ephemeral() {
853 let storage = Some(KanidmStorage {
854 ephemeral: Some(EphemeralVolumeSource::default()),
855 ..Default::default()
856 });
857 let kanidm = create_kanidm_with_storage(storage);
858 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
859
860 assert_eq!(volumes.len(), 1);
861 assert!(
862 volumes
863 .iter()
864 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
865 );
866 assert!(volume_claim_template.is_none());
867 }
868
869 #[test]
870 fn test_generate_volumes_with_ephemeral_and_volumeclaimtemplate() {
871 let storage = Some(KanidmStorage {
872 ephemeral: Some(EphemeralVolumeSource::default()),
873 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
874 ..Default::default()
875 });
876 let kanidm = create_kanidm_with_storage(storage);
877 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
878
879 assert_eq!(volumes.len(), 1);
880 assert!(
881 volumes
882 .iter()
883 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
884 );
885 assert!(volume_claim_template.is_none());
886 }
887
888 #[test]
889 fn test_generate_volumes_with_volumeclaimtemplate() {
890 let storage = Some(KanidmStorage {
891 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
892 ..Default::default()
893 });
894 let kanidm = create_kanidm_with_storage(storage);
895 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
896
897 assert!(volumes.is_empty());
898 assert!(volume_claim_template.is_some());
899 }
900
901 #[test]
902 fn test_generate_volumes_with_existing_volumes() {
903 let existing_volume = Volume {
904 name: "existing-volume".to_string(),
905 ..Volume::default()
906 };
907 let kanidm = create_kanidm_with_storage(None);
908 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![existing_volume.clone()]);
909
910 assert_eq!(volumes.len(), 2);
911 assert!(volumes.clone().iter().any(|v| v.name == "existing-volume"));
912 assert!(
913 volumes
914 .iter()
915 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
916 );
917 assert!(volume_claim_template.is_none());
918 }
919
920 #[test]
921 fn test_generate_volumes_with_multiple_existing_volumes() {
922 let existing_volume1 = Volume {
923 name: "existing-volume-1".to_string(),
924 ..Volume::default()
925 };
926 let existing_volume2 = Volume {
927 name: "existing-volume-2".to_string(),
928 ..Volume::default()
929 };
930 let kanidm = create_kanidm_with_storage(None);
931 let (volumes, volume_claim_template) =
932 kanidm.expand_storage(vec![existing_volume1.clone(), existing_volume2.clone()]);
933
934 assert_eq!(volumes.len(), 3);
935 assert!(
936 volumes
937 .clone()
938 .iter()
939 .any(|v| v.name == "existing-volume-1")
940 );
941 assert!(
942 volumes
943 .clone()
944 .iter()
945 .any(|v| v.name == "existing-volume-2")
946 );
947 assert!(
948 volumes
949 .iter()
950 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
951 );
952 assert!(volume_claim_template.is_none());
953 }
954}
955
956#[cfg(all(test, feature = "integration-test"))]
957mod integration_test {
958 use super::{REPLICATION_CONFIG_IMAGE, REPLICATION_CONFIG_SCRIPT};
959
960 use std::fs;
961 use std::path::Path;
962
963 use tempfile::tempdir;
964 use testcontainers::ContainerRequest;
965 use testcontainers::GenericImage;
966 use testcontainers::ImageExt;
967 use testcontainers::core::Mount;
968 use testcontainers::runners::AsyncRunner;
969 use tokio::io::{AsyncBufReadExt, BufReader};
970
971 struct TestCase<'a> {
972 env_vars: Vec<(&'a str, &'a str)>,
973 expected_result: &'a str,
974 }
975
976 async fn run_test_case(
977 image_parts: &[&str],
978 cmd: &[&str],
979 tmp_dir_path: &str,
980 env_vars: &[(&str, &str)],
981 expected_result: &str,
982 ) {
983 let container = GenericImage::new(image_parts[0], image_parts[1]);
984 let mut container_request: ContainerRequest<GenericImage> = container.clone().into();
985
986 for (key, value) in env_vars {
987 container_request =
988 container_request.with_env_var((*key).to_string(), (*value).to_string());
989 }
990
991 let container = container_request
992 .with_cmd(cmd.iter().map(|&s| s.to_string()))
993 .with_mount(Mount::bind_mount(tmp_dir_path.to_string(), "/tmp"))
994 .with_user(nix::unistd::getuid().to_string())
995 .start()
996 .await
997 .unwrap();
998
999 let stdout = container.stdout(true);
1000 let mut stdout_reader = BufReader::new(stdout).lines();
1001 let mut stdout_lines = Vec::new();
1002 while let Some(l) = stdout_reader.next_line().await.unwrap() {
1003 stdout_lines.push(l);
1004 }
1005 dbg!(stdout_lines.join("\n"));
1006
1007 let stderr = container.stderr(true);
1008 let mut stderr_reader = BufReader::new(stderr).lines();
1009 let mut stderr_lines = Vec::new();
1010 while let Some(l) = stderr_reader.next_line().await.unwrap() {
1011 stderr_lines.push(l);
1012 }
1013 dbg!(stderr_lines.join("\n"));
1014
1015 let server_toml_path = Path::new(tmp_dir_path).join("server.toml");
1016 let content = fs::read_to_string(server_toml_path).expect("Unable to read server.toml");
1017 assert_eq!(content, expected_result);
1018 }
1019
1020 #[tokio::test]
1021 async fn test_replication_config_generation() {
1022 let image_parts = REPLICATION_CONFIG_IMAGE.split(':').collect::<Vec<&str>>();
1023 let cmd = ["--script", REPLICATION_CONFIG_SCRIPT];
1024 let tmp_dir = tempdir().unwrap();
1025 let tmp_dir_path = tmp_dir.path().to_str().unwrap().to_string();
1026
1027 let test_cases = vec![
1028 TestCase {
1029 env_vars: vec![
1030 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1031 ("REPLICATION_PORT", "8444"),
1032 ("BIND_ADDRESS", "0.0.0.0"),
1033 ("KANIDM_NAME", "kanidm-test"),
1034 ("POD_NAME", "kanidm-test-default-0"),
1035 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1036 (
1037 "KANIDM_TEST_DEFAULT_0_HOST",
1038 "kanidm-test-default-0.kanidm-test",
1039 ),
1040 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1041 (
1042 "KANIDM_TEST_DEFAULT_1_HOST",
1043 "kanidm-test-default-1.kanidm-test",
1044 ),
1045 ],
1046 expected_result: r#"version = "2"
1047
1048[replication]
1049origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1050bindaddress = "0.0.0.0:8444"
1051
1052"#,
1053 },
1054 TestCase {
1055 env_vars: vec![
1056 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1057 ("REPLICATION_PORT", "8444"),
1058 ("BIND_ADDRESS", "0.0.0.0"),
1059 ("KANIDM_NAME", "kanidm-test"),
1060 ("POD_NAME", "kanidm-test-default-0"),
1061 (
1062 "EXTERNAL_REPLICATION_NODE_HOST_0",
1063 "repl://external-host-0:8444",
1064 ),
1065 (
1066 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1067 "dummy-cert-external-host-0",
1068 ),
1069 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1070 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1071 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1072 (
1073 "KANIDM_TEST_DEFAULT_0_HOST",
1074 "kanidm-test-default-0.kanidm-test",
1075 ),
1076 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1077 (
1078 "KANIDM_TEST_DEFAULT_1_HOST",
1079 "kanidm-test-default-1.kanidm-test",
1080 ),
1081 ],
1082 expected_result: r#"version = "2"
1083
1084[replication]
1085origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1086bindaddress = "0.0.0.0:8444"
1087
1088[replication."repl://external-host-0:8444"]
1089type = "mutual-pull"
1090partner_cert = "dummy-cert-external-host-0"
1091automatic_refresh = true
1092
1093"#,
1094 },
1095 TestCase {
1096 env_vars: vec![
1097 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1098 ("REPLICATION_PORT", "8444"),
1099 ("BIND_ADDRESS", "0.0.0.0"),
1100 ("KANIDM_NAME", "kanidm-test"),
1101 ("POD_NAME", "kanidm-test-default-0"),
1102 (
1103 "EXTERNAL_REPLICATION_NODE_HOST_0",
1104 "repl://external-host-0:8444",
1105 ),
1106 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1107 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1108 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1109 (
1110 "KANIDM_TEST_DEFAULT_0_HOST",
1111 "kanidm-test-default-0.kanidm-test",
1112 ),
1113 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1114 (
1115 "KANIDM_TEST_DEFAULT_1_HOST",
1116 "kanidm-test-default-1.kanidm-test",
1117 ),
1118 ],
1119 expected_result: r#"version = "2"
1120
1121[replication]
1122origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1123bindaddress = "0.0.0.0:8444"
1124
1125"#,
1126 },
1127 TestCase {
1128 env_vars: vec![
1129 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1130 ("REPLICATION_PORT", "8444"),
1131 ("BIND_ADDRESS", "0.0.0.0"),
1132 ("KANIDM_NAME", "kanidm-test"),
1133 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1134 ("POD_NAME", "kanidm-test-default-0"),
1135 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1136 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1137 (
1138 "KANIDM_TEST_DEFAULT_0_HOST",
1139 "kanidm-test-default-0.kanidm-test",
1140 ),
1141 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1142 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1143 (
1144 "KANIDM_TEST_DEFAULT_1_HOST",
1145 "kanidm-test-default-1.kanidm-test",
1146 ),
1147 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1148 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1149 (
1150 "KANIDM_TEST_DEFAULT_3_HOST",
1151 "kanidm-test-default-3.kanidm-test",
1152 ),
1153 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1154 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1155 (
1156 "KANIDM_TEST_READ_REPLICA_0_HOST",
1157 "kanidm-test-read-replica-0.kanidm-test",
1158 ),
1159 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1160 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1161 (
1162 "KANIDM_TEST_READ_REPLICA_1_HOST",
1163 "kanidm-test-read-replica-1.kanidm-test",
1164 ),
1165 ],
1166 expected_result: r#"version = "2"
1167
1168[replication]
1169origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1170bindaddress = "0.0.0.0:8444"
1171
1172[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1173type = "mutual-pull"
1174partner_cert = "dummy-cert-default-1"
1175automatic_refresh = false
1176
1177[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1178type = "mutual-pull"
1179partner_cert = "dummy-cert-default-3"
1180automatic_refresh = false
1181
1182[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1183type = "allow-pull"
1184consumer_cert = "dummy-cert-read-replica-0"
1185
1186[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1187type = "allow-pull"
1188consumer_cert = "dummy-cert-read-replica-1"
1189
1190"#,
1191 },
1192 TestCase {
1193 env_vars: vec![
1194 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1195 ("REPLICATION_PORT", "8444"),
1196 ("BIND_ADDRESS", "0.0.0.0"),
1197 ("KANIDM_NAME", "kanidm-test"),
1198 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1199 ("POD_NAME", "kanidm-test-default-1"),
1200 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1201 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1202 (
1203 "KANIDM_TEST_DEFAULT_0_HOST",
1204 "kanidm-test-default-0.kanidm-test",
1205 ),
1206 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1207 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1208 (
1209 "KANIDM_TEST_DEFAULT_1_HOST",
1210 "kanidm-test-default-1.kanidm-test",
1211 ),
1212 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1213 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1214 (
1215 "KANIDM_TEST_DEFAULT_3_HOST",
1216 "kanidm-test-default-3.kanidm-test",
1217 ),
1218 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1219 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1220 (
1221 "KANIDM_TEST_READ_REPLICA_0_HOST",
1222 "kanidm-test-read-replica-0.kanidm-test",
1223 ),
1224 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1225 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1226 (
1227 "KANIDM_TEST_READ_REPLICA_1_HOST",
1228 "kanidm-test-read-replica-1.kanidm-test",
1229 ),
1230 ],
1231 expected_result: r#"version = "2"
1232
1233[replication]
1234origin = "repl://kanidm-test-default-1.kanidm-test:8444"
1235bindaddress = "0.0.0.0:8444"
1236
1237[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1238type = "mutual-pull"
1239partner_cert = "dummy-cert-default-0"
1240automatic_refresh = true
1241
1242[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1243type = "mutual-pull"
1244partner_cert = "dummy-cert-default-3"
1245automatic_refresh = false
1246
1247[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1248type = "allow-pull"
1249consumer_cert = "dummy-cert-read-replica-0"
1250
1251[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1252type = "allow-pull"
1253consumer_cert = "dummy-cert-read-replica-1"
1254
1255"#,
1256 },
1257 TestCase {
1258 env_vars: vec![
1259 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1260 ("REPLICATION_PORT", "8444"),
1261 ("BIND_ADDRESS", "0.0.0.0"),
1262 ("KANIDM_NAME", "kanidm-test"),
1263 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1264 ("POD_NAME", "kanidm-test-default-3"),
1265 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1266 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1267 (
1268 "KANIDM_TEST_DEFAULT_0_HOST",
1269 "kanidm-test-default-0.kanidm-test",
1270 ),
1271 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1272 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1273 (
1274 "KANIDM_TEST_DEFAULT_1_HOST",
1275 "kanidm-test-default-1.kanidm-test",
1276 ),
1277 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1278 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1279 (
1280 "KANIDM_TEST_DEFAULT_3_HOST",
1281 "kanidm-test-default-3.kanidm-test",
1282 ),
1283 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1284 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1285 (
1286 "KANIDM_TEST_READ_REPLICA_0_HOST",
1287 "kanidm-test-read-replica-0.kanidm-test",
1288 ),
1289 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1290 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1291 (
1292 "KANIDM_TEST_READ_REPLICA_1_HOST",
1293 "kanidm-test-read-replica-1.kanidm-test",
1294 ),
1295 ],
1296 expected_result: r#"version = "2"
1297
1298[replication]
1299origin = "repl://kanidm-test-default-3.kanidm-test:8444"
1300bindaddress = "0.0.0.0:8444"
1301
1302[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1303type = "mutual-pull"
1304partner_cert = "dummy-cert-default-0"
1305automatic_refresh = true
1306
1307[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1308type = "mutual-pull"
1309partner_cert = "dummy-cert-default-1"
1310automatic_refresh = false
1311
1312[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1313type = "allow-pull"
1314consumer_cert = "dummy-cert-read-replica-0"
1315
1316[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1317type = "allow-pull"
1318consumer_cert = "dummy-cert-read-replica-1"
1319
1320"#,
1321 },
1322 TestCase {
1323 env_vars: vec![
1324 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1325 ("REPLICATION_PORT", "8444"),
1326 ("BIND_ADDRESS", "0.0.0.0"),
1327 ("KANIDM_NAME", "kanidm-test"),
1328 ("REPLICA_GROUP", "read-replica"),
1329 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1330 ("POD_NAME", "kanidm-test-read-replica-0"),
1331 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1332 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1333 (
1334 "KANIDM_TEST_DEFAULT_0_HOST",
1335 "kanidm-test-default-0.kanidm-test",
1336 ),
1337 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1338 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1339 (
1340 "KANIDM_TEST_DEFAULT_1_HOST",
1341 "kanidm-test-default-1.kanidm-test",
1342 ),
1343 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1344 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1345 (
1346 "KANIDM_TEST_DEFAULT_3_HOST",
1347 "kanidm-test-default-3.kanidm-test",
1348 ),
1349 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1350 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1351 (
1352 "KANIDM_TEST_READ_REPLICA_0_HOST",
1353 "kanidm-test-read-replica-0.kanidm-test",
1354 ),
1355 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1356 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1357 (
1358 "KANIDM_TEST_READ_REPLICA_1_HOST",
1359 "kanidm-test-read-replica-1.kanidm-test",
1360 ),
1361 ],
1362 expected_result: r#"version = "2"
1363
1364[replication]
1365origin = "repl://kanidm-test-read-replica-0.kanidm-test:8444"
1366bindaddress = "0.0.0.0:8444"
1367
1368[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1369type = "pull"
1370supplier_cert = "dummy-cert-default-0"
1371automatic_refresh = true
1372
1373[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1374type = "pull"
1375supplier_cert = "dummy-cert-default-1"
1376automatic_refresh = false
1377
1378[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1379type = "pull"
1380supplier_cert = "dummy-cert-default-3"
1381automatic_refresh = false
1382
1383"#,
1384 },
1385 TestCase {
1386 env_vars: vec![
1387 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1388 ("REPLICATION_PORT", "8444"),
1389 ("BIND_ADDRESS", "0.0.0.0"),
1390 ("KANIDM_NAME", "kanidm-test"),
1391 ("REPLICA_GROUP", "read-replica"),
1392 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1393 ("POD_NAME", "kanidm-test-read-replica-1"),
1394 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1395 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1396 (
1397 "KANIDM_TEST_DEFAULT_0_HOST",
1398 "kanidm-test-default-0.kanidm-test",
1399 ),
1400 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1401 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1402 (
1403 "KANIDM_TEST_DEFAULT_1_HOST",
1404 "kanidm-test-default-1.kanidm-test",
1405 ),
1406 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1407 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1408 (
1409 "KANIDM_TEST_DEFAULT_3_HOST",
1410 "kanidm-test-default-3.kanidm-test",
1411 ),
1412 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1413 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1414 (
1415 "KANIDM_TEST_READ_REPLICA_0_HOST",
1416 "kanidm-test-read-replica-0.kanidm-test",
1417 ),
1418 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1419 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1420 (
1421 "KANIDM_TEST_READ_REPLICA_1_HOST",
1422 "kanidm-test-read-replica-1.kanidm-test",
1423 ),
1424 ],
1425 expected_result: r#"version = "2"
1426
1427[replication]
1428origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1429bindaddress = "0.0.0.0:8444"
1430
1431[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1432type = "pull"
1433supplier_cert = "dummy-cert-default-0"
1434automatic_refresh = true
1435
1436[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1437type = "pull"
1438supplier_cert = "dummy-cert-default-1"
1439automatic_refresh = false
1440
1441[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1442type = "pull"
1443supplier_cert = "dummy-cert-default-3"
1444automatic_refresh = false
1445
1446"#,
1447 },
1448 TestCase {
1449 env_vars: vec![
1450 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1451 ("REPLICATION_PORT", "8444"),
1452 ("BIND_ADDRESS", "0.0.0.0"),
1453 ("KANIDM_NAME", "kanidm-test"),
1454 ("REPLICA_GROUP", "read-replica"),
1455 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1456 ("POD_NAME", "kanidm-test-read-replica-1"),
1457 (
1458 "EXTERNAL_REPLICATION_NODE_HOST_0",
1459 "repl://external-host-0:8444",
1460 ),
1461 (
1462 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1463 "dummy-cert-external-host-0",
1464 ),
1465 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1466 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1467 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1468 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1469 (
1470 "KANIDM_TEST_DEFAULT_0_HOST",
1471 "kanidm-test-default-0.kanidm-test",
1472 ),
1473 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1474 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1475 (
1476 "KANIDM_TEST_DEFAULT_1_HOST",
1477 "kanidm-test-default-1.kanidm-test",
1478 ),
1479 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1480 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1481 (
1482 "KANIDM_TEST_DEFAULT_3_HOST",
1483 "kanidm-test-default-3.kanidm-test",
1484 ),
1485 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1486 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1487 (
1488 "KANIDM_TEST_READ_REPLICA_0_HOST",
1489 "kanidm-test-read-replica-0.kanidm-test",
1490 ),
1491 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1492 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1493 (
1494 "KANIDM_TEST_READ_REPLICA_1_HOST",
1495 "kanidm-test-read-replica-1.kanidm-test",
1496 ),
1497 ],
1498 expected_result: r#"version = "2"
1499
1500[replication]
1501origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1502bindaddress = "0.0.0.0:8444"
1503
1504[replication."repl://external-host-0:8444"]
1505type = "mutual-pull"
1506partner_cert = "dummy-cert-external-host-0"
1507automatic_refresh = true
1508
1509[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1510type = "pull"
1511supplier_cert = "dummy-cert-default-0"
1512automatic_refresh = true
1513
1514[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1515type = "pull"
1516supplier_cert = "dummy-cert-default-1"
1517automatic_refresh = false
1518
1519[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1520type = "pull"
1521supplier_cert = "dummy-cert-default-3"
1522automatic_refresh = false
1523
1524"#,
1525 },
1526 TestCase {
1527 env_vars: vec![
1528 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1529 ("REPLICATION_PORT", "8444"),
1530 ("BIND_ADDRESS", "0.0.0.0"),
1531 ("KANIDM_NAME", "kanidm-test"),
1532 ("POD_NAME", "kanidm-test-default-0"),
1533 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1534 ("KANIDM_TEST_DEFAULT_0_HOST", "10.200.20.1"),
1535 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1536 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1537 ("KANIDM_TEST_DEFAULT_1_HOST", "10.200.20.2"),
1538 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1539 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1540 ("KANIDM_TEST_DEFAULT_3_HOST", "10.200.20.4"),
1541 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1542 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1543 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1544 (
1545 "KANIDM_TEST_READ_REPLICA_0_HOST",
1546 "kanidm-test-read-replica-0.kanidm-test",
1547 ),
1548 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1549 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1550 (
1551 "KANIDM_TEST_READ_REPLICA_1_HOST",
1552 "kanidm-test-read-replica-1.kanidm-test",
1553 ),
1554 ],
1555 expected_result: r#"version = "2"
1556
1557[replication]
1558origin = "repl://10.200.20.1:8444"
1559bindaddress = "0.0.0.0:8444"
1560
1561[replication."repl://10.200.20.2:8444"]
1562type = "mutual-pull"
1563partner_cert = "dummy-cert-default-1"
1564automatic_refresh = false
1565
1566[replication."repl://10.200.20.4:8444"]
1567type = "mutual-pull"
1568partner_cert = "dummy-cert-default-3"
1569automatic_refresh = false
1570
1571[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1572type = "allow-pull"
1573consumer_cert = "dummy-cert-read-replica-0"
1574
1575[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1576type = "allow-pull"
1577consumer_cert = "dummy-cert-read-replica-1"
1578
1579"#,
1580 },
1581 ];
1582
1583 for test_case in test_cases {
1584 run_test_case(
1585 &image_parts,
1586 &cmd,
1587 &tmp_dir_path,
1588 &test_case.env_vars,
1589 test_case.expected_result,
1590 )
1591 .await;
1592 }
1593 }
1594}