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
100#[derive(Debug, Clone, PartialEq, Eq)]
101pub(super) enum StatefulSetApplyStrategy {
102 Apply,
103 Recreate { immutable_fields: Vec<&'static str> },
104}
105
106pub(super) fn preserve_defaulted_statefulset_fields(
117 desired: &mut StatefulSet,
118 current: &StatefulSet,
119) {
120 let Some(desired_spec) = desired.spec.as_mut() else {
121 return;
122 };
123
124 if desired_spec.pod_management_policy.is_none() {
125 desired_spec.pod_management_policy = Some("OrderedReady".to_string());
126 }
127
128 if let Some(templates) = desired_spec.volume_claim_templates.as_mut() {
129 if let Some(current_templates) = current
130 .spec
131 .as_ref()
132 .and_then(|s| s.volume_claim_templates.as_ref())
133 {
134 for template in templates.iter_mut() {
135 if let Some(spec) = template.spec.as_mut() {
136 if spec.storage_class_name.is_none()
140 && let Some(template_name) = template.metadata.name.as_deref()
141 && let Some(current_spec) = current_templates
142 .iter()
143 .find(|current| current.metadata.name.as_deref() == Some(template_name))
144 .and_then(|current| current.spec.as_ref())
145 {
146 spec.storage_class_name
147 .clone_from(¤t_spec.storage_class_name);
148 }
149 if spec.volume_mode.is_none() {
150 spec.volume_mode = Some("Filesystem".to_string());
151 }
152 }
153 }
154 } else {
155 for template in templates {
156 if let Some(spec) = template.spec.as_mut() {
157 if spec.volume_mode.is_none() {
158 spec.volume_mode = Some("Filesystem".to_string());
159 }
160 }
161 }
162 }
163 }
164}
165
166fn pod_management_policy(spec: &StatefulSetSpec) -> &str {
167 spec.pod_management_policy
168 .as_deref()
169 .unwrap_or("OrderedReady")
170}
171
172fn normalized_volume_claim_templates(spec: &StatefulSetSpec) -> Option<Vec<PersistentVolumeClaim>> {
173 let mut templates = spec.volume_claim_templates.clone();
174 if let Some(templates) = templates.as_mut() {
175 for template in templates {
176 if let Some(pvc_spec) = template.spec.as_mut()
177 && pvc_spec.volume_mode.is_none()
178 {
179 pvc_spec.volume_mode = Some("Filesystem".to_string());
180 }
181 }
182 }
183 templates
184}
185
186fn deletes_pvcs_when_deleted(spec: &StatefulSetSpec) -> bool {
187 spec.persistent_volume_claim_retention_policy
188 .as_ref()
189 .and_then(|policy| policy.when_deleted.as_deref())
190 == Some("Delete")
191}
192
193pub(super) fn classify_statefulset_change(
200 current: &StatefulSet,
201 desired: &StatefulSet,
202) -> StatefulSetApplyStrategy {
203 let (Some(current_spec), Some(desired_spec)) = (current.spec.as_ref(), desired.spec.as_ref())
204 else {
205 return StatefulSetApplyStrategy::Apply;
207 };
208
209 if normalized_volume_claim_templates(current_spec)
210 != normalized_volume_claim_templates(desired_spec)
211 {
212 return StatefulSetApplyStrategy::Apply;
213 }
214
215 let mut immutable_fields = Vec::new();
216 if current_spec.selector != desired_spec.selector {
217 immutable_fields.push("spec.selector");
218 }
219 if current_spec.service_name != desired_spec.service_name {
220 immutable_fields.push("spec.serviceName");
221 }
222 if pod_management_policy(current_spec) != pod_management_policy(desired_spec) {
223 immutable_fields.push("spec.podManagementPolicy");
224 }
225
226 if immutable_fields.is_empty() || deletes_pvcs_when_deleted(current_spec) {
227 StatefulSetApplyStrategy::Apply
228 } else {
229 StatefulSetApplyStrategy::Recreate { immutable_fields }
230 }
231}
232
233pub trait StatefulSetExt {
234 fn statefulset_name(&self, rg_name: &str) -> String;
235 fn pod_name(&self, rg_name: &str, i: i32) -> String;
236 fn pod_env_prefix(&self, pod_name: &str) -> String;
237
238 fn create_statefulset(
239 &self,
240 replica_group: &ReplicaGroup,
241 tls_secret_hash: Option<&str>,
242 ) -> Result<StatefulSet>;
243}
244
245impl StatefulSetExt for Kanidm {
246 #[inline]
247 fn statefulset_name(&self, rg_name: &str) -> String {
248 format!("{kanidm_name}-{rg_name}", kanidm_name = self.name_any())
249 }
250
251 #[inline]
252 fn pod_name(&self, rg_name: &str, i: i32) -> String {
253 format!("{}-{}", self.statefulset_name(rg_name), i)
254 }
255
256 #[inline]
257 fn pod_env_prefix(&self, pod_name: &str) -> String {
258 pod_name.to_uppercase().replace("-", "_")
259 }
260
261 fn create_statefulset(
262 &self,
263 replica_group: &ReplicaGroup,
264 tls_secret_hash: Option<&str>,
265 ) -> Result<StatefulSet> {
266 let pod_labels = self.generate_pod_labels(replica_group);
267 let labels = self.generate_sts_labels(&pod_labels);
268 let env = self.generate_env_vars(replica_group);
269 let init_containers = self.generate_init_containers(replica_group)?;
270 let ports = self.generate_container_ports();
271 let probe = self.generate_probe();
272 let volume_mounts = self.generate_volume_mounts();
273 let containers =
274 self.generate_containers(&env, &volume_mounts, &ports, &probe, replica_group)?;
275 let dns_policy = self.generate_dns_policy();
276 let (volumes, volume_claim_templates) = self.generate_volumes();
277
278 Ok(StatefulSet {
279 metadata: self.generate_metadata(
280 &replica_group.name,
281 &replica_group.stateful_set_annotations,
282 &labels,
283 ),
284 spec: Some(StatefulSetSpec {
285 replicas: Some(replica_group.replicas),
286 selector: LabelSelector {
287 match_expressions: None,
288 match_labels: Some(pod_labels.clone()),
289 },
290 template: PodTemplateSpec {
291 metadata: Some(ObjectMeta {
292 labels: Some(pod_labels),
293 annotations: tls_secret_hash.map(|hash| {
297 BTreeMap::from([(
298 TLS_SECRET_HASH_ANNOTATION.to_string(),
299 hash.to_string(),
300 )])
301 }),
302 ..ObjectMeta::default()
303 }),
304 spec: Some(PodSpec {
305 containers,
306 volumes: Some(volumes),
307 node_selector: replica_group.node_selector.clone(),
308 affinity: replica_group.affinity.clone(),
309 tolerations: replica_group.tolerations.clone(),
310 topology_spread_constraints: replica_group
311 .topology_spread_constraints
312 .clone(),
313 security_context: self.spec.security_context.clone(),
314 dns_policy,
315 dns_config: self.spec.dns_config.clone(),
316 init_containers: Some(init_containers),
317 host_aliases: self.spec.host_aliases.clone(),
318 enable_service_links: Some(self.spec.enable_service_links),
319 automount_service_account_token: self.spec.automount_service_account_token,
320 host_users: self.spec.host_users,
321 runtime_class_name: self.spec.runtime_class_name.clone(),
322 ..PodSpec::default()
323 }),
324 },
325 service_name: Some(self.service_name()),
326 persistent_volume_claim_retention_policy: self
327 .spec
328 .persistent_volume_claim_retention_policy
329 .clone(),
330 min_ready_seconds: self.spec.min_ready_seconds,
331 volume_claim_templates,
332 ..StatefulSetSpec::default()
333 }),
334 ..StatefulSet::default()
335 })
336 }
337}
338
339impl Kanidm {
340 fn generate_pod_labels(&self, replica_group: &ReplicaGroup) -> BTreeMap<String, String> {
341 self.generate_resource_labels()
342 .into_iter()
343 .chain(std::iter::once((
344 REPLICA_GROUP_LABEL.to_string(),
345 replica_group.name.clone(),
346 )))
347 .collect()
348 }
349
350 fn generate_sts_labels(
351 &self,
352 pod_labels: &BTreeMap<String, String>,
353 ) -> BTreeMap<String, String> {
354 pod_labels.clone()
355 }
356
357 fn generate_env_vars(&self, replica_group: &ReplicaGroup) -> Vec<EnvVar> {
358 let origin = match self.spec.origin.clone() {
359 Some(o) => o,
360 None => format!("https://{}", self.spec.domain.clone()),
361 };
362 let bind_address = match self.spec.ip_family {
363 IpFamily::Ipv4 => IPV4_BIND_ADDRESS,
364 IpFamily::Ipv6 => IPV6_BIND_ADDRESS,
365 };
366
367 self.spec
368 .env
369 .clone()
370 .unwrap_or_default()
371 .into_iter()
372 .chain(vec![
373 EnvVar {
374 name: "KANIDM_DOMAIN".to_string(),
375 value: Some(self.spec.domain.clone()),
376 ..EnvVar::default()
377 },
378 EnvVar {
379 name: "KANIDM_ORIGIN".to_string(),
380 value: Some(origin),
381 ..EnvVar::default()
382 },
383 EnvVar {
384 name: "KANIDM_DB_PATH".to_string(),
385 value: Some(format!("{VOLUME_DATA_PATH}/kanidm.db")),
386 ..EnvVar::default()
387 },
388 EnvVar {
389 name: "KANIDM_TLS_CHAIN".to_string(),
390 value: Some(format!("{VOLUME_TLS_PATH}/tls.crt")),
391 ..EnvVar::default()
392 },
393 EnvVar {
394 name: "KANIDM_TLS_KEY".to_string(),
395 value: Some(format!("{VOLUME_TLS_PATH}/tls.key")),
396 ..EnvVar::default()
397 },
398 EnvVar {
399 name: "KANIDM_BINDADDRESS".to_string(),
400 value: Some(format!("{bind_address}:{CONTAINER_HTTPS_PORT}")),
401 ..EnvVar::default()
402 },
403 EnvVar {
404 name: "KANIDM_ROLE".to_string(),
405 value: Some(serde_plain::to_string(&replica_group.role.clone()).unwrap()),
406 ..EnvVar::default()
407 },
408 EnvVar {
409 name: "KANIDM_LOG_LEVEL".to_string(),
410 value: Some(serde_plain::to_string(&self.spec.log_level.clone()).unwrap()),
411 ..EnvVar::default()
412 },
413 ])
414 .chain(
415 self.spec
416 .ldap_port_name
417 .clone()
418 .into_iter()
419 .map(|_| EnvVar {
420 name: "KANIDM_LDAPBINDADDRESS".to_string(),
421 value: Some(format!("{bind_address}:{CONTAINER_LDAP_PORT}")),
422 ..EnvVar::default()
423 }),
424 )
425 .collect()
426 }
427
428 fn generate_config_volume_mount(&self) -> VolumeMount {
429 VolumeMount {
430 name: VOLUME_CONFIG_NAME.to_string(),
431 mount_path: VOLUME_CONFIG_PATH.to_string(),
432 read_only: Some(false),
433 ..VolumeMount::default()
434 }
435 }
436
437 fn generate_volume_mounts(&self) -> Vec<VolumeMount> {
438 self.spec
439 .volume_mounts
440 .clone()
441 .unwrap_or_default()
442 .into_iter()
443 .chain([
444 VolumeMount {
445 name: VOLUME_DATA_NAME.to_string(),
446 mount_path: VOLUME_DATA_PATH.to_string(),
447 ..VolumeMount::default()
448 },
449 VolumeMount {
450 name: VOLUME_TLS_NAME.to_string(),
451 mount_path: VOLUME_TLS_PATH.to_string(),
452 read_only: Some(true),
453 ..VolumeMount::default()
454 },
455 ])
456 .chain(
457 self.is_replication_enabled()
458 .then(|| self.generate_config_volume_mount()),
459 )
460 .collect()
461 }
462
463 fn generate_init_containers(&self, replica_group: &ReplicaGroup) -> Result<Vec<Container>> {
464 if self.is_replication_enabled() {
465 let external_replica_nodes_envs = self
466 .spec
467 .external_replication_nodes
468 .iter()
469 .flat_map(|ern| {
470 [
471 EnvVar {
472 name: format!("EXTERNAL_REPLICATION_NODE_{}", ern.name),
473 value: Some(format!(
474 "repl://{host}:{port}",
475 host = ern.hostname.clone(),
476 port = ern.port
477 )),
478 ..EnvVar::default()
479 },
480 EnvVar {
481 name: format!("EXTERNAL_REPLICATION_NODE_{}_CERT", ern.name),
482 value_from: Some(EnvVarSource {
483 secret_key_ref: Some(ern.certificate.clone()),
484 ..EnvVarSource::default()
485 }),
486 ..EnvVar::default()
487 },
488 EnvVar {
489 name: format!("EXTERNAL_REPLICATION_NODE_{}_TYPE", ern.name),
490 value: serde_plain::to_string(&ern._type).ok(),
491 ..EnvVar::default()
492 },
493 EnvVar {
494 name: format!(
495 "EXTERNAL_REPLICATION_NODE_{}_AUTOMATIC_REFRESH",
496 ern.name
497 ),
498 value: Some(ern.automatic_refresh.to_string()),
499 ..EnvVar::default()
500 },
501 ]
502 })
503 .collect::<Vec<EnvVar>>();
504 let replica_secrets_envs = self
505 .spec
506 .replica_groups
507 .iter()
508 .flat_map(|rg| {
509 (0..rg.replicas).flat_map(move |i| {
510 let pod_name = self.pod_name(&rg.name, i);
511 let pod_env_prefix = self.pod_env_prefix(&pod_name);
512 let pod_host = match rg
513 .services
514 .as_ref()
515 .and_then(|s| s.replication_hostname_template.as_ref())
516 {
517 Some(template) => template
518 .replace("{pod_name}", &pod_name)
519 .replace("{replica_index}", &i.to_string())
520 .replace("{domain}", &self.spec.domain),
521 None => format!(
522 "{pod_name}.{}.{}.svc.{}",
523 self.service_name(),
524 self.get_namespace(),
525 cluster_domain()
526 ),
527 };
528 [
529 EnvVar {
530 name: pod_env_prefix.clone(),
531 value_from: Some(EnvVarSource {
532 secret_key_ref: Some(SecretKeySelector {
533 name: self.replica_secret_name(&pod_name),
534 key: REPLICA_SECRET_KEY.to_string(),
535 optional: Some(true),
536 }),
537 ..EnvVarSource::default()
538 }),
539 ..EnvVar::default()
540 },
541 EnvVar {
542 name: format!("{pod_env_prefix}_TYPE"),
543 value: replication_type(
544 replica_group.role.clone(),
545 rg.role.clone(),
546 )
547 .and_then(|t| serde_plain::to_string(&t).ok()),
548 ..EnvVar::default()
549 },
550 EnvVar {
551 name: format!("{pod_env_prefix}_HOST"),
552 value: Some(pod_host),
553 ..EnvVar::default()
554 },
555 ]
556 })
557 })
558 .collect::<Vec<EnvVar>>();
559
560 let primary_node = self
561 .spec
562 .replica_groups
563 .iter()
564 .find(|rg| rg.primary_node)
565 .map(|rg| format!("{}-0", self.statefulset_name(&rg.name)));
566
567 let bind_address = match self.spec.ip_family {
568 IpFamily::Ipv4 => IPV4_BIND_ADDRESS,
569 IpFamily::Ipv6 => IPV6_BIND_ADDRESS,
570 };
571
572 let env = external_replica_nodes_envs
573 .into_iter()
574 .chain(replica_secrets_envs)
575 .chain([
576 EnvVar {
577 name: "POD_NAME".to_string(),
578 value_from: Some(EnvVarSource {
579 field_ref: Some(ObjectFieldSelector {
580 api_version: Some("v1".to_string()),
581 field_path: "metadata.name".to_string(),
582 }),
583 ..EnvVarSource::default()
584 }),
585 ..EnvVar::default()
586 },
587 EnvVar {
588 name: "REPLICATION_PORT".to_string(),
589 value: Some(CONTAINER_REPLICATION_PORT.to_string()),
590 ..EnvVar::default()
591 },
592 EnvVar {
593 name: "BIND_ADDRESS".to_string(),
594 value: Some(bind_address.to_string()),
595 ..EnvVar::default()
596 },
597 EnvVar {
598 name: "KANIDM_CONFIG_PATH".to_string(),
599 value: Some(KANIDM_CONFIG_PATH.to_string()),
600 ..EnvVar::default()
601 },
602 EnvVar {
603 name: "KANIDM_NAME".to_string(),
604 value: Some(self.name_any()),
605 ..EnvVar::default()
606 },
607 ])
608 .chain(primary_node.map(|pn| EnvVar {
609 name: "KANIDM_PRIMARY_NODE".to_string(),
610 value: Some(pn),
611 ..EnvVar::default()
612 }))
613 .collect::<Vec<EnvVar>>();
614
615 let init_container = Container {
616 name: "kanidm-generate-replication-config".to_string(),
617 image: Some(REPLICATION_CONFIG_IMAGE.to_string()),
618 env: Some(env),
619 args: Some(vec![
620 "--script".to_string(),
621 REPLICATION_CONFIG_SCRIPT.to_string(),
622 ]),
623 volume_mounts: Some(vec![self.generate_config_volume_mount()]),
624 ..Container::default()
625 };
626
627 merge_containers(self.spec.init_containers.clone(), &init_container)
628 } else {
629 let filtered_init_containers = self
633 .spec
634 .init_containers
635 .clone()
636 .unwrap_or_default()
637 .into_iter()
638 .filter(|container| container.name != "kanidm-generate-replication-config")
639 .collect();
640 Ok(filtered_init_containers)
641 }
642 }
643
644 fn generate_container_ports(&self) -> Vec<ContainerPort> {
645 std::iter::once(ContainerPort {
646 name: Some(self.spec.port_name.clone()),
647 container_port: CONTAINER_HTTPS_PORT,
648 ..ContainerPort::default()
649 })
650 .chain(
651 self.spec
652 .ldap_port_name
653 .clone()
654 .into_iter()
655 .map(|port_name| ContainerPort {
656 name: Some(port_name.clone()),
657 container_port: CONTAINER_LDAP_PORT,
658 ..ContainerPort::default()
659 }),
660 )
661 .chain(self.is_replication_enabled().then(|| ContainerPort {
662 name: Some(CONTAINER_REPLICATION_PORT_NAME.to_string()),
663 container_port: CONTAINER_REPLICATION_PORT,
664 ..ContainerPort::default()
665 }))
666 .collect()
667 }
668
669 fn generate_probe(&self) -> Probe {
670 Probe {
671 http_get: Some(HTTPGetAction {
672 path: Some("/status".to_string()),
673 port: IntOrString::String(self.spec.port_name.clone()),
674 scheme: Some("HTTPS".to_string()),
675 ..HTTPGetAction::default()
676 }),
677 ..Probe::default()
678 }
679 }
680
681 fn generate_containers(
682 &self,
683 env: &[EnvVar],
684 volume_mounts: &[VolumeMount],
685 ports: &[ContainerPort],
686 probe: &Probe,
687 replica_group: &ReplicaGroup,
688 ) -> Result<Vec<Container>> {
689 let command = vec!["kanidmd".to_string(), "server".to_string()]
690 .into_iter()
691 .chain(
692 self.is_replication_enabled()
693 .then(|| vec!["-c".to_string(), KANIDM_CONFIG_PATH.to_string()])
694 .into_iter()
695 .flatten(),
696 )
697 .collect::<Vec<String>>();
698 let kanidm_container = Container {
699 name: "kanidm".to_string(),
700 image: Some(self.spec.image.clone()),
701 image_pull_policy: self.spec.image_pull_policy.clone(),
702 command: Some(command),
703 env: Some(env.to_owned()),
704 ports: Some(ports.to_owned()),
705 volume_mounts: Some(volume_mounts.to_owned()),
706 resources: replica_group.resources.clone(),
707 readiness_probe: Some(probe.clone()),
708 liveness_probe: Some(probe.clone()),
709 ..Container::default()
710 };
711
712 merge_containers(self.spec.containers.clone(), &kanidm_container)
713 }
714
715 fn generate_dns_policy(&self) -> Option<String> {
716 match self.spec.host_network {
717 Some(true) => Some("ClusterFirstWithHostNet".to_string()),
718 _ => self.spec.dns_policy.clone(),
719 }
720 }
721
722 fn generate_volumes(&self) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
723 let secret_name = self.effective_tls_secret_name();
724
725 self.expand_storage(
726 self.spec
727 .volumes
728 .clone()
729 .unwrap_or_default()
730 .into_iter()
731 .chain(std::iter::once(Volume {
732 name: VOLUME_TLS_NAME.to_string(),
733 secret: Some(SecretVolumeSource {
734 secret_name: Some(secret_name),
735 default_mode: Some(0o400),
736 ..SecretVolumeSource::default()
737 }),
738 ..Volume::default()
739 }))
740 .chain(self.is_replication_enabled().then(|| Volume {
741 name: VOLUME_CONFIG_NAME.to_string(),
742 empty_dir: Some(EmptyDirVolumeSource {
743 medium: None,
744 size_limit: None,
745 }),
746 ..Volume::default()
747 }))
748 .collect(),
749 )
750 }
751
752 fn expand_storage(
753 &self,
754 volumes: Vec<Volume>,
755 ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
756 let default_expand_storage = |volumes: Vec<Volume>| {
757 (
758 volumes
759 .into_iter()
760 .chain(std::iter::once(Volume {
761 name: VOLUME_DATA_NAME.to_string(),
762 empty_dir: Some(EmptyDirVolumeSource {
763 medium: None,
764 size_limit: None,
765 }),
766 ..Volume::default()
767 }))
768 .collect(),
769 None,
770 )
771 };
772
773 match self.spec.storage.clone() {
774 Some(storage) => {
775 if let Some(empty_dir) = storage.empty_dir {
776 (
777 volumes
778 .into_iter()
779 .chain(std::iter::once(Volume {
780 name: VOLUME_DATA_NAME.to_string(),
781 empty_dir: Some(empty_dir),
782 ..Volume::default()
783 }))
784 .collect(),
785 None,
786 )
787 } else if let Some(ephemeral) = storage.ephemeral {
788 (
789 volumes
790 .into_iter()
791 .chain(std::iter::once(Volume {
792 name: VOLUME_DATA_NAME.to_string(),
793 ephemeral: Some(ephemeral),
794 ..Volume::default()
795 }))
796 .collect(),
797 None,
798 )
799 } else if let Some(volume_claim_template) = storage.volume_claim_template {
800 let pvc = volume_claim_template.to_persistent_volume_claim();
801 let named_template = PersistentVolumeClaim {
802 metadata: ObjectMeta {
803 name: Some(VOLUME_DATA_NAME.to_string()),
804 ..pvc.metadata
805 },
806 spec: pvc.spec,
807 ..pvc
808 };
809 (volumes, Some(vec![named_template]))
810 } else {
811 default_expand_storage(volumes)
812 }
813 }
814 None => default_expand_storage(volumes),
815 }
816 }
817
818 fn generate_metadata(
819 &self,
820 replica_group_name: &str,
821 annotations: &Option<BTreeMap<String, String>>,
822 labels: &BTreeMap<String, String>,
823 ) -> ObjectMeta {
824 ObjectMeta {
825 name: Some(self.statefulset_name(replica_group_name)),
826 namespace: self.namespace(),
827 labels: Some(labels.clone()),
828 owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
829 annotations: annotations.clone(),
830 ..ObjectMeta::default()
831 }
832 }
833}
834
835fn replication_type(
836 source_role: KanidmServerRole,
837 target_role: KanidmServerRole,
838) -> Option<ReplicationType> {
839 match (source_role, target_role) {
840 (
841 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
842 KanidmServerRole::WriteReplicaNoUi | KanidmServerRole::WriteReplica,
843 ) => Some(ReplicationType::MutualPull),
844
845 (
846 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
847 KanidmServerRole::ReadOnlyReplica,
848 ) => Some(ReplicationType::AllowPull),
849 (
850 KanidmServerRole::ReadOnlyReplica,
851 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
852 ) => Some(ReplicationType::Pull),
853 (KanidmServerRole::ReadOnlyReplica, KanidmServerRole::ReadOnlyReplica) => None,
854 }
855}
856
857#[cfg(test)]
858mod tests {
859 use super::{
860 StatefulSetApplyStrategy, StatefulSetExt, TLS_SECRET_HASH_ANNOTATION,
861 classify_statefulset_change, preserve_defaulted_statefulset_fields,
862 };
863 use crate::kanidm::crd::{
864 Kanidm, KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
865 };
866 use k8s_openapi::api::apps::v1::{
867 StatefulSet, StatefulSetPersistentVolumeClaimRetentionPolicy,
868 };
869 use k8s_openapi::api::core::v1::{
870 EmptyDirVolumeSource, EphemeralVolumeSource, PersistentVolumeClaim,
871 PersistentVolumeClaimSpec, Volume,
872 };
873 use kube::api::ObjectMeta;
874
875 fn create_kanidm_with_storage(storage: Option<KanidmStorage>) -> Kanidm {
876 Kanidm {
877 spec: KanidmSpec {
878 storage,
879 ..Default::default()
880 },
881 ..Default::default()
882 }
883 }
884
885 fn create_kanidm_with_replica_group() -> (Kanidm, ReplicaGroup) {
886 let replica_group = ReplicaGroup {
887 name: "default".to_string(),
888 replicas: 1,
889 ..Default::default()
890 };
891 let kanidm = Kanidm {
892 metadata: ObjectMeta {
893 name: Some("test".to_string()),
894 namespace: Some("default".to_string()),
895 ..Default::default()
896 },
897 spec: KanidmSpec {
898 domain: "idm.example.com".to_string(),
899 replica_groups: vec![replica_group.clone()],
900 ..Default::default()
901 },
902 ..Default::default()
903 };
904 (kanidm, replica_group)
905 }
906
907 #[test]
908 fn test_create_statefulset_with_tls_secret_hash_annotation() {
909 let (kanidm, replica_group) = create_kanidm_with_replica_group();
910 let sts = kanidm
911 .create_statefulset(&replica_group, Some("abc123"))
912 .unwrap();
913
914 let annotations = sts
915 .spec
916 .unwrap()
917 .template
918 .metadata
919 .unwrap()
920 .annotations
921 .unwrap();
922 assert_eq!(
923 annotations.get(TLS_SECRET_HASH_ANNOTATION),
924 Some(&"abc123".to_string())
925 );
926 }
927
928 #[test]
929 fn test_create_statefulset_without_tls_secret_hash_annotation() {
930 let (kanidm, replica_group) = create_kanidm_with_replica_group();
931 let sts = kanidm.create_statefulset(&replica_group, None).unwrap();
932
933 let annotations = sts.spec.unwrap().template.metadata.unwrap().annotations;
934 assert!(annotations.is_none());
935 }
936
937 #[test]
938 fn test_generate_volumes_without_storage() {
939 let kanidm = create_kanidm_with_storage(None);
940 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
941
942 assert_eq!(volumes.clone().len(), 1);
943 assert_eq!(volumes.clone().first().unwrap().name, "kanidm-data");
944 assert!(volumes.first().unwrap().empty_dir.is_some());
945 assert!(volume_claim_template.is_none());
946 }
947
948 fn generated_statefulset() -> StatefulSet {
949 let (kanidm, replica_group) = create_kanidm_with_replica_group();
950 kanidm.create_statefulset(&replica_group, None).unwrap()
951 }
952
953 #[test]
954 fn statefulset_mutable_change_uses_apply() {
955 let current = generated_statefulset();
956 let mut desired = current.clone();
957 desired.spec.as_mut().unwrap().replicas = Some(2);
958
959 assert_eq!(
960 classify_statefulset_change(¤t, &desired),
961 StatefulSetApplyStrategy::Apply
962 );
963 }
964
965 #[test]
966 fn statefulset_selector_change_requires_recreation() {
967 let current = generated_statefulset();
968 let mut desired = current.clone();
969 desired
970 .spec
971 .as_mut()
972 .unwrap()
973 .selector
974 .match_labels
975 .get_or_insert_default()
976 .insert("immutable".to_string(), "changed".to_string());
977
978 assert_eq!(
979 classify_statefulset_change(¤t, &desired),
980 StatefulSetApplyStrategy::Recreate {
981 immutable_fields: vec!["spec.selector"]
982 }
983 );
984 }
985
986 #[test]
987 fn statefulset_service_name_change_requires_recreation() {
988 let current = generated_statefulset();
989 let mut desired = current.clone();
990 desired.spec.as_mut().unwrap().service_name = Some("different".to_string());
991
992 assert_eq!(
993 classify_statefulset_change(¤t, &desired),
994 StatefulSetApplyStrategy::Recreate {
995 immutable_fields: vec!["spec.serviceName"]
996 }
997 );
998 }
999
1000 #[test]
1001 fn statefulset_pod_management_default_does_not_recreate() {
1002 let mut current = generated_statefulset();
1003 current.spec.as_mut().unwrap().pod_management_policy = Some("OrderedReady".to_string());
1004 let mut desired = generated_statefulset();
1005 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1006
1007 assert_eq!(
1008 classify_statefulset_change(¤t, &desired),
1009 StatefulSetApplyStrategy::Apply
1010 );
1011 }
1012
1013 #[test]
1014 fn statefulset_non_default_pod_management_policy_requires_recreation() {
1015 let mut current = generated_statefulset();
1016 current.spec.as_mut().unwrap().pod_management_policy = Some("Parallel".to_string());
1017 let mut desired = generated_statefulset();
1018 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1019
1020 assert_eq!(
1021 classify_statefulset_change(¤t, &desired),
1022 StatefulSetApplyStrategy::Recreate {
1023 immutable_fields: vec!["spec.podManagementPolicy"]
1024 }
1025 );
1026 }
1027
1028 #[test]
1029 fn statefulset_volume_claim_template_change_is_non_destructive() {
1030 let mut current = generated_statefulset();
1031 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1032 metadata: ObjectMeta {
1033 name: Some("kanidm-data".to_string()),
1034 ..Default::default()
1035 },
1036 spec: Some(PersistentVolumeClaimSpec {
1037 storage_class_name: Some("old".to_string()),
1038 ..Default::default()
1039 }),
1040 ..Default::default()
1041 }]);
1042 let mut desired = current.clone();
1043 desired
1044 .spec
1045 .as_mut()
1046 .unwrap()
1047 .volume_claim_templates
1048 .as_mut()
1049 .unwrap()[0]
1050 .spec
1051 .as_mut()
1052 .unwrap()
1053 .storage_class_name = Some("new".to_string());
1054
1055 assert_eq!(
1056 classify_statefulset_change(¤t, &desired),
1057 StatefulSetApplyStrategy::Apply
1058 );
1059 }
1060
1061 #[test]
1062 fn statefulset_storage_class_defaulting_preserves_live_value() {
1063 let mut current = generated_statefulset();
1064 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1065 metadata: ObjectMeta {
1066 name: Some("kanidm-data".to_string()),
1067 ..Default::default()
1068 },
1069 spec: Some(PersistentVolumeClaimSpec {
1070 storage_class_name: Some("fast".to_string()),
1071 ..Default::default()
1072 }),
1073 ..Default::default()
1074 }]);
1075 let mut desired = current.clone();
1076 desired
1077 .spec
1078 .as_mut()
1079 .unwrap()
1080 .volume_claim_templates
1081 .as_mut()
1082 .unwrap()[0]
1083 .spec
1084 .as_mut()
1085 .unwrap()
1086 .storage_class_name = None;
1087 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1088
1089 assert_eq!(
1092 desired
1093 .spec
1094 .as_ref()
1095 .unwrap()
1096 .volume_claim_templates
1097 .as_ref()
1098 .unwrap()[0]
1099 .spec
1100 .as_ref()
1101 .unwrap()
1102 .storage_class_name,
1103 Some("fast".to_string())
1104 );
1105 assert_eq!(
1106 classify_statefulset_change(¤t, &desired),
1107 StatefulSetApplyStrategy::Apply
1108 );
1109 }
1110
1111 #[test]
1112 fn statefulset_server_defaults_do_not_require_recreation() {
1113 let mut desired = generated_statefulset();
1114 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1115 metadata: ObjectMeta {
1116 name: Some("kanidm-data".to_string()),
1117 ..Default::default()
1118 },
1119 spec: Some(PersistentVolumeClaimSpec::default()),
1120 ..Default::default()
1121 }]);
1122 let mut current = desired.clone();
1123 let current_spec = current.spec.as_mut().unwrap();
1124 current_spec.pod_management_policy = Some("OrderedReady".to_string());
1125 current_spec.volume_claim_templates.as_mut().unwrap()[0]
1126 .spec
1127 .as_mut()
1128 .unwrap()
1129 .volume_mode = Some("Filesystem".to_string());
1130
1131 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1132
1133 assert_eq!(
1134 classify_statefulset_change(¤t, &desired),
1135 StatefulSetApplyStrategy::Apply
1136 );
1137 }
1138
1139 #[test]
1140 fn statefulset_delete_retention_blocks_automatic_recreation() {
1141 let mut current = generated_statefulset();
1142 current
1143 .spec
1144 .as_mut()
1145 .unwrap()
1146 .persistent_volume_claim_retention_policy =
1147 Some(StatefulSetPersistentVolumeClaimRetentionPolicy {
1148 when_deleted: Some("Delete".to_string()),
1149 when_scaled: None,
1150 });
1151 let mut desired = current.clone();
1152 desired
1153 .spec
1154 .as_mut()
1155 .unwrap()
1156 .selector
1157 .match_labels
1158 .get_or_insert_default()
1159 .insert("immutable".to_string(), "changed".to_string());
1160
1161 assert_eq!(
1162 classify_statefulset_change(¤t, &desired),
1163 StatefulSetApplyStrategy::Apply
1164 );
1165 }
1166
1167 #[test]
1168 fn test_generate_volumes_with_emptydir() {
1169 let storage = Some(KanidmStorage {
1170 empty_dir: Some(EmptyDirVolumeSource::default()),
1171 ..Default::default()
1172 });
1173 let kanidm = create_kanidm_with_storage(storage);
1174 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1175
1176 assert_eq!(volumes.clone().len(), 1);
1177 assert!(
1178 volumes
1179 .iter()
1180 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1181 );
1182 assert!(volume_claim_template.is_none());
1183 }
1184
1185 #[test]
1186 fn test_generate_volumes_with_emptydir_and_ephemeral() {
1187 let storage = Some(KanidmStorage {
1188 empty_dir: Some(EmptyDirVolumeSource::default()),
1189 ephemeral: Some(EphemeralVolumeSource::default()),
1190 ..Default::default()
1191 });
1192 let kanidm = create_kanidm_with_storage(storage);
1193 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1194
1195 assert_eq!(volumes.clone().len(), 1);
1196 assert!(
1197 volumes
1198 .iter()
1199 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1200 );
1201 assert!(volume_claim_template.is_none());
1202 }
1203
1204 #[test]
1205 fn test_generate_volumes_with_emptydir_ephemeral_and_volumeclaimtemplate() {
1206 let storage = Some(KanidmStorage {
1207 empty_dir: Some(EmptyDirVolumeSource::default()),
1208 ephemeral: Some(EphemeralVolumeSource::default()),
1209 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1210 });
1211 let kanidm = create_kanidm_with_storage(storage);
1212 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1213
1214 assert_eq!(volumes.len(), 1);
1215 assert!(
1216 volumes
1217 .iter()
1218 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1219 );
1220 assert!(volume_claim_template.is_none());
1221 }
1222
1223 #[test]
1224 fn test_generate_volumes_with_ephemeral() {
1225 let storage = Some(KanidmStorage {
1226 ephemeral: Some(EphemeralVolumeSource::default()),
1227 ..Default::default()
1228 });
1229 let kanidm = create_kanidm_with_storage(storage);
1230 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1231
1232 assert_eq!(volumes.len(), 1);
1233 assert!(
1234 volumes
1235 .iter()
1236 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
1237 );
1238 assert!(volume_claim_template.is_none());
1239 }
1240
1241 #[test]
1242 fn test_generate_volumes_with_ephemeral_and_volumeclaimtemplate() {
1243 let storage = Some(KanidmStorage {
1244 ephemeral: Some(EphemeralVolumeSource::default()),
1245 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1246 ..Default::default()
1247 });
1248 let kanidm = create_kanidm_with_storage(storage);
1249 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1250
1251 assert_eq!(volumes.len(), 1);
1252 assert!(
1253 volumes
1254 .iter()
1255 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
1256 );
1257 assert!(volume_claim_template.is_none());
1258 }
1259
1260 #[test]
1261 fn test_generate_volumes_with_volumeclaimtemplate() {
1262 let storage = Some(KanidmStorage {
1263 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1264 ..Default::default()
1265 });
1266 let kanidm = create_kanidm_with_storage(storage);
1267 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1268
1269 assert!(volumes.is_empty());
1270 assert!(volume_claim_template.is_some());
1271 }
1272
1273 #[test]
1274 fn test_generate_volumes_with_existing_volumes() {
1275 let existing_volume = Volume {
1276 name: "existing-volume".to_string(),
1277 ..Volume::default()
1278 };
1279 let kanidm = create_kanidm_with_storage(None);
1280 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![existing_volume.clone()]);
1281
1282 assert_eq!(volumes.len(), 2);
1283 assert!(volumes.clone().iter().any(|v| v.name == "existing-volume"));
1284 assert!(
1285 volumes
1286 .iter()
1287 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1288 );
1289 assert!(volume_claim_template.is_none());
1290 }
1291
1292 #[test]
1293 fn test_generate_volumes_with_multiple_existing_volumes() {
1294 let existing_volume1 = Volume {
1295 name: "existing-volume-1".to_string(),
1296 ..Volume::default()
1297 };
1298 let existing_volume2 = Volume {
1299 name: "existing-volume-2".to_string(),
1300 ..Volume::default()
1301 };
1302 let kanidm = create_kanidm_with_storage(None);
1303 let (volumes, volume_claim_template) =
1304 kanidm.expand_storage(vec![existing_volume1.clone(), existing_volume2.clone()]);
1305
1306 assert_eq!(volumes.len(), 3);
1307 assert!(
1308 volumes
1309 .clone()
1310 .iter()
1311 .any(|v| v.name == "existing-volume-1")
1312 );
1313 assert!(
1314 volumes
1315 .clone()
1316 .iter()
1317 .any(|v| v.name == "existing-volume-2")
1318 );
1319 assert!(
1320 volumes
1321 .iter()
1322 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1323 );
1324 assert!(volume_claim_template.is_none());
1325 }
1326
1327 #[test]
1328 fn statefulset_storage_class_omission_preserves_live() {
1329 let mut current = generated_statefulset();
1330 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1331 metadata: ObjectMeta {
1332 name: Some("kanidm-data".to_string()),
1333 ..Default::default()
1334 },
1335 spec: Some(PersistentVolumeClaimSpec {
1336 storage_class_name: Some("standard".to_string()),
1337 ..Default::default()
1338 }),
1339 ..Default::default()
1340 }]);
1341 let mut desired = generated_statefulset();
1342 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1343 metadata: ObjectMeta {
1344 name: Some("kanidm-data".to_string()),
1345 ..Default::default()
1346 },
1347 spec: Some(PersistentVolumeClaimSpec {
1348 storage_class_name: None,
1349 ..Default::default()
1350 }),
1351 ..Default::default()
1352 }]);
1353 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1354
1355 assert_eq!(
1357 desired
1358 .spec
1359 .as_ref()
1360 .unwrap()
1361 .volume_claim_templates
1362 .as_ref()
1363 .unwrap()[0]
1364 .spec
1365 .as_ref()
1366 .unwrap()
1367 .storage_class_name,
1368 Some("standard".to_string())
1369 );
1370 }
1371
1372 #[test]
1373 fn statefulset_storage_class_explicit_non_null_desired_is_preserved() {
1374 let mut current = generated_statefulset();
1375 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1376 metadata: ObjectMeta {
1377 name: Some("kanidm-data".to_string()),
1378 ..Default::default()
1379 },
1380 spec: Some(PersistentVolumeClaimSpec {
1381 storage_class_name: Some("old".to_string()),
1382 ..Default::default()
1383 }),
1384 ..Default::default()
1385 }]);
1386 let mut desired = generated_statefulset();
1387 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1388 metadata: ObjectMeta {
1389 name: Some("kanidm-data".to_string()),
1390 ..Default::default()
1391 },
1392 spec: Some(PersistentVolumeClaimSpec {
1393 storage_class_name: Some("new".to_string()),
1394 ..Default::default()
1395 }),
1396 ..Default::default()
1397 }]);
1398 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1400
1401 assert_eq!(
1403 desired
1404 .spec
1405 .as_ref()
1406 .unwrap()
1407 .volume_claim_templates
1408 .as_ref()
1409 .unwrap()[0]
1410 .spec
1411 .as_ref()
1412 .unwrap()
1413 .storage_class_name,
1414 Some("new".to_string())
1415 );
1416 }
1417}
1418
1419#[cfg(all(test, feature = "integration-test"))]
1420mod integration_test {
1421 use super::{REPLICATION_CONFIG_IMAGE, REPLICATION_CONFIG_SCRIPT};
1422
1423 use std::fs;
1424 use std::path::Path;
1425
1426 use tempfile::tempdir;
1427 use testcontainers::ContainerRequest;
1428 use testcontainers::GenericImage;
1429 use testcontainers::ImageExt;
1430 use testcontainers::core::Mount;
1431 use testcontainers::runners::AsyncRunner;
1432 use tokio::io::{AsyncBufReadExt, BufReader};
1433
1434 struct TestCase<'a> {
1435 env_vars: Vec<(&'a str, &'a str)>,
1436 expected_result: &'a str,
1437 }
1438
1439 async fn run_test_case(
1440 image_parts: &[&str],
1441 cmd: &[&str],
1442 tmp_dir_path: &str,
1443 env_vars: &[(&str, &str)],
1444 expected_result: &str,
1445 ) {
1446 let container = GenericImage::new(image_parts[0], image_parts[1]);
1447 let mut container_request: ContainerRequest<GenericImage> = container.clone().into();
1448
1449 for (key, value) in env_vars {
1450 container_request =
1451 container_request.with_env_var((*key).to_string(), (*value).to_string());
1452 }
1453
1454 let container = container_request
1455 .with_cmd(cmd.iter().map(|&s| s.to_string()))
1456 .with_mount(Mount::bind_mount(tmp_dir_path.to_string(), "/tmp"))
1457 .with_user(nix::unistd::getuid().to_string())
1458 .start()
1459 .await
1460 .unwrap();
1461
1462 let stdout = container.stdout(true);
1463 let mut stdout_reader = BufReader::new(stdout).lines();
1464 let mut stdout_lines = Vec::new();
1465 while let Some(l) = stdout_reader.next_line().await.unwrap() {
1466 stdout_lines.push(l);
1467 }
1468 dbg!(stdout_lines.join("\n"));
1469
1470 let stderr = container.stderr(true);
1471 let mut stderr_reader = BufReader::new(stderr).lines();
1472 let mut stderr_lines = Vec::new();
1473 while let Some(l) = stderr_reader.next_line().await.unwrap() {
1474 stderr_lines.push(l);
1475 }
1476 dbg!(stderr_lines.join("\n"));
1477
1478 let server_toml_path = Path::new(tmp_dir_path).join("server.toml");
1479 let content = fs::read_to_string(server_toml_path).expect("Unable to read server.toml");
1480 assert_eq!(content, expected_result);
1481 }
1482
1483 #[tokio::test]
1484 async fn test_replication_config_generation() {
1485 let image_parts = REPLICATION_CONFIG_IMAGE.split(':').collect::<Vec<&str>>();
1486 let cmd = ["--script", REPLICATION_CONFIG_SCRIPT];
1487 let tmp_dir = tempdir().unwrap();
1488 let tmp_dir_path = tmp_dir.path().to_str().unwrap().to_string();
1489
1490 let test_cases = vec![
1491 TestCase {
1492 env_vars: vec![
1493 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1494 ("REPLICATION_PORT", "8444"),
1495 ("BIND_ADDRESS", "0.0.0.0"),
1496 ("KANIDM_NAME", "kanidm-test"),
1497 ("POD_NAME", "kanidm-test-default-0"),
1498 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1499 (
1500 "KANIDM_TEST_DEFAULT_0_HOST",
1501 "kanidm-test-default-0.kanidm-test",
1502 ),
1503 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1504 (
1505 "KANIDM_TEST_DEFAULT_1_HOST",
1506 "kanidm-test-default-1.kanidm-test",
1507 ),
1508 ],
1509 expected_result: r#"version = "2"
1510
1511[replication]
1512origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1513bindaddress = "0.0.0.0:8444"
1514
1515"#,
1516 },
1517 TestCase {
1518 env_vars: vec![
1519 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1520 ("REPLICATION_PORT", "8444"),
1521 ("BIND_ADDRESS", "0.0.0.0"),
1522 ("KANIDM_NAME", "kanidm-test"),
1523 ("POD_NAME", "kanidm-test-default-0"),
1524 (
1525 "EXTERNAL_REPLICATION_NODE_HOST_0",
1526 "repl://external-host-0:8444",
1527 ),
1528 (
1529 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1530 "dummy-cert-external-host-0",
1531 ),
1532 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1533 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1534 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1535 (
1536 "KANIDM_TEST_DEFAULT_0_HOST",
1537 "kanidm-test-default-0.kanidm-test",
1538 ),
1539 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1540 (
1541 "KANIDM_TEST_DEFAULT_1_HOST",
1542 "kanidm-test-default-1.kanidm-test",
1543 ),
1544 ],
1545 expected_result: r#"version = "2"
1546
1547[replication]
1548origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1549bindaddress = "0.0.0.0:8444"
1550
1551[replication."repl://external-host-0:8444"]
1552type = "mutual-pull"
1553partner_cert = "dummy-cert-external-host-0"
1554automatic_refresh = true
1555
1556"#,
1557 },
1558 TestCase {
1559 env_vars: vec![
1560 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1561 ("REPLICATION_PORT", "8444"),
1562 ("BIND_ADDRESS", "0.0.0.0"),
1563 ("KANIDM_NAME", "kanidm-test"),
1564 ("POD_NAME", "kanidm-test-default-0"),
1565 (
1566 "EXTERNAL_REPLICATION_NODE_HOST_0",
1567 "repl://external-host-0:8444",
1568 ),
1569 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1570 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1571 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1572 (
1573 "KANIDM_TEST_DEFAULT_0_HOST",
1574 "kanidm-test-default-0.kanidm-test",
1575 ),
1576 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1577 (
1578 "KANIDM_TEST_DEFAULT_1_HOST",
1579 "kanidm-test-default-1.kanidm-test",
1580 ),
1581 ],
1582 expected_result: r#"version = "2"
1583
1584[replication]
1585origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1586bindaddress = "0.0.0.0:8444"
1587
1588"#,
1589 },
1590 TestCase {
1591 env_vars: vec![
1592 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1593 ("REPLICATION_PORT", "8444"),
1594 ("BIND_ADDRESS", "0.0.0.0"),
1595 ("KANIDM_NAME", "kanidm-test"),
1596 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1597 ("POD_NAME", "kanidm-test-default-0"),
1598 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1599 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1600 (
1601 "KANIDM_TEST_DEFAULT_0_HOST",
1602 "kanidm-test-default-0.kanidm-test",
1603 ),
1604 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1605 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1606 (
1607 "KANIDM_TEST_DEFAULT_1_HOST",
1608 "kanidm-test-default-1.kanidm-test",
1609 ),
1610 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1611 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1612 (
1613 "KANIDM_TEST_DEFAULT_3_HOST",
1614 "kanidm-test-default-3.kanidm-test",
1615 ),
1616 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1617 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1618 (
1619 "KANIDM_TEST_READ_REPLICA_0_HOST",
1620 "kanidm-test-read-replica-0.kanidm-test",
1621 ),
1622 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1623 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1624 (
1625 "KANIDM_TEST_READ_REPLICA_1_HOST",
1626 "kanidm-test-read-replica-1.kanidm-test",
1627 ),
1628 ],
1629 expected_result: r#"version = "2"
1630
1631[replication]
1632origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1633bindaddress = "0.0.0.0:8444"
1634
1635[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1636type = "mutual-pull"
1637partner_cert = "dummy-cert-default-1"
1638automatic_refresh = false
1639
1640[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1641type = "mutual-pull"
1642partner_cert = "dummy-cert-default-3"
1643automatic_refresh = false
1644
1645[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1646type = "allow-pull"
1647consumer_cert = "dummy-cert-read-replica-0"
1648
1649[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1650type = "allow-pull"
1651consumer_cert = "dummy-cert-read-replica-1"
1652
1653"#,
1654 },
1655 TestCase {
1656 env_vars: vec![
1657 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1658 ("REPLICATION_PORT", "8444"),
1659 ("BIND_ADDRESS", "0.0.0.0"),
1660 ("KANIDM_NAME", "kanidm-test"),
1661 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1662 ("POD_NAME", "kanidm-test-default-1"),
1663 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1664 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1665 (
1666 "KANIDM_TEST_DEFAULT_0_HOST",
1667 "kanidm-test-default-0.kanidm-test",
1668 ),
1669 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1670 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1671 (
1672 "KANIDM_TEST_DEFAULT_1_HOST",
1673 "kanidm-test-default-1.kanidm-test",
1674 ),
1675 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1676 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1677 (
1678 "KANIDM_TEST_DEFAULT_3_HOST",
1679 "kanidm-test-default-3.kanidm-test",
1680 ),
1681 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1682 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1683 (
1684 "KANIDM_TEST_READ_REPLICA_0_HOST",
1685 "kanidm-test-read-replica-0.kanidm-test",
1686 ),
1687 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1688 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1689 (
1690 "KANIDM_TEST_READ_REPLICA_1_HOST",
1691 "kanidm-test-read-replica-1.kanidm-test",
1692 ),
1693 ],
1694 expected_result: r#"version = "2"
1695
1696[replication]
1697origin = "repl://kanidm-test-default-1.kanidm-test:8444"
1698bindaddress = "0.0.0.0:8444"
1699
1700[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1701type = "mutual-pull"
1702partner_cert = "dummy-cert-default-0"
1703automatic_refresh = true
1704
1705[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1706type = "mutual-pull"
1707partner_cert = "dummy-cert-default-3"
1708automatic_refresh = false
1709
1710[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1711type = "allow-pull"
1712consumer_cert = "dummy-cert-read-replica-0"
1713
1714[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1715type = "allow-pull"
1716consumer_cert = "dummy-cert-read-replica-1"
1717
1718"#,
1719 },
1720 TestCase {
1721 env_vars: vec![
1722 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1723 ("REPLICATION_PORT", "8444"),
1724 ("BIND_ADDRESS", "0.0.0.0"),
1725 ("KANIDM_NAME", "kanidm-test"),
1726 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1727 ("POD_NAME", "kanidm-test-default-3"),
1728 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1729 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1730 (
1731 "KANIDM_TEST_DEFAULT_0_HOST",
1732 "kanidm-test-default-0.kanidm-test",
1733 ),
1734 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1735 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1736 (
1737 "KANIDM_TEST_DEFAULT_1_HOST",
1738 "kanidm-test-default-1.kanidm-test",
1739 ),
1740 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1741 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1742 (
1743 "KANIDM_TEST_DEFAULT_3_HOST",
1744 "kanidm-test-default-3.kanidm-test",
1745 ),
1746 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1747 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1748 (
1749 "KANIDM_TEST_READ_REPLICA_0_HOST",
1750 "kanidm-test-read-replica-0.kanidm-test",
1751 ),
1752 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1753 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1754 (
1755 "KANIDM_TEST_READ_REPLICA_1_HOST",
1756 "kanidm-test-read-replica-1.kanidm-test",
1757 ),
1758 ],
1759 expected_result: r#"version = "2"
1760
1761[replication]
1762origin = "repl://kanidm-test-default-3.kanidm-test:8444"
1763bindaddress = "0.0.0.0:8444"
1764
1765[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1766type = "mutual-pull"
1767partner_cert = "dummy-cert-default-0"
1768automatic_refresh = true
1769
1770[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1771type = "mutual-pull"
1772partner_cert = "dummy-cert-default-1"
1773automatic_refresh = false
1774
1775[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1776type = "allow-pull"
1777consumer_cert = "dummy-cert-read-replica-0"
1778
1779[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1780type = "allow-pull"
1781consumer_cert = "dummy-cert-read-replica-1"
1782
1783"#,
1784 },
1785 TestCase {
1786 env_vars: vec![
1787 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1788 ("REPLICATION_PORT", "8444"),
1789 ("BIND_ADDRESS", "0.0.0.0"),
1790 ("KANIDM_NAME", "kanidm-test"),
1791 ("REPLICA_GROUP", "read-replica"),
1792 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1793 ("POD_NAME", "kanidm-test-read-replica-0"),
1794 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1795 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1796 (
1797 "KANIDM_TEST_DEFAULT_0_HOST",
1798 "kanidm-test-default-0.kanidm-test",
1799 ),
1800 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1801 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1802 (
1803 "KANIDM_TEST_DEFAULT_1_HOST",
1804 "kanidm-test-default-1.kanidm-test",
1805 ),
1806 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1807 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1808 (
1809 "KANIDM_TEST_DEFAULT_3_HOST",
1810 "kanidm-test-default-3.kanidm-test",
1811 ),
1812 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1813 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1814 (
1815 "KANIDM_TEST_READ_REPLICA_0_HOST",
1816 "kanidm-test-read-replica-0.kanidm-test",
1817 ),
1818 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1819 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1820 (
1821 "KANIDM_TEST_READ_REPLICA_1_HOST",
1822 "kanidm-test-read-replica-1.kanidm-test",
1823 ),
1824 ],
1825 expected_result: r#"version = "2"
1826
1827[replication]
1828origin = "repl://kanidm-test-read-replica-0.kanidm-test:8444"
1829bindaddress = "0.0.0.0:8444"
1830
1831[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1832type = "pull"
1833supplier_cert = "dummy-cert-default-0"
1834automatic_refresh = true
1835
1836[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1837type = "pull"
1838supplier_cert = "dummy-cert-default-1"
1839automatic_refresh = false
1840
1841[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1842type = "pull"
1843supplier_cert = "dummy-cert-default-3"
1844automatic_refresh = false
1845
1846"#,
1847 },
1848 TestCase {
1849 env_vars: vec![
1850 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1851 ("REPLICATION_PORT", "8444"),
1852 ("BIND_ADDRESS", "0.0.0.0"),
1853 ("KANIDM_NAME", "kanidm-test"),
1854 ("REPLICA_GROUP", "read-replica"),
1855 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1856 ("POD_NAME", "kanidm-test-read-replica-1"),
1857 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1858 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1859 (
1860 "KANIDM_TEST_DEFAULT_0_HOST",
1861 "kanidm-test-default-0.kanidm-test",
1862 ),
1863 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1864 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1865 (
1866 "KANIDM_TEST_DEFAULT_1_HOST",
1867 "kanidm-test-default-1.kanidm-test",
1868 ),
1869 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1870 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1871 (
1872 "KANIDM_TEST_DEFAULT_3_HOST",
1873 "kanidm-test-default-3.kanidm-test",
1874 ),
1875 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1876 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1877 (
1878 "KANIDM_TEST_READ_REPLICA_0_HOST",
1879 "kanidm-test-read-replica-0.kanidm-test",
1880 ),
1881 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1882 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1883 (
1884 "KANIDM_TEST_READ_REPLICA_1_HOST",
1885 "kanidm-test-read-replica-1.kanidm-test",
1886 ),
1887 ],
1888 expected_result: r#"version = "2"
1889
1890[replication]
1891origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1892bindaddress = "0.0.0.0:8444"
1893
1894[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1895type = "pull"
1896supplier_cert = "dummy-cert-default-0"
1897automatic_refresh = true
1898
1899[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1900type = "pull"
1901supplier_cert = "dummy-cert-default-1"
1902automatic_refresh = false
1903
1904[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1905type = "pull"
1906supplier_cert = "dummy-cert-default-3"
1907automatic_refresh = false
1908
1909"#,
1910 },
1911 TestCase {
1912 env_vars: vec![
1913 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1914 ("REPLICATION_PORT", "8444"),
1915 ("BIND_ADDRESS", "0.0.0.0"),
1916 ("KANIDM_NAME", "kanidm-test"),
1917 ("REPLICA_GROUP", "read-replica"),
1918 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1919 ("POD_NAME", "kanidm-test-read-replica-1"),
1920 (
1921 "EXTERNAL_REPLICATION_NODE_HOST_0",
1922 "repl://external-host-0:8444",
1923 ),
1924 (
1925 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1926 "dummy-cert-external-host-0",
1927 ),
1928 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1929 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1930 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1931 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1932 (
1933 "KANIDM_TEST_DEFAULT_0_HOST",
1934 "kanidm-test-default-0.kanidm-test",
1935 ),
1936 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1937 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1938 (
1939 "KANIDM_TEST_DEFAULT_1_HOST",
1940 "kanidm-test-default-1.kanidm-test",
1941 ),
1942 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1943 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1944 (
1945 "KANIDM_TEST_DEFAULT_3_HOST",
1946 "kanidm-test-default-3.kanidm-test",
1947 ),
1948 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1949 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1950 (
1951 "KANIDM_TEST_READ_REPLICA_0_HOST",
1952 "kanidm-test-read-replica-0.kanidm-test",
1953 ),
1954 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1955 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1956 (
1957 "KANIDM_TEST_READ_REPLICA_1_HOST",
1958 "kanidm-test-read-replica-1.kanidm-test",
1959 ),
1960 ],
1961 expected_result: r#"version = "2"
1962
1963[replication]
1964origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
1965bindaddress = "0.0.0.0:8444"
1966
1967[replication."repl://external-host-0:8444"]
1968type = "mutual-pull"
1969partner_cert = "dummy-cert-external-host-0"
1970automatic_refresh = true
1971
1972[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1973type = "pull"
1974supplier_cert = "dummy-cert-default-0"
1975automatic_refresh = true
1976
1977[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1978type = "pull"
1979supplier_cert = "dummy-cert-default-1"
1980automatic_refresh = false
1981
1982[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1983type = "pull"
1984supplier_cert = "dummy-cert-default-3"
1985automatic_refresh = false
1986
1987"#,
1988 },
1989 TestCase {
1990 env_vars: vec![
1991 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1992 ("REPLICATION_PORT", "8444"),
1993 ("BIND_ADDRESS", "0.0.0.0"),
1994 ("KANIDM_NAME", "kanidm-test"),
1995 ("POD_NAME", "kanidm-test-default-0"),
1996 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1997 ("KANIDM_TEST_DEFAULT_0_HOST", "10.200.20.1"),
1998 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1999 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2000 ("KANIDM_TEST_DEFAULT_1_HOST", "10.200.20.2"),
2001 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
2002 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2003 ("KANIDM_TEST_DEFAULT_3_HOST", "10.200.20.4"),
2004 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
2005 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2006 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
2007 (
2008 "KANIDM_TEST_READ_REPLICA_0_HOST",
2009 "kanidm-test-read-replica-0.kanidm-test",
2010 ),
2011 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2012 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
2013 (
2014 "KANIDM_TEST_READ_REPLICA_1_HOST",
2015 "kanidm-test-read-replica-1.kanidm-test",
2016 ),
2017 ],
2018 expected_result: r#"version = "2"
2019
2020[replication]
2021origin = "repl://10.200.20.1:8444"
2022bindaddress = "0.0.0.0:8444"
2023
2024[replication."repl://10.200.20.2:8444"]
2025type = "mutual-pull"
2026partner_cert = "dummy-cert-default-1"
2027automatic_refresh = false
2028
2029[replication."repl://10.200.20.4:8444"]
2030type = "mutual-pull"
2031partner_cert = "dummy-cert-default-3"
2032automatic_refresh = false
2033
2034[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
2035type = "allow-pull"
2036consumer_cert = "dummy-cert-read-replica-0"
2037
2038[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
2039type = "allow-pull"
2040consumer_cert = "dummy-cert-read-replica-1"
2041
2042"#,
2043 },
2044 ];
2045
2046 for test_case in test_cases {
2047 run_test_case(
2048 &image_parts,
2049 &cmd,
2050 &tmp_dir_path,
2051 &test_case.env_vars,
2052 test_case.expected_result,
2053 )
2054 .await;
2055 }
2056 }
2057}