1use super::secret::{REPLICA_SECRET_KEY, SecretExt};
2use super::service::ServiceExt;
3use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
4
5use crate::controller::cluster_domain;
6use crate::kanidm::crd::{IpFamily, Kanidm, KanidmServerRole, ReplicaGroup, ReplicationType};
7
8use kaniop_backup_core::auth::{
9 AuthRole, build_auth_env_vars, build_auth_volume_mounts, build_auth_volumes,
10 build_ca_bundle_volume, build_ca_bundle_volume_mount, build_encryption_env_vars,
11 ca_bundle_env_var,
12};
13use kaniop_backup_core::image::data_mover_image;
14use kaniop_backup_core::pod_defaults::{default_resource_requirements, hardened_security_context};
15
16use kaniop_k8s_util::error::Result;
17use kaniop_k8s_util::resources::merge_containers;
18
19use std::collections::BTreeMap;
20
21use k8s_openapi::api::apps::v1::{StatefulSet, StatefulSetSpec};
22use k8s_openapi::api::core::v1::{
23 Container, ContainerPort, EmptyDirVolumeSource, EnvVar, EnvVarSource, HTTPGetAction,
24 ObjectFieldSelector, PersistentVolumeClaim, PodSpec, PodTemplateSpec, Probe, SecretKeySelector,
25 SecretVolumeSource, Volume, VolumeMount,
26};
27use k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector;
28use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
29use kube::ResourceExt;
30use kube::api::{ObjectMeta, Resource};
31
32pub const REPLICA_GROUP_LABEL: &str = "kanidm.kaniop.rs/replica-group";
33pub const REPLICA_LABEL: &str = "kanidm.kaniop.rs/replica";
34pub const TLS_SECRET_HASH_ANNOTATION: &str = "kanidm.kaniop.rs/tls-secret-hash";
35pub const CONTAINER_REPLICATION_PORT: i32 = 8444;
36pub const CONTAINER_REPLICATION_PORT_NAME: &str = "replication";
37
38const REPLICATION_CONFIG_IMAGE: &str = "ghcr.io/rash-sh/rash:3.0.0";
40const REPLICATION_CONFIG_SCRIPT: &str = r#"
41- copy:
42 content: |
43 {%- set backup_enabled = env.KANIOP_BACKUP_ENABLED if env.KANIOP_BACKUP_ENABLED is defined else "" %}
44 {%- set primary_node = env.KANIDM_PRIMARY_NODE if env.KANIDM_PRIMARY_NODE is defined else "" %}
45 {%- set backup_schedule = env.KANIOP_BACKUP_SCHEDULE if env.KANIOP_BACKUP_SCHEDULE is defined else "" %}
46 {%- set backup_versions = env.KANIOP_BACKUP_VERSIONS if env.KANIOP_BACKUP_VERSIONS is defined else "" -%}
47 version = "2"
48
49 {% if backup_enabled == "true" and env.POD_NAME == primary_node -%}
50 [online_backup]
51 path = "/data/backups"
52 schedule = "{{ backup_schedule }}"
53 versions = {{ backup_versions }}
54 {% endif -%}
55
56 {% if env.KANIOP_REPLICATION_ENABLED == "true" -%}
57 {% set pod_env = env.POD_NAME | upper | replace('-', '_') -%}
58 [replication]
59 origin = "repl://{{ env[pod_env + '_HOST'] }}:{{ env.REPLICATION_PORT }}"
60 bindaddress = "{{ env.BIND_ADDRESS }}:{{ env.REPLICATION_PORT }}"
61
62 {% for e in env -%}
63 {% if e is startingwith(env.KANIDM_NAME| upper | replace('-', '_')) -%}
64 {% if e == pod_env or e is endingwith("_TYPE") or
65 e + '_TYPE' not in env or env[e + '_TYPE'] == "" -%}
66 {% continue -%}
67 {% endif -%}
68 {% set replica = e | lower | replace('_', '-') -%}
69 [replication."repl://{{ env[e + '_HOST'] }}:{{ env.REPLICATION_PORT }}"]
70 {% set type = env[e + '_TYPE'] -%}
71 type = "{{ type }}"
72 {% if type == "mutual-pull" -%}
73 partner_cert = "{{ env[e] }}"
74 {% elif type == "pull" -%}
75 supplier_cert = "{{ env[e] }}"
76 {% else -%}
77 consumer_cert = "{{ env[e] }}"
78 {% endif -%}
79 {% if type != "allow-pull" -%}
80 {% if replica == primary_node -%}
81 automatic_refresh = true
82 {% else -%}
83 automatic_refresh = false
84 {% endif -%}
85 {% endif %}
86 {% elif e is startingwith("EXTERNAL_REPLICATION_NODE") -%}
87 {% if e + '_CERT' not in env or e is endingwith("_TYPE") or e is endingwith("_CERT") or e is endingwith("_AUTOMATIC_REFRESH") -%}
88 {% continue -%}
89 {% endif -%}
90 [replication."{{ env[e] }}"]
91 {% set type = env[e + '_TYPE'] -%}
92 type = "{{ type }}"
93 {% if type == "mutual-pull" -%}
94 partner_cert = "{{ env[e + '_CERT'] }}"
95 {% elif type == "pull" -%}
96 supplier_cert = "{{ env[e + '_CERT'] }}"
97 {% else -%}
98 consumer_cert = "{{ env[e + '_CERT'] }}"
99 {% endif -%}
100 {% if type != "allow-pull" -%}
101 automatic_refresh = {{ env[e + '_AUTOMATIC_REFRESH'] }}
102 {% endif %}
103 {% endif %}
104 {%- endfor -%}
105 {% endif -%}
106 dest: "{{ env.KANIDM_CONFIG_PATH }}"
107 mode: "0400"
108"#;
109const CONTAINER_HTTPS_PORT: i32 = 8443;
110const CONTAINER_LDAP_PORT: i32 = 3636;
111pub const KANIDM_CONFIG_PATH: &str = "/run/kanidm/server.toml";
112pub const KANIDM_BACKUP_PATH: &str = "/data/backups";
113const VOLUME_CONFIG_NAME: &str = "kanidm-config";
114const VOLUME_CONFIG_PATH: &str = "/run/kanidm";
115const VOLUME_DATA_NAME: &str = "kanidm-data";
116const VOLUME_DATA_PATH: &str = "/data";
117const VOLUME_TLS_NAME: &str = "kanidm-certs";
118const VOLUME_TLS_PATH: &str = "/etc/kanidm/tls";
119
120const IPV4_BIND_ADDRESS: &str = "0.0.0.0";
121const IPV6_BIND_ADDRESS: &str = "[::]";
122
123#[derive(Debug, Clone, PartialEq, Eq)]
124pub(super) enum StatefulSetApplyStrategy {
125 Apply,
126 Recreate { immutable_fields: Vec<&'static str> },
127}
128
129pub(super) fn preserve_defaulted_statefulset_fields(
140 desired: &mut StatefulSet,
141 current: &StatefulSet,
142) {
143 let Some(desired_spec) = desired.spec.as_mut() else {
144 return;
145 };
146
147 if desired_spec.pod_management_policy.is_none() {
148 desired_spec.pod_management_policy = Some("OrderedReady".to_string());
149 }
150
151 if let Some(templates) = desired_spec.volume_claim_templates.as_mut() {
152 if let Some(current_templates) = current
153 .spec
154 .as_ref()
155 .and_then(|s| s.volume_claim_templates.as_ref())
156 {
157 for template in templates.iter_mut() {
158 if let Some(spec) = template.spec.as_mut() {
159 if spec.storage_class_name.is_none()
163 && let Some(template_name) = template.metadata.name.as_deref()
164 && let Some(current_spec) = current_templates
165 .iter()
166 .find(|current| current.metadata.name.as_deref() == Some(template_name))
167 .and_then(|current| current.spec.as_ref())
168 {
169 spec.storage_class_name
170 .clone_from(¤t_spec.storage_class_name);
171 }
172 if spec.volume_mode.is_none() {
173 spec.volume_mode = Some("Filesystem".to_string());
174 }
175 }
176 }
177 } else {
178 for template in templates {
179 if let Some(spec) = template.spec.as_mut() {
180 if spec.volume_mode.is_none() {
181 spec.volume_mode = Some("Filesystem".to_string());
182 }
183 }
184 }
185 }
186 }
187}
188
189fn pod_management_policy(spec: &StatefulSetSpec) -> &str {
190 spec.pod_management_policy
191 .as_deref()
192 .unwrap_or("OrderedReady")
193}
194
195fn normalized_volume_claim_templates(spec: &StatefulSetSpec) -> Option<Vec<PersistentVolumeClaim>> {
196 let mut templates = spec.volume_claim_templates.clone();
197 if let Some(templates) = templates.as_mut() {
198 for template in templates {
199 if let Some(pvc_spec) = template.spec.as_mut()
200 && pvc_spec.volume_mode.is_none()
201 {
202 pvc_spec.volume_mode = Some("Filesystem".to_string());
203 }
204 }
205 }
206 templates
207}
208
209fn deletes_pvcs_when_deleted(spec: &StatefulSetSpec) -> bool {
210 spec.persistent_volume_claim_retention_policy
211 .as_ref()
212 .and_then(|policy| policy.when_deleted.as_deref())
213 == Some("Delete")
214}
215
216pub(super) fn classify_statefulset_change(
223 current: &StatefulSet,
224 desired: &StatefulSet,
225) -> StatefulSetApplyStrategy {
226 let (Some(current_spec), Some(desired_spec)) = (current.spec.as_ref(), desired.spec.as_ref())
227 else {
228 return StatefulSetApplyStrategy::Apply;
230 };
231
232 if normalized_volume_claim_templates(current_spec)
233 != normalized_volume_claim_templates(desired_spec)
234 {
235 return StatefulSetApplyStrategy::Apply;
236 }
237
238 let mut immutable_fields = Vec::new();
239 if current_spec.selector != desired_spec.selector {
240 immutable_fields.push("spec.selector");
241 }
242 if current_spec.service_name != desired_spec.service_name {
243 immutable_fields.push("spec.serviceName");
244 }
245 if pod_management_policy(current_spec) != pod_management_policy(desired_spec) {
246 immutable_fields.push("spec.podManagementPolicy");
247 }
248
249 if immutable_fields.is_empty() || deletes_pvcs_when_deleted(current_spec) {
250 StatefulSetApplyStrategy::Apply
251 } else {
252 StatefulSetApplyStrategy::Recreate { immutable_fields }
253 }
254}
255
256pub trait StatefulSetExt {
257 fn statefulset_name(&self, rg_name: &str) -> String;
258 fn pod_name(&self, rg_name: &str, i: i32) -> String;
259 fn pod_env_prefix(&self, pod_name: &str) -> String;
260
261 fn create_statefulset(
262 &self,
263 replica_group: &ReplicaGroup,
264 tls_secret_hash: Option<&str>,
265 backup_config: Option<&BackupConfig>,
266 ) -> Result<StatefulSet>;
267}
268
269impl StatefulSetExt for Kanidm {
270 #[inline]
271 fn statefulset_name(&self, rg_name: &str) -> String {
272 format!("{kanidm_name}-{rg_name}", kanidm_name = self.name_any())
273 }
274
275 #[inline]
276 fn pod_name(&self, rg_name: &str, i: i32) -> String {
277 format!("{}-{}", self.statefulset_name(rg_name), i)
278 }
279
280 #[inline]
281 fn pod_env_prefix(&self, pod_name: &str) -> String {
282 pod_name.to_uppercase().replace("-", "_")
283 }
284
285 fn create_statefulset(
286 &self,
287 replica_group: &ReplicaGroup,
288 tls_secret_hash: Option<&str>,
289 backup_config: Option<&BackupConfig>,
290 ) -> Result<StatefulSet> {
291 let pod_labels = self.generate_pod_labels(replica_group);
292 let labels = self.generate_sts_labels(&pod_labels);
293 let env = self.generate_env_vars(replica_group);
294 let mut init_containers = self.generate_init_containers(replica_group, backup_config)?;
295 let ports = self.generate_container_ports();
296 let probe = self.generate_probe();
297 let volume_mounts = self.generate_volume_mounts(backup_config);
298 let mut containers = self.generate_containers(
299 &env,
300 &volume_mounts,
301 &ports,
302 &probe,
303 replica_group,
304 backup_config,
305 )?;
306 let transport_config = backup_config.and_then(|config| config.transport.as_ref());
307 let transport_name = super::transport::TRANSPORT_SIDECAR_NAME;
308
309 containers.retain(|c| c.name != transport_name);
313 init_containers.retain(|c| c.name != transport_name);
314 if replica_group.primary_node {
315 if let Some(config) = transport_config {
316 init_containers.push(self.build_transport_sidecar(config, replica_group)?);
317 }
318 }
319
320 let dns_policy = self.generate_dns_policy();
321 let (mut volumes, volume_claim_templates) = self.generate_volumes(backup_config);
322
323 if let Some(config) = transport_config {
324 let auth_volumes = build_auth_volumes(&config.auth_method);
325 volumes.extend(auth_volumes);
326 if let Some(ca_bundle_ref) = &config.ca_bundle_ref {
327 volumes.push(build_ca_bundle_volume(ca_bundle_ref));
328 }
329 if !volumes.iter().any(|v| v.name == "kanidm-tmp") {
330 volumes.push(Volume {
331 name: "kanidm-tmp".to_string(),
332 empty_dir: Some(EmptyDirVolumeSource::default()),
333 ..Volume::default()
334 });
335 }
336 }
337
338 Ok(StatefulSet {
339 metadata: self.generate_metadata(
340 &replica_group.name,
341 &replica_group.stateful_set_annotations,
342 &labels,
343 ),
344 spec: Some(StatefulSetSpec {
345 replicas: Some(replica_group.replicas),
346 selector: LabelSelector {
347 match_expressions: None,
348 match_labels: Some(pod_labels.clone()),
349 },
350 template: PodTemplateSpec {
351 metadata: Some(ObjectMeta {
352 labels: Some(pod_labels),
353 annotations: tls_secret_hash.map(|hash| {
354 BTreeMap::from([(
355 TLS_SECRET_HASH_ANNOTATION.to_string(),
356 hash.to_string(),
357 )])
358 }),
359 ..ObjectMeta::default()
360 }),
361 spec: Some(PodSpec {
362 containers,
363 volumes: Some(volumes),
364 node_selector: replica_group.node_selector.clone(),
365 affinity: replica_group.affinity.clone(),
366 tolerations: replica_group.tolerations.clone(),
367 topology_spread_constraints: replica_group
368 .topology_spread_constraints
369 .clone(),
370 security_context: self.spec.security_context.clone(),
371 dns_policy,
372 dns_config: self.spec.dns_config.clone(),
373 init_containers: Some(init_containers),
374 host_aliases: self.spec.host_aliases.clone(),
375 enable_service_links: Some(self.spec.enable_service_links),
376 automount_service_account_token: self.spec.automount_service_account_token,
377 host_users: self.spec.host_users,
378 runtime_class_name: self.spec.runtime_class_name.clone(),
379 ..PodSpec::default()
380 }),
381 },
382 service_name: Some(self.service_name()),
383 persistent_volume_claim_retention_policy: self
384 .spec
385 .persistent_volume_claim_retention_policy
386 .clone(),
387 min_ready_seconds: self.spec.min_ready_seconds,
388 volume_claim_templates,
389 ..StatefulSetSpec::default()
390 }),
391 ..StatefulSet::default()
392 })
393 }
394}
395
396impl Kanidm {
397 fn uses_generated_config(&self, backup_config: Option<&BackupConfig>) -> bool {
398 self.is_replication_enabled() || backup_config.is_some()
399 }
400
401 fn generate_pod_labels(&self, replica_group: &ReplicaGroup) -> BTreeMap<String, String> {
402 self.generate_resource_labels()
403 .into_iter()
404 .chain(std::iter::once((
405 REPLICA_GROUP_LABEL.to_string(),
406 replica_group.name.clone(),
407 )))
408 .collect()
409 }
410
411 fn generate_sts_labels(
412 &self,
413 pod_labels: &BTreeMap<String, String>,
414 ) -> BTreeMap<String, String> {
415 pod_labels.clone()
416 }
417
418 fn generate_env_vars(&self, replica_group: &ReplicaGroup) -> Vec<EnvVar> {
419 let origin = match self.spec.origin.clone() {
420 Some(o) => o,
421 None => format!("https://{}", self.spec.domain.clone()),
422 };
423 let bind_address = match self.spec.ip_family {
424 IpFamily::Ipv4 => IPV4_BIND_ADDRESS,
425 IpFamily::Ipv6 => IPV6_BIND_ADDRESS,
426 };
427
428 self.spec
429 .env
430 .clone()
431 .unwrap_or_default()
432 .into_iter()
433 .chain(vec![
434 EnvVar {
435 name: "KANIDM_DOMAIN".to_string(),
436 value: Some(self.spec.domain.clone()),
437 ..EnvVar::default()
438 },
439 EnvVar {
440 name: "KANIDM_ORIGIN".to_string(),
441 value: Some(origin),
442 ..EnvVar::default()
443 },
444 EnvVar {
445 name: "KANIDM_DB_PATH".to_string(),
446 value: Some(format!("{VOLUME_DATA_PATH}/kanidm.db")),
447 ..EnvVar::default()
448 },
449 EnvVar {
450 name: "KANIDM_TLS_CHAIN".to_string(),
451 value: Some(format!("{VOLUME_TLS_PATH}/tls.crt")),
452 ..EnvVar::default()
453 },
454 EnvVar {
455 name: "KANIDM_TLS_KEY".to_string(),
456 value: Some(format!("{VOLUME_TLS_PATH}/tls.key")),
457 ..EnvVar::default()
458 },
459 EnvVar {
460 name: "KANIDM_BINDADDRESS".to_string(),
461 value: Some(format!("{bind_address}:{CONTAINER_HTTPS_PORT}")),
462 ..EnvVar::default()
463 },
464 EnvVar {
465 name: "KANIDM_ROLE".to_string(),
466 value: Some(serde_plain::to_string(&replica_group.role.clone()).unwrap()),
467 ..EnvVar::default()
468 },
469 EnvVar {
470 name: "KANIDM_LOG_LEVEL".to_string(),
471 value: Some(serde_plain::to_string(&self.spec.log_level.clone()).unwrap()),
472 ..EnvVar::default()
473 },
474 ])
475 .chain(
476 self.spec
477 .ldap_port_name
478 .clone()
479 .into_iter()
480 .map(|_| EnvVar {
481 name: "KANIDM_LDAPBINDADDRESS".to_string(),
482 value: Some(format!("{bind_address}:{CONTAINER_LDAP_PORT}")),
483 ..EnvVar::default()
484 }),
485 )
486 .collect()
487 }
488
489 fn generate_config_volume_mount(&self) -> VolumeMount {
490 VolumeMount {
491 name: VOLUME_CONFIG_NAME.to_string(),
492 mount_path: VOLUME_CONFIG_PATH.to_string(),
493 read_only: Some(false),
494 ..VolumeMount::default()
495 }
496 }
497
498 fn generate_volume_mounts(&self, backup_config: Option<&BackupConfig>) -> Vec<VolumeMount> {
499 self.spec
500 .volume_mounts
501 .clone()
502 .unwrap_or_default()
503 .into_iter()
504 .chain([
505 VolumeMount {
506 name: VOLUME_DATA_NAME.to_string(),
507 mount_path: VOLUME_DATA_PATH.to_string(),
508 ..VolumeMount::default()
509 },
510 VolumeMount {
511 name: VOLUME_TLS_NAME.to_string(),
512 mount_path: VOLUME_TLS_PATH.to_string(),
513 read_only: Some(true),
514 ..VolumeMount::default()
515 },
516 ])
517 .chain(
518 self.uses_generated_config(backup_config)
519 .then(|| self.generate_config_volume_mount()),
520 )
521 .collect()
522 }
523
524 fn generate_init_containers(
525 &self,
526 replica_group: &ReplicaGroup,
527 backup_config: Option<&BackupConfig>,
528 ) -> Result<Vec<Container>> {
529 if self.uses_generated_config(backup_config) {
530 let external_replica_nodes_envs = self
531 .spec
532 .external_replication_nodes
533 .iter()
534 .flat_map(|ern| {
535 [
536 EnvVar {
537 name: format!("EXTERNAL_REPLICATION_NODE_{}", ern.name),
538 value: Some(format!(
539 "repl://{host}:{port}",
540 host = ern.hostname.clone(),
541 port = ern.port
542 )),
543 ..EnvVar::default()
544 },
545 EnvVar {
546 name: format!("EXTERNAL_REPLICATION_NODE_{}_CERT", ern.name),
547 value_from: Some(EnvVarSource {
548 secret_key_ref: Some(ern.certificate.clone()),
549 ..EnvVarSource::default()
550 }),
551 ..EnvVar::default()
552 },
553 EnvVar {
554 name: format!("EXTERNAL_REPLICATION_NODE_{}_TYPE", ern.name),
555 value: serde_plain::to_string(&ern._type).ok(),
556 ..EnvVar::default()
557 },
558 EnvVar {
559 name: format!(
560 "EXTERNAL_REPLICATION_NODE_{}_AUTOMATIC_REFRESH",
561 ern.name
562 ),
563 value: Some(ern.automatic_refresh.to_string()),
564 ..EnvVar::default()
565 },
566 ]
567 })
568 .collect::<Vec<EnvVar>>();
569 let replica_secrets_envs = self
570 .spec
571 .replica_groups
572 .iter()
573 .flat_map(|rg| {
574 (0..rg.replicas).flat_map(move |i| {
575 let pod_name = self.pod_name(&rg.name, i);
576 let pod_env_prefix = self.pod_env_prefix(&pod_name);
577 let pod_host = match rg
578 .services
579 .as_ref()
580 .and_then(|s| s.replication_hostname_template.as_ref())
581 {
582 Some(template) => template
583 .replace("{pod_name}", &pod_name)
584 .replace("{replica_index}", &i.to_string())
585 .replace("{domain}", &self.spec.domain),
586 None => format!(
587 "{pod_name}.{}.{}.svc.{}",
588 self.service_name(),
589 self.get_namespace(),
590 cluster_domain()
591 ),
592 };
593 [
594 EnvVar {
595 name: pod_env_prefix.clone(),
596 value_from: Some(EnvVarSource {
597 secret_key_ref: Some(SecretKeySelector {
598 name: self.replica_secret_name(&pod_name),
599 key: REPLICA_SECRET_KEY.to_string(),
600 optional: Some(true),
601 }),
602 ..EnvVarSource::default()
603 }),
604 ..EnvVar::default()
605 },
606 EnvVar {
607 name: format!("{pod_env_prefix}_TYPE"),
608 value: replication_type(
609 replica_group.role.clone(),
610 rg.role.clone(),
611 )
612 .and_then(|t| serde_plain::to_string(&t).ok()),
613 ..EnvVar::default()
614 },
615 EnvVar {
616 name: format!("{pod_env_prefix}_HOST"),
617 value: Some(pod_host),
618 ..EnvVar::default()
619 },
620 ]
621 })
622 })
623 .collect::<Vec<EnvVar>>();
624
625 let primary_node = self
626 .spec
627 .replica_groups
628 .iter()
629 .find(|rg| rg.primary_node)
630 .map(|rg| format!("{}-0", self.statefulset_name(&rg.name)));
631
632 let bind_address = match self.spec.ip_family {
633 IpFamily::Ipv4 => IPV4_BIND_ADDRESS,
634 IpFamily::Ipv6 => IPV6_BIND_ADDRESS,
635 };
636
637 let env = external_replica_nodes_envs
638 .into_iter()
639 .chain(replica_secrets_envs)
640 .chain([
641 EnvVar {
642 name: "POD_NAME".to_string(),
643 value_from: Some(EnvVarSource {
644 field_ref: Some(ObjectFieldSelector {
645 api_version: Some("v1".to_string()),
646 field_path: "metadata.name".to_string(),
647 }),
648 ..EnvVarSource::default()
649 }),
650 ..EnvVar::default()
651 },
652 EnvVar {
653 name: "REPLICATION_PORT".to_string(),
654 value: Some(CONTAINER_REPLICATION_PORT.to_string()),
655 ..EnvVar::default()
656 },
657 EnvVar {
658 name: "BIND_ADDRESS".to_string(),
659 value: Some(bind_address.to_string()),
660 ..EnvVar::default()
661 },
662 EnvVar {
663 name: "KANIDM_CONFIG_PATH".to_string(),
664 value: Some(KANIDM_CONFIG_PATH.to_string()),
665 ..EnvVar::default()
666 },
667 EnvVar {
668 name: "KANIDM_NAME".to_string(),
669 value: Some(self.name_any()),
670 ..EnvVar::default()
671 },
672 EnvVar {
673 name: "KANIOP_REPLICATION_ENABLED".to_string(),
674 value: Some(self.is_replication_enabled().to_string()),
675 ..EnvVar::default()
676 },
677 EnvVar {
678 name: "KANIOP_BACKUP_ENABLED".to_string(),
679 value: Some(backup_config.is_some().to_string()),
680 ..EnvVar::default()
681 },
682 ])
683 .chain(backup_config.into_iter().flat_map(|backup| {
684 [
685 EnvVar {
686 name: "KANIOP_BACKUP_SCHEDULE".to_string(),
687 value: Some(backup.schedule.clone()),
688 ..EnvVar::default()
689 },
690 EnvVar {
691 name: "KANIOP_BACKUP_VERSIONS".to_string(),
692 value: Some(backup.local_versions.to_string()),
693 ..EnvVar::default()
694 },
695 ]
696 }))
697 .chain(primary_node.map(|pn| EnvVar {
698 name: "KANIDM_PRIMARY_NODE".to_string(),
699 value: Some(pn),
700 ..EnvVar::default()
701 }))
702 .collect::<Vec<EnvVar>>();
703
704 let init_container = Container {
705 name: "kanidm-generate-replication-config".to_string(),
706 image: Some(REPLICATION_CONFIG_IMAGE.to_string()),
707 env: Some(env),
708 args: Some(vec![
709 "--script".to_string(),
710 REPLICATION_CONFIG_SCRIPT.to_string(),
711 ]),
712 volume_mounts: Some(vec![self.generate_config_volume_mount()]),
713 ..Container::default()
714 };
715
716 merge_containers(self.spec.init_containers.clone(), &init_container)
717 } else {
718 let filtered_init_containers = self
722 .spec
723 .init_containers
724 .clone()
725 .unwrap_or_default()
726 .into_iter()
727 .filter(|container| container.name != "kanidm-generate-replication-config")
728 .collect();
729 Ok(filtered_init_containers)
730 }
731 }
732
733 fn generate_container_ports(&self) -> Vec<ContainerPort> {
734 std::iter::once(ContainerPort {
735 name: Some(self.spec.port_name.clone()),
736 container_port: CONTAINER_HTTPS_PORT,
737 ..ContainerPort::default()
738 })
739 .chain(
740 self.spec
741 .ldap_port_name
742 .clone()
743 .into_iter()
744 .map(|port_name| ContainerPort {
745 name: Some(port_name.clone()),
746 container_port: CONTAINER_LDAP_PORT,
747 ..ContainerPort::default()
748 }),
749 )
750 .chain(self.is_replication_enabled().then(|| ContainerPort {
751 name: Some(CONTAINER_REPLICATION_PORT_NAME.to_string()),
752 container_port: CONTAINER_REPLICATION_PORT,
753 ..ContainerPort::default()
754 }))
755 .collect()
756 }
757
758 fn generate_probe(&self) -> Probe {
759 Probe {
760 http_get: Some(HTTPGetAction {
761 path: Some("/status".to_string()),
762 port: IntOrString::String(self.spec.port_name.clone()),
763 scheme: Some("HTTPS".to_string()),
764 ..HTTPGetAction::default()
765 }),
766 ..Probe::default()
767 }
768 }
769
770 fn generate_containers(
771 &self,
772 env: &[EnvVar],
773 volume_mounts: &[VolumeMount],
774 ports: &[ContainerPort],
775 probe: &Probe,
776 replica_group: &ReplicaGroup,
777 backup_config: Option<&BackupConfig>,
778 ) -> Result<Vec<Container>> {
779 let command = vec!["kanidmd".to_string(), "server".to_string()]
780 .into_iter()
781 .chain(
782 self.uses_generated_config(backup_config)
783 .then(|| vec!["-c".to_string(), KANIDM_CONFIG_PATH.to_string()])
784 .into_iter()
785 .flatten(),
786 )
787 .collect::<Vec<String>>();
788 let kanidm_container = Container {
789 name: "kanidm".to_string(),
790 image: Some(self.spec.image.clone()),
791 image_pull_policy: self.spec.image_pull_policy.clone(),
792 command: Some(command),
793 env: Some(env.to_owned()),
794 ports: Some(ports.to_owned()),
795 volume_mounts: Some(volume_mounts.to_owned()),
796 resources: replica_group.resources.clone(),
797 readiness_probe: Some(probe.clone()),
798 liveness_probe: Some(probe.clone()),
799 ..Container::default()
800 };
801
802 merge_containers(self.spec.containers.clone(), &kanidm_container)
803 }
804
805 fn generate_dns_policy(&self) -> Option<String> {
806 match self.spec.host_network {
807 Some(true) => Some("ClusterFirstWithHostNet".to_string()),
808 _ => self.spec.dns_policy.clone(),
809 }
810 }
811
812 fn generate_volumes(
813 &self,
814 backup_config: Option<&BackupConfig>,
815 ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
816 let secret_name = self.effective_tls_secret_name();
817
818 self.expand_storage(
819 self.spec
820 .volumes
821 .clone()
822 .unwrap_or_default()
823 .into_iter()
824 .chain(std::iter::once(Volume {
825 name: VOLUME_TLS_NAME.to_string(),
826 secret: Some(SecretVolumeSource {
827 secret_name: Some(secret_name),
828 default_mode: Some(0o400),
829 ..SecretVolumeSource::default()
830 }),
831 ..Volume::default()
832 }))
833 .chain(self.uses_generated_config(backup_config).then(|| Volume {
834 name: VOLUME_CONFIG_NAME.to_string(),
835 empty_dir: Some(EmptyDirVolumeSource {
836 medium: None,
837 size_limit: None,
838 }),
839 ..Volume::default()
840 }))
841 .collect(),
842 )
843 }
844
845 fn expand_storage(
846 &self,
847 volumes: Vec<Volume>,
848 ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
849 let default_expand_storage = |volumes: Vec<Volume>| {
850 (
851 volumes
852 .into_iter()
853 .chain(std::iter::once(Volume {
854 name: VOLUME_DATA_NAME.to_string(),
855 empty_dir: Some(EmptyDirVolumeSource {
856 medium: None,
857 size_limit: None,
858 }),
859 ..Volume::default()
860 }))
861 .collect(),
862 None,
863 )
864 };
865
866 match self.spec.storage.clone() {
867 Some(storage) => {
868 if let Some(empty_dir) = storage.empty_dir {
869 (
870 volumes
871 .into_iter()
872 .chain(std::iter::once(Volume {
873 name: VOLUME_DATA_NAME.to_string(),
874 empty_dir: Some(empty_dir),
875 ..Volume::default()
876 }))
877 .collect(),
878 None,
879 )
880 } else if let Some(ephemeral) = storage.ephemeral {
881 (
882 volumes
883 .into_iter()
884 .chain(std::iter::once(Volume {
885 name: VOLUME_DATA_NAME.to_string(),
886 ephemeral: Some(ephemeral),
887 ..Volume::default()
888 }))
889 .collect(),
890 None,
891 )
892 } else if let Some(volume_claim_template) = storage.volume_claim_template {
893 let pvc = volume_claim_template.to_persistent_volume_claim();
894 let named_template = PersistentVolumeClaim {
895 metadata: ObjectMeta {
896 name: Some(VOLUME_DATA_NAME.to_string()),
897 ..pvc.metadata
898 },
899 spec: pvc.spec,
900 ..pvc
901 };
902 (volumes, Some(vec![named_template]))
903 } else {
904 default_expand_storage(volumes)
905 }
906 }
907 None => default_expand_storage(volumes),
908 }
909 }
910
911 fn generate_metadata(
912 &self,
913 replica_group_name: &str,
914 annotations: &Option<BTreeMap<String, String>>,
915 labels: &BTreeMap<String, String>,
916 ) -> ObjectMeta {
917 ObjectMeta {
918 name: Some(self.statefulset_name(replica_group_name)),
919 namespace: self.namespace(),
920 labels: Some(labels.clone()),
921 owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
922 annotations: annotations.clone(),
923 ..ObjectMeta::default()
924 }
925 }
926
927 fn build_transport_sidecar(
928 &self,
929 config: &TransportSidecarConfig,
930 replica_group: &ReplicaGroup,
931 ) -> Result<Container> {
932 let primary_node = format!("{}-0", self.statefulset_name(&replica_group.name));
933
934 let mut env_vars = vec![
935 EnvVar {
936 name: "POD_NAME".to_string(),
937 value_from: Some(EnvVarSource {
938 field_ref: Some(ObjectFieldSelector {
939 api_version: Some("v1".to_string()),
940 field_path: "metadata.name".to_string(),
941 }),
942 ..EnvVarSource::default()
943 }),
944 ..EnvVar::default()
945 },
946 EnvVar {
947 name: "KANIDM_PRIMARY_NODE".to_string(),
948 value: Some(primary_node),
949 ..EnvVar::default()
950 },
951 ];
952
953 let auth_env = build_auth_env_vars(&config.auth_method, &self.name_any(), AuthRole::Writer);
954 env_vars.extend(auth_env);
955
956 if config.ca_bundle_ref.is_some() {
957 env_vars.push(ca_bundle_env_var());
958 }
959
960 env_vars.extend(build_encryption_env_vars(
961 config.encryption_key_ref.as_ref(),
962 ));
963
964 let mut volume_mounts = vec![
965 VolumeMount {
966 name: VOLUME_DATA_NAME.to_string(),
967 mount_path: VOLUME_DATA_PATH.to_string(),
968 read_only: Some(true),
969 ..VolumeMount::default()
970 },
971 VolumeMount {
972 name: "kanidm-tmp".to_string(),
973 mount_path: "/tmp".to_string(),
974 ..VolumeMount::default()
975 },
976 ];
977
978 let auth_mounts = build_auth_volume_mounts(&config.auth_method);
979 volume_mounts.extend(auth_mounts);
980
981 if config.ca_bundle_ref.is_some() {
982 volume_mounts.push(build_ca_bundle_volume_mount());
983 }
984
985 Ok(Container {
986 name: super::transport::TRANSPORT_SIDECAR_NAME.to_string(),
987 image: Some(data_mover_image()),
988 command: Some(vec!["/bin/kaniop-data-mover".to_string()]),
989 args: Some(vec![
990 "transport".to_string(),
991 "--operation-doc".to_string(),
992 config.operation_doc_json.clone(),
993 ]),
994 env: Some(env_vars),
995 volume_mounts: Some(volume_mounts),
996 security_context: Some(hardened_security_context()),
997 resources: Some(default_resource_requirements()),
998 restart_policy: Some("Always".to_string()),
1001 ..Container::default()
1002 })
1003 }
1004}
1005
1006fn replication_type(
1007 source_role: KanidmServerRole,
1008 target_role: KanidmServerRole,
1009) -> Option<ReplicationType> {
1010 match (source_role, target_role) {
1011 (
1012 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
1013 KanidmServerRole::WriteReplicaNoUi | KanidmServerRole::WriteReplica,
1014 ) => Some(ReplicationType::MutualPull),
1015
1016 (
1017 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
1018 KanidmServerRole::ReadOnlyReplica,
1019 ) => Some(ReplicationType::AllowPull),
1020 (
1021 KanidmServerRole::ReadOnlyReplica,
1022 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
1023 ) => Some(ReplicationType::Pull),
1024 (KanidmServerRole::ReadOnlyReplica, KanidmServerRole::ReadOnlyReplica) => None,
1025 }
1026}
1027
1028#[cfg(test)]
1029mod tests {
1030 use super::{
1031 StatefulSetApplyStrategy, StatefulSetExt, TLS_SECRET_HASH_ANNOTATION,
1032 classify_statefulset_change, preserve_defaulted_statefulset_fields,
1033 };
1034 use crate::kanidm::crd::{
1035 Kanidm, KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
1036 };
1037 use k8s_openapi::api::apps::v1::{
1038 StatefulSet, StatefulSetPersistentVolumeClaimRetentionPolicy,
1039 };
1040 use k8s_openapi::api::core::v1::{
1041 EmptyDirVolumeSource, EphemeralVolumeSource, PersistentVolumeClaim,
1042 PersistentVolumeClaimSpec, Volume,
1043 };
1044 use kube::api::ObjectMeta;
1045
1046 fn create_kanidm_with_storage(storage: Option<KanidmStorage>) -> Kanidm {
1047 Kanidm {
1048 spec: KanidmSpec {
1049 storage,
1050 ..Default::default()
1051 },
1052 ..Default::default()
1053 }
1054 }
1055
1056 pub(super) fn create_kanidm_with_replica_group() -> (Kanidm, ReplicaGroup) {
1057 let replica_group = ReplicaGroup {
1058 name: "default".to_string(),
1059 replicas: 1,
1060 ..Default::default()
1061 };
1062 let kanidm = Kanidm {
1063 metadata: ObjectMeta {
1064 name: Some("test".to_string()),
1065 namespace: Some("default".to_string()),
1066 ..Default::default()
1067 },
1068 spec: KanidmSpec {
1069 domain: "idm.example.com".to_string(),
1070 replica_groups: vec![replica_group.clone()],
1071 ..Default::default()
1072 },
1073 ..Default::default()
1074 };
1075 (kanidm, replica_group)
1076 }
1077
1078 #[test]
1079 fn test_create_statefulset_with_tls_secret_hash_annotation() {
1080 let (kanidm, replica_group) = create_kanidm_with_replica_group();
1081 let sts = kanidm
1082 .create_statefulset(&replica_group, Some("abc123"), None)
1083 .unwrap();
1084
1085 let annotations = sts
1086 .spec
1087 .unwrap()
1088 .template
1089 .metadata
1090 .unwrap()
1091 .annotations
1092 .unwrap();
1093 assert_eq!(
1094 annotations.get(TLS_SECRET_HASH_ANNOTATION),
1095 Some(&"abc123".to_string())
1096 );
1097 }
1098
1099 #[test]
1100 fn test_create_statefulset_without_tls_secret_hash_annotation() {
1101 let (kanidm, replica_group) = create_kanidm_with_replica_group();
1102 let sts = kanidm
1103 .create_statefulset(&replica_group, None, None)
1104 .unwrap();
1105
1106 let annotations = sts.spec.unwrap().template.metadata.unwrap().annotations;
1107 assert!(annotations.is_none());
1108 }
1109
1110 #[test]
1111 fn test_generate_volumes_without_storage() {
1112 let kanidm = create_kanidm_with_storage(None);
1113 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1114
1115 assert_eq!(volumes.clone().len(), 1);
1116 assert_eq!(volumes.clone().first().unwrap().name, "kanidm-data");
1117 assert!(volumes.first().unwrap().empty_dir.is_some());
1118 assert!(volume_claim_template.is_none());
1119 }
1120
1121 fn generated_statefulset() -> StatefulSet {
1122 let (kanidm, replica_group) = create_kanidm_with_replica_group();
1123 kanidm
1124 .create_statefulset(&replica_group, None, None)
1125 .unwrap()
1126 }
1127
1128 #[test]
1129 fn statefulset_mutable_change_uses_apply() {
1130 let current = generated_statefulset();
1131 let mut desired = current.clone();
1132 desired.spec.as_mut().unwrap().replicas = Some(2);
1133
1134 assert_eq!(
1135 classify_statefulset_change(¤t, &desired),
1136 StatefulSetApplyStrategy::Apply
1137 );
1138 }
1139
1140 #[test]
1141 fn statefulset_selector_change_requires_recreation() {
1142 let current = generated_statefulset();
1143 let mut desired = current.clone();
1144 desired
1145 .spec
1146 .as_mut()
1147 .unwrap()
1148 .selector
1149 .match_labels
1150 .get_or_insert_default()
1151 .insert("immutable".to_string(), "changed".to_string());
1152
1153 assert_eq!(
1154 classify_statefulset_change(¤t, &desired),
1155 StatefulSetApplyStrategy::Recreate {
1156 immutable_fields: vec!["spec.selector"]
1157 }
1158 );
1159 }
1160
1161 #[test]
1162 fn statefulset_service_name_change_requires_recreation() {
1163 let current = generated_statefulset();
1164 let mut desired = current.clone();
1165 desired.spec.as_mut().unwrap().service_name = Some("different".to_string());
1166
1167 assert_eq!(
1168 classify_statefulset_change(¤t, &desired),
1169 StatefulSetApplyStrategy::Recreate {
1170 immutable_fields: vec!["spec.serviceName"]
1171 }
1172 );
1173 }
1174
1175 #[test]
1176 fn statefulset_pod_management_default_does_not_recreate() {
1177 let mut current = generated_statefulset();
1178 current.spec.as_mut().unwrap().pod_management_policy = Some("OrderedReady".to_string());
1179 let mut desired = generated_statefulset();
1180 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1181
1182 assert_eq!(
1183 classify_statefulset_change(¤t, &desired),
1184 StatefulSetApplyStrategy::Apply
1185 );
1186 }
1187
1188 #[test]
1189 fn statefulset_non_default_pod_management_policy_requires_recreation() {
1190 let mut current = generated_statefulset();
1191 current.spec.as_mut().unwrap().pod_management_policy = Some("Parallel".to_string());
1192 let mut desired = generated_statefulset();
1193 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1194
1195 assert_eq!(
1196 classify_statefulset_change(¤t, &desired),
1197 StatefulSetApplyStrategy::Recreate {
1198 immutable_fields: vec!["spec.podManagementPolicy"]
1199 }
1200 );
1201 }
1202
1203 #[test]
1204 fn statefulset_volume_claim_template_change_is_non_destructive() {
1205 let mut current = generated_statefulset();
1206 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1207 metadata: ObjectMeta {
1208 name: Some("kanidm-data".to_string()),
1209 ..Default::default()
1210 },
1211 spec: Some(PersistentVolumeClaimSpec {
1212 storage_class_name: Some("old".to_string()),
1213 ..Default::default()
1214 }),
1215 ..Default::default()
1216 }]);
1217 let mut desired = current.clone();
1218 desired
1219 .spec
1220 .as_mut()
1221 .unwrap()
1222 .volume_claim_templates
1223 .as_mut()
1224 .unwrap()[0]
1225 .spec
1226 .as_mut()
1227 .unwrap()
1228 .storage_class_name = Some("new".to_string());
1229
1230 assert_eq!(
1231 classify_statefulset_change(¤t, &desired),
1232 StatefulSetApplyStrategy::Apply
1233 );
1234 }
1235
1236 #[test]
1237 fn statefulset_storage_class_defaulting_preserves_live_value() {
1238 let mut current = generated_statefulset();
1239 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1240 metadata: ObjectMeta {
1241 name: Some("kanidm-data".to_string()),
1242 ..Default::default()
1243 },
1244 spec: Some(PersistentVolumeClaimSpec {
1245 storage_class_name: Some("fast".to_string()),
1246 ..Default::default()
1247 }),
1248 ..Default::default()
1249 }]);
1250 let mut desired = current.clone();
1251 desired
1252 .spec
1253 .as_mut()
1254 .unwrap()
1255 .volume_claim_templates
1256 .as_mut()
1257 .unwrap()[0]
1258 .spec
1259 .as_mut()
1260 .unwrap()
1261 .storage_class_name = None;
1262 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1263
1264 assert_eq!(
1267 desired
1268 .spec
1269 .as_ref()
1270 .unwrap()
1271 .volume_claim_templates
1272 .as_ref()
1273 .unwrap()[0]
1274 .spec
1275 .as_ref()
1276 .unwrap()
1277 .storage_class_name,
1278 Some("fast".to_string())
1279 );
1280 assert_eq!(
1281 classify_statefulset_change(¤t, &desired),
1282 StatefulSetApplyStrategy::Apply
1283 );
1284 }
1285
1286 #[test]
1287 fn statefulset_server_defaults_do_not_require_recreation() {
1288 let mut desired = generated_statefulset();
1289 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1290 metadata: ObjectMeta {
1291 name: Some("kanidm-data".to_string()),
1292 ..Default::default()
1293 },
1294 spec: Some(PersistentVolumeClaimSpec::default()),
1295 ..Default::default()
1296 }]);
1297 let mut current = desired.clone();
1298 let current_spec = current.spec.as_mut().unwrap();
1299 current_spec.pod_management_policy = Some("OrderedReady".to_string());
1300 current_spec.volume_claim_templates.as_mut().unwrap()[0]
1301 .spec
1302 .as_mut()
1303 .unwrap()
1304 .volume_mode = Some("Filesystem".to_string());
1305
1306 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1307
1308 assert_eq!(
1309 classify_statefulset_change(¤t, &desired),
1310 StatefulSetApplyStrategy::Apply
1311 );
1312 }
1313
1314 #[test]
1315 fn statefulset_delete_retention_blocks_automatic_recreation() {
1316 let mut current = generated_statefulset();
1317 current
1318 .spec
1319 .as_mut()
1320 .unwrap()
1321 .persistent_volume_claim_retention_policy =
1322 Some(StatefulSetPersistentVolumeClaimRetentionPolicy {
1323 when_deleted: Some("Delete".to_string()),
1324 when_scaled: None,
1325 });
1326 let mut desired = current.clone();
1327 desired
1328 .spec
1329 .as_mut()
1330 .unwrap()
1331 .selector
1332 .match_labels
1333 .get_or_insert_default()
1334 .insert("immutable".to_string(), "changed".to_string());
1335
1336 assert_eq!(
1337 classify_statefulset_change(¤t, &desired),
1338 StatefulSetApplyStrategy::Apply
1339 );
1340 }
1341
1342 #[test]
1343 fn test_generate_volumes_with_emptydir() {
1344 let storage = Some(KanidmStorage {
1345 empty_dir: Some(EmptyDirVolumeSource::default()),
1346 ..Default::default()
1347 });
1348 let kanidm = create_kanidm_with_storage(storage);
1349 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1350
1351 assert_eq!(volumes.clone().len(), 1);
1352 assert!(
1353 volumes
1354 .iter()
1355 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1356 );
1357 assert!(volume_claim_template.is_none());
1358 }
1359
1360 #[test]
1361 fn test_generate_volumes_with_emptydir_and_ephemeral() {
1362 let storage = Some(KanidmStorage {
1363 empty_dir: Some(EmptyDirVolumeSource::default()),
1364 ephemeral: Some(EphemeralVolumeSource::default()),
1365 ..Default::default()
1366 });
1367 let kanidm = create_kanidm_with_storage(storage);
1368 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1369
1370 assert_eq!(volumes.clone().len(), 1);
1371 assert!(
1372 volumes
1373 .iter()
1374 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1375 );
1376 assert!(volume_claim_template.is_none());
1377 }
1378
1379 #[test]
1380 fn test_generate_volumes_with_emptydir_ephemeral_and_volumeclaimtemplate() {
1381 let storage = Some(KanidmStorage {
1382 empty_dir: Some(EmptyDirVolumeSource::default()),
1383 ephemeral: Some(EphemeralVolumeSource::default()),
1384 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1385 });
1386 let kanidm = create_kanidm_with_storage(storage);
1387 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1388
1389 assert_eq!(volumes.len(), 1);
1390 assert!(
1391 volumes
1392 .iter()
1393 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1394 );
1395 assert!(volume_claim_template.is_none());
1396 }
1397
1398 #[test]
1399 fn test_generate_volumes_with_ephemeral() {
1400 let storage = Some(KanidmStorage {
1401 ephemeral: Some(EphemeralVolumeSource::default()),
1402 ..Default::default()
1403 });
1404 let kanidm = create_kanidm_with_storage(storage);
1405 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1406
1407 assert_eq!(volumes.len(), 1);
1408 assert!(
1409 volumes
1410 .iter()
1411 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
1412 );
1413 assert!(volume_claim_template.is_none());
1414 }
1415
1416 #[test]
1417 fn test_generate_volumes_with_ephemeral_and_volumeclaimtemplate() {
1418 let storage = Some(KanidmStorage {
1419 ephemeral: Some(EphemeralVolumeSource::default()),
1420 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1421 ..Default::default()
1422 });
1423 let kanidm = create_kanidm_with_storage(storage);
1424 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1425
1426 assert_eq!(volumes.len(), 1);
1427 assert!(
1428 volumes
1429 .iter()
1430 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
1431 );
1432 assert!(volume_claim_template.is_none());
1433 }
1434
1435 #[test]
1436 fn test_generate_volumes_with_volumeclaimtemplate() {
1437 let storage = Some(KanidmStorage {
1438 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1439 ..Default::default()
1440 });
1441 let kanidm = create_kanidm_with_storage(storage);
1442 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1443
1444 assert!(volumes.is_empty());
1445 assert!(volume_claim_template.is_some());
1446 }
1447
1448 #[test]
1449 fn test_generate_volumes_with_existing_volumes() {
1450 let existing_volume = Volume {
1451 name: "existing-volume".to_string(),
1452 ..Volume::default()
1453 };
1454 let kanidm = create_kanidm_with_storage(None);
1455 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![existing_volume.clone()]);
1456
1457 assert_eq!(volumes.len(), 2);
1458 assert!(volumes.clone().iter().any(|v| v.name == "existing-volume"));
1459 assert!(
1460 volumes
1461 .iter()
1462 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1463 );
1464 assert!(volume_claim_template.is_none());
1465 }
1466
1467 #[test]
1468 fn test_generate_volumes_with_multiple_existing_volumes() {
1469 let existing_volume1 = Volume {
1470 name: "existing-volume-1".to_string(),
1471 ..Volume::default()
1472 };
1473 let existing_volume2 = Volume {
1474 name: "existing-volume-2".to_string(),
1475 ..Volume::default()
1476 };
1477 let kanidm = create_kanidm_with_storage(None);
1478 let (volumes, volume_claim_template) =
1479 kanidm.expand_storage(vec![existing_volume1.clone(), existing_volume2.clone()]);
1480
1481 assert_eq!(volumes.len(), 3);
1482 assert!(
1483 volumes
1484 .clone()
1485 .iter()
1486 .any(|v| v.name == "existing-volume-1")
1487 );
1488 assert!(
1489 volumes
1490 .clone()
1491 .iter()
1492 .any(|v| v.name == "existing-volume-2")
1493 );
1494 assert!(
1495 volumes
1496 .iter()
1497 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1498 );
1499 assert!(volume_claim_template.is_none());
1500 }
1501
1502 #[test]
1503 fn statefulset_storage_class_omission_preserves_live() {
1504 let mut current = generated_statefulset();
1505 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1506 metadata: ObjectMeta {
1507 name: Some("kanidm-data".to_string()),
1508 ..Default::default()
1509 },
1510 spec: Some(PersistentVolumeClaimSpec {
1511 storage_class_name: Some("standard".to_string()),
1512 ..Default::default()
1513 }),
1514 ..Default::default()
1515 }]);
1516 let mut desired = generated_statefulset();
1517 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1518 metadata: ObjectMeta {
1519 name: Some("kanidm-data".to_string()),
1520 ..Default::default()
1521 },
1522 spec: Some(PersistentVolumeClaimSpec {
1523 storage_class_name: None,
1524 ..Default::default()
1525 }),
1526 ..Default::default()
1527 }]);
1528 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1529
1530 assert_eq!(
1532 desired
1533 .spec
1534 .as_ref()
1535 .unwrap()
1536 .volume_claim_templates
1537 .as_ref()
1538 .unwrap()[0]
1539 .spec
1540 .as_ref()
1541 .unwrap()
1542 .storage_class_name,
1543 Some("standard".to_string())
1544 );
1545 }
1546
1547 #[test]
1548 fn statefulset_storage_class_explicit_non_null_desired_is_preserved() {
1549 let mut current = generated_statefulset();
1550 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1551 metadata: ObjectMeta {
1552 name: Some("kanidm-data".to_string()),
1553 ..Default::default()
1554 },
1555 spec: Some(PersistentVolumeClaimSpec {
1556 storage_class_name: Some("old".to_string()),
1557 ..Default::default()
1558 }),
1559 ..Default::default()
1560 }]);
1561 let mut desired = generated_statefulset();
1562 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1563 metadata: ObjectMeta {
1564 name: Some("kanidm-data".to_string()),
1565 ..Default::default()
1566 },
1567 spec: Some(PersistentVolumeClaimSpec {
1568 storage_class_name: Some("new".to_string()),
1569 ..Default::default()
1570 }),
1571 ..Default::default()
1572 }]);
1573 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1575
1576 assert_eq!(
1578 desired
1579 .spec
1580 .as_ref()
1581 .unwrap()
1582 .volume_claim_templates
1583 .as_ref()
1584 .unwrap()[0]
1585 .spec
1586 .as_ref()
1587 .unwrap()
1588 .storage_class_name,
1589 Some("new".to_string())
1590 );
1591 }
1592}
1593
1594#[cfg(all(test, feature = "integration-test"))]
1595mod integration_test {
1596 use super::{REPLICATION_CONFIG_IMAGE, REPLICATION_CONFIG_SCRIPT};
1597
1598 use std::fs;
1599 use std::path::Path;
1600
1601 use tempfile::tempdir;
1602 use testcontainers::ContainerRequest;
1603 use testcontainers::GenericImage;
1604 use testcontainers::ImageExt;
1605 use testcontainers::core::Mount;
1606 use testcontainers::runners::AsyncRunner;
1607 use tokio::io::{AsyncBufReadExt, BufReader};
1608
1609 struct TestCase<'a> {
1610 env_vars: Vec<(&'a str, &'a str)>,
1611 expected_result: &'a str,
1612 }
1613
1614 async fn run_test_case(
1615 image_parts: &[&str],
1616 cmd: &[&str],
1617 tmp_dir_path: &str,
1618 env_vars: &[(&str, &str)],
1619 expected_result: &str,
1620 ) {
1621 let container = GenericImage::new(image_parts[0], image_parts[1]);
1622 let mut container_request: ContainerRequest<GenericImage> = container.clone().into();
1623
1624 for (key, value) in env_vars {
1625 container_request =
1626 container_request.with_env_var((*key).to_string(), (*value).to_string());
1627 }
1628
1629 let container = container_request
1630 .with_cmd(cmd.iter().map(|&s| s.to_string()))
1631 .with_mount(Mount::bind_mount(tmp_dir_path.to_string(), "/tmp"))
1632 .with_user(nix::unistd::getuid().to_string())
1633 .start()
1634 .await
1635 .unwrap();
1636
1637 let stdout = container.stdout(true);
1638 let mut stdout_reader = BufReader::new(stdout).lines();
1639 let mut stdout_lines = Vec::new();
1640 while let Some(l) = stdout_reader.next_line().await.unwrap() {
1641 stdout_lines.push(l);
1642 }
1643 dbg!(stdout_lines.join("\n"));
1644
1645 let stderr = container.stderr(true);
1646 let mut stderr_reader = BufReader::new(stderr).lines();
1647 let mut stderr_lines = Vec::new();
1648 while let Some(l) = stderr_reader.next_line().await.unwrap() {
1649 stderr_lines.push(l);
1650 }
1651 dbg!(stderr_lines.join("\n"));
1652
1653 let server_toml_path = Path::new(tmp_dir_path).join("server.toml");
1654 let content = fs::read_to_string(server_toml_path).expect("Unable to read server.toml");
1655 assert_eq!(content, expected_result);
1656 }
1657
1658 #[tokio::test]
1659 async fn test_replication_config_generation() {
1660 let image_parts = REPLICATION_CONFIG_IMAGE.split(':').collect::<Vec<&str>>();
1661 let cmd = ["--script", REPLICATION_CONFIG_SCRIPT];
1662 let tmp_dir = tempdir().unwrap();
1663 let tmp_dir_path = tmp_dir.path().to_str().unwrap().to_string();
1664
1665 let test_cases = vec![
1666 TestCase {
1667 env_vars: vec![
1668 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1669 ("REPLICATION_PORT", "8444"),
1670 ("BIND_ADDRESS", "0.0.0.0"),
1671 ("KANIDM_NAME", "kanidm-test"),
1672 ("POD_NAME", "kanidm-test-default-0"),
1673 ("KANIOP_REPLICATION_ENABLED", "true"),
1674 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1675 (
1676 "KANIDM_TEST_DEFAULT_0_HOST",
1677 "kanidm-test-default-0.kanidm-test",
1678 ),
1679 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1680 (
1681 "KANIDM_TEST_DEFAULT_1_HOST",
1682 "kanidm-test-default-1.kanidm-test",
1683 ),
1684 ],
1685 expected_result: r#"version = "2"
1686
1687[replication]
1688origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1689bindaddress = "0.0.0.0:8444"
1690
1691"#,
1692 },
1693 TestCase {
1694 env_vars: vec![
1695 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1696 ("REPLICATION_PORT", "8444"),
1697 ("BIND_ADDRESS", "0.0.0.0"),
1698 ("KANIDM_NAME", "kanidm-test"),
1699 ("POD_NAME", "kanidm-test-default-0"),
1700 ("KANIOP_REPLICATION_ENABLED", "true"),
1701 (
1702 "EXTERNAL_REPLICATION_NODE_HOST_0",
1703 "repl://external-host-0:8444",
1704 ),
1705 (
1706 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1707 "dummy-cert-external-host-0",
1708 ),
1709 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1710 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1711 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1712 (
1713 "KANIDM_TEST_DEFAULT_0_HOST",
1714 "kanidm-test-default-0.kanidm-test",
1715 ),
1716 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1717 (
1718 "KANIDM_TEST_DEFAULT_1_HOST",
1719 "kanidm-test-default-1.kanidm-test",
1720 ),
1721 ],
1722 expected_result: r#"version = "2"
1723
1724[replication]
1725origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1726bindaddress = "0.0.0.0:8444"
1727
1728[replication."repl://external-host-0:8444"]
1729type = "mutual-pull"
1730partner_cert = "dummy-cert-external-host-0"
1731automatic_refresh = true
1732
1733"#,
1734 },
1735 TestCase {
1736 env_vars: vec![
1737 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1738 ("REPLICATION_PORT", "8444"),
1739 ("BIND_ADDRESS", "0.0.0.0"),
1740 ("KANIDM_NAME", "kanidm-test"),
1741 ("POD_NAME", "kanidm-test-default-0"),
1742 ("KANIOP_REPLICATION_ENABLED", "true"),
1743 (
1744 "EXTERNAL_REPLICATION_NODE_HOST_0",
1745 "repl://external-host-0:8444",
1746 ),
1747 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1748 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1749 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1750 (
1751 "KANIDM_TEST_DEFAULT_0_HOST",
1752 "kanidm-test-default-0.kanidm-test",
1753 ),
1754 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1755 (
1756 "KANIDM_TEST_DEFAULT_1_HOST",
1757 "kanidm-test-default-1.kanidm-test",
1758 ),
1759 ],
1760 expected_result: r#"version = "2"
1761
1762[replication]
1763origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1764bindaddress = "0.0.0.0:8444"
1765
1766"#,
1767 },
1768 TestCase {
1769 env_vars: vec![
1770 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1771 ("REPLICATION_PORT", "8444"),
1772 ("BIND_ADDRESS", "0.0.0.0"),
1773 ("KANIDM_NAME", "kanidm-test"),
1774 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1775 ("POD_NAME", "kanidm-test-default-0"),
1776 ("KANIOP_REPLICATION_ENABLED", "true"),
1777 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1778 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1779 (
1780 "KANIDM_TEST_DEFAULT_0_HOST",
1781 "kanidm-test-default-0.kanidm-test",
1782 ),
1783 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1784 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1785 (
1786 "KANIDM_TEST_DEFAULT_1_HOST",
1787 "kanidm-test-default-1.kanidm-test",
1788 ),
1789 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1790 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1791 (
1792 "KANIDM_TEST_DEFAULT_3_HOST",
1793 "kanidm-test-default-3.kanidm-test",
1794 ),
1795 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1796 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1797 (
1798 "KANIDM_TEST_READ_REPLICA_0_HOST",
1799 "kanidm-test-read-replica-0.kanidm-test",
1800 ),
1801 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1802 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1803 (
1804 "KANIDM_TEST_READ_REPLICA_1_HOST",
1805 "kanidm-test-read-replica-1.kanidm-test",
1806 ),
1807 ],
1808 expected_result: r#"version = "2"
1809
1810[replication]
1811origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1812bindaddress = "0.0.0.0:8444"
1813
1814[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1815type = "mutual-pull"
1816partner_cert = "dummy-cert-default-1"
1817automatic_refresh = false
1818
1819[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1820type = "mutual-pull"
1821partner_cert = "dummy-cert-default-3"
1822automatic_refresh = false
1823
1824[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1825type = "allow-pull"
1826consumer_cert = "dummy-cert-read-replica-0"
1827
1828[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1829type = "allow-pull"
1830consumer_cert = "dummy-cert-read-replica-1"
1831
1832"#,
1833 },
1834 TestCase {
1835 env_vars: vec![
1836 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1837 ("REPLICATION_PORT", "8444"),
1838 ("BIND_ADDRESS", "0.0.0.0"),
1839 ("KANIDM_NAME", "kanidm-test"),
1840 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1841 ("POD_NAME", "kanidm-test-default-1"),
1842 ("KANIOP_REPLICATION_ENABLED", "true"),
1843 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1844 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1845 (
1846 "KANIDM_TEST_DEFAULT_0_HOST",
1847 "kanidm-test-default-0.kanidm-test",
1848 ),
1849 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1850 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1851 (
1852 "KANIDM_TEST_DEFAULT_1_HOST",
1853 "kanidm-test-default-1.kanidm-test",
1854 ),
1855 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1856 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1857 (
1858 "KANIDM_TEST_DEFAULT_3_HOST",
1859 "kanidm-test-default-3.kanidm-test",
1860 ),
1861 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1862 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1863 (
1864 "KANIDM_TEST_READ_REPLICA_0_HOST",
1865 "kanidm-test-read-replica-0.kanidm-test",
1866 ),
1867 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1868 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1869 (
1870 "KANIDM_TEST_READ_REPLICA_1_HOST",
1871 "kanidm-test-read-replica-1.kanidm-test",
1872 ),
1873 ],
1874 expected_result: r#"version = "2"
1875
1876[replication]
1877origin = "repl://kanidm-test-default-1.kanidm-test:8444"
1878bindaddress = "0.0.0.0:8444"
1879
1880[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1881type = "mutual-pull"
1882partner_cert = "dummy-cert-default-0"
1883automatic_refresh = true
1884
1885[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1886type = "mutual-pull"
1887partner_cert = "dummy-cert-default-3"
1888automatic_refresh = false
1889
1890[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1891type = "allow-pull"
1892consumer_cert = "dummy-cert-read-replica-0"
1893
1894[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1895type = "allow-pull"
1896consumer_cert = "dummy-cert-read-replica-1"
1897
1898"#,
1899 },
1900 TestCase {
1901 env_vars: vec![
1902 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1903 ("REPLICATION_PORT", "8444"),
1904 ("BIND_ADDRESS", "0.0.0.0"),
1905 ("KANIDM_NAME", "kanidm-test"),
1906 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1907 ("POD_NAME", "kanidm-test-default-3"),
1908 ("KANIOP_REPLICATION_ENABLED", "true"),
1909 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1910 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1911 (
1912 "KANIDM_TEST_DEFAULT_0_HOST",
1913 "kanidm-test-default-0.kanidm-test",
1914 ),
1915 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1916 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1917 (
1918 "KANIDM_TEST_DEFAULT_1_HOST",
1919 "kanidm-test-default-1.kanidm-test",
1920 ),
1921 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1922 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1923 (
1924 "KANIDM_TEST_DEFAULT_3_HOST",
1925 "kanidm-test-default-3.kanidm-test",
1926 ),
1927 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1928 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1929 (
1930 "KANIDM_TEST_READ_REPLICA_0_HOST",
1931 "kanidm-test-read-replica-0.kanidm-test",
1932 ),
1933 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1934 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1935 (
1936 "KANIDM_TEST_READ_REPLICA_1_HOST",
1937 "kanidm-test-read-replica-1.kanidm-test",
1938 ),
1939 ],
1940 expected_result: r#"version = "2"
1941
1942[replication]
1943origin = "repl://kanidm-test-default-3.kanidm-test:8444"
1944bindaddress = "0.0.0.0:8444"
1945
1946[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1947type = "mutual-pull"
1948partner_cert = "dummy-cert-default-0"
1949automatic_refresh = true
1950
1951[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1952type = "mutual-pull"
1953partner_cert = "dummy-cert-default-1"
1954automatic_refresh = false
1955
1956[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1957type = "allow-pull"
1958consumer_cert = "dummy-cert-read-replica-0"
1959
1960[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1961type = "allow-pull"
1962consumer_cert = "dummy-cert-read-replica-1"
1963
1964"#,
1965 },
1966 TestCase {
1967 env_vars: vec![
1968 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1969 ("REPLICATION_PORT", "8444"),
1970 ("BIND_ADDRESS", "0.0.0.0"),
1971 ("KANIDM_NAME", "kanidm-test"),
1972 ("REPLICA_GROUP", "read-replica"),
1973 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1974 ("POD_NAME", "kanidm-test-read-replica-0"),
1975 ("KANIOP_REPLICATION_ENABLED", "true"),
1976 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1977 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1978 (
1979 "KANIDM_TEST_DEFAULT_0_HOST",
1980 "kanidm-test-default-0.kanidm-test",
1981 ),
1982 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1983 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1984 (
1985 "KANIDM_TEST_DEFAULT_1_HOST",
1986 "kanidm-test-default-1.kanidm-test",
1987 ),
1988 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1989 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1990 (
1991 "KANIDM_TEST_DEFAULT_3_HOST",
1992 "kanidm-test-default-3.kanidm-test",
1993 ),
1994 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1995 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1996 (
1997 "KANIDM_TEST_READ_REPLICA_0_HOST",
1998 "kanidm-test-read-replica-0.kanidm-test",
1999 ),
2000 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2001 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
2002 (
2003 "KANIDM_TEST_READ_REPLICA_1_HOST",
2004 "kanidm-test-read-replica-1.kanidm-test",
2005 ),
2006 ],
2007 expected_result: r#"version = "2"
2008
2009[replication]
2010origin = "repl://kanidm-test-read-replica-0.kanidm-test:8444"
2011bindaddress = "0.0.0.0:8444"
2012
2013[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
2014type = "pull"
2015supplier_cert = "dummy-cert-default-0"
2016automatic_refresh = true
2017
2018[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
2019type = "pull"
2020supplier_cert = "dummy-cert-default-1"
2021automatic_refresh = false
2022
2023[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
2024type = "pull"
2025supplier_cert = "dummy-cert-default-3"
2026automatic_refresh = false
2027
2028"#,
2029 },
2030 TestCase {
2031 env_vars: vec![
2032 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2033 ("REPLICATION_PORT", "8444"),
2034 ("BIND_ADDRESS", "0.0.0.0"),
2035 ("KANIDM_NAME", "kanidm-test"),
2036 ("REPLICA_GROUP", "read-replica"),
2037 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
2038 ("POD_NAME", "kanidm-test-read-replica-1"),
2039 ("KANIOP_REPLICATION_ENABLED", "true"),
2040 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2041 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
2042 (
2043 "KANIDM_TEST_DEFAULT_0_HOST",
2044 "kanidm-test-default-0.kanidm-test",
2045 ),
2046 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2047 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
2048 (
2049 "KANIDM_TEST_DEFAULT_1_HOST",
2050 "kanidm-test-default-1.kanidm-test",
2051 ),
2052 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2053 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
2054 (
2055 "KANIDM_TEST_DEFAULT_3_HOST",
2056 "kanidm-test-default-3.kanidm-test",
2057 ),
2058 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2059 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
2060 (
2061 "KANIDM_TEST_READ_REPLICA_0_HOST",
2062 "kanidm-test-read-replica-0.kanidm-test",
2063 ),
2064 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2065 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
2066 (
2067 "KANIDM_TEST_READ_REPLICA_1_HOST",
2068 "kanidm-test-read-replica-1.kanidm-test",
2069 ),
2070 ],
2071 expected_result: r#"version = "2"
2072
2073[replication]
2074origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
2075bindaddress = "0.0.0.0:8444"
2076
2077[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
2078type = "pull"
2079supplier_cert = "dummy-cert-default-0"
2080automatic_refresh = true
2081
2082[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
2083type = "pull"
2084supplier_cert = "dummy-cert-default-1"
2085automatic_refresh = false
2086
2087[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
2088type = "pull"
2089supplier_cert = "dummy-cert-default-3"
2090automatic_refresh = false
2091
2092"#,
2093 },
2094 TestCase {
2095 env_vars: vec![
2096 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2097 ("REPLICATION_PORT", "8444"),
2098 ("BIND_ADDRESS", "0.0.0.0"),
2099 ("KANIDM_NAME", "kanidm-test"),
2100 ("REPLICA_GROUP", "read-replica"),
2101 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
2102 ("POD_NAME", "kanidm-test-read-replica-1"),
2103 (
2104 "EXTERNAL_REPLICATION_NODE_HOST_0",
2105 "repl://external-host-0:8444",
2106 ),
2107 (
2108 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
2109 "dummy-cert-external-host-0",
2110 ),
2111 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
2112 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
2113 ("KANIOP_REPLICATION_ENABLED", "true"),
2114 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2115 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
2116 (
2117 "KANIDM_TEST_DEFAULT_0_HOST",
2118 "kanidm-test-default-0.kanidm-test",
2119 ),
2120 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2121 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
2122 (
2123 "KANIDM_TEST_DEFAULT_1_HOST",
2124 "kanidm-test-default-1.kanidm-test",
2125 ),
2126 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2127 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
2128 (
2129 "KANIDM_TEST_DEFAULT_3_HOST",
2130 "kanidm-test-default-3.kanidm-test",
2131 ),
2132 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2133 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
2134 (
2135 "KANIDM_TEST_READ_REPLICA_0_HOST",
2136 "kanidm-test-read-replica-0.kanidm-test",
2137 ),
2138 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2139 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
2140 (
2141 "KANIDM_TEST_READ_REPLICA_1_HOST",
2142 "kanidm-test-read-replica-1.kanidm-test",
2143 ),
2144 ],
2145 expected_result: r#"version = "2"
2146
2147[replication]
2148origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
2149bindaddress = "0.0.0.0:8444"
2150
2151[replication."repl://external-host-0:8444"]
2152type = "mutual-pull"
2153partner_cert = "dummy-cert-external-host-0"
2154automatic_refresh = true
2155
2156[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
2157type = "pull"
2158supplier_cert = "dummy-cert-default-0"
2159automatic_refresh = true
2160
2161[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
2162type = "pull"
2163supplier_cert = "dummy-cert-default-1"
2164automatic_refresh = false
2165
2166[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
2167type = "pull"
2168supplier_cert = "dummy-cert-default-3"
2169automatic_refresh = false
2170
2171"#,
2172 },
2173 TestCase {
2174 env_vars: vec![
2175 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2176 ("REPLICATION_PORT", "8444"),
2177 ("BIND_ADDRESS", "0.0.0.0"),
2178 ("KANIDM_NAME", "kanidm-test"),
2179 ("POD_NAME", "kanidm-test-default-0"),
2180 ("KANIOP_REPLICATION_ENABLED", "true"),
2181 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2182 ("KANIDM_TEST_DEFAULT_0_HOST", "10.200.20.1"),
2183 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
2184 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2185 ("KANIDM_TEST_DEFAULT_1_HOST", "10.200.20.2"),
2186 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
2187 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2188 ("KANIDM_TEST_DEFAULT_3_HOST", "10.200.20.4"),
2189 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
2190 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2191 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
2192 (
2193 "KANIDM_TEST_READ_REPLICA_0_HOST",
2194 "kanidm-test-read-replica-0.kanidm-test",
2195 ),
2196 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2197 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
2198 (
2199 "KANIDM_TEST_READ_REPLICA_1_HOST",
2200 "kanidm-test-read-replica-1.kanidm-test",
2201 ),
2202 ],
2203 expected_result: r#"version = "2"
2204
2205[replication]
2206origin = "repl://10.200.20.1:8444"
2207bindaddress = "0.0.0.0:8444"
2208
2209[replication."repl://10.200.20.2:8444"]
2210type = "mutual-pull"
2211partner_cert = "dummy-cert-default-1"
2212automatic_refresh = false
2213
2214[replication."repl://10.200.20.4:8444"]
2215type = "mutual-pull"
2216partner_cert = "dummy-cert-default-3"
2217automatic_refresh = false
2218
2219[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
2220type = "allow-pull"
2221consumer_cert = "dummy-cert-read-replica-0"
2222
2223[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
2224type = "allow-pull"
2225consumer_cert = "dummy-cert-read-replica-1"
2226
2227"#,
2228 },
2229 ];
2230
2231 for test_case in test_cases {
2232 run_test_case(
2233 &image_parts,
2234 &cmd,
2235 &tmp_dir_path,
2236 &test_case.env_vars,
2237 test_case.expected_result,
2238 )
2239 .await;
2240 }
2241 }
2242
2243 #[test]
2244 fn backup_enables_generated_config_and_native_online_backup_stanza() {
2245 use crate::kanidm::crd::{KanidmStorage, PersistentVolumeClaimTemplate};
2246 use k8s_openapi::api::core::v1::PersistentVolumeClaimSpec;
2247
2248 use crate::kanidm::reconcile::transport::BackupConfig;
2249
2250 use super::StatefulSetExt;
2251
2252 let (mut kanidm, mut replica_group) = super::tests::create_kanidm_with_replica_group();
2253 replica_group.primary_node = true;
2254 kanidm.spec.replica_groups = vec![replica_group.clone()];
2255 let backup_config = BackupConfig {
2256 schedule: "0 2 * * *".to_string(),
2257 local_versions: 7,
2258 transport: None,
2259 };
2260 kanidm.spec.storage = Some(KanidmStorage {
2261 volume_claim_template: Some(PersistentVolumeClaimTemplate {
2262 metadata: None,
2263 spec: Some(PersistentVolumeClaimSpec::default()),
2264 }),
2265 ..Default::default()
2266 });
2267
2268 let sts = kanidm
2269 .create_statefulset(&replica_group, None, Some(&backup_config))
2270 .unwrap();
2271 let pod = sts.spec.unwrap().template.spec.unwrap();
2272 let init = pod
2273 .init_containers
2274 .unwrap()
2275 .into_iter()
2276 .find(|c| c.name == "kanidm-generate-replication-config")
2277 .unwrap();
2278 let env = init.env.unwrap();
2279 assert!(
2280 env.iter()
2281 .any(|e| e.name == "KANIOP_BACKUP_ENABLED" && e.value.as_deref() == Some("true"))
2282 );
2283 assert!(
2284 env.iter()
2285 .any(|e| e.name == "KANIOP_BACKUP_SCHEDULE"
2286 && e.value.as_deref() == Some("0 2 * * *"))
2287 );
2288 assert!(
2289 env.iter()
2290 .any(|e| e.name == "KANIOP_BACKUP_VERSIONS" && e.value.as_deref() == Some("7"))
2291 );
2292 let script = init.args.unwrap().join("\n");
2293 assert!(script.contains("[online_backup]"));
2294 assert!(script.contains("env.POD_NAME == primary_node"));
2295 }
2296
2297 #[test]
2298 fn transport_sidecar_is_native_sidecar_for_primary_group_with_config() {
2299 use super::StatefulSetExt;
2300 use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2301 use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2302
2303 use super::tests::create_kanidm_with_replica_group;
2304 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2305 replica_group.primary_node = true;
2306 kanidm.spec.replica_groups = vec![replica_group.clone()];
2307
2308 let config = BackupConfig {
2309 schedule: "0 2 * * *".to_string(),
2310 local_versions: 7,
2311 transport: Some(TransportSidecarConfig {
2312 operation_doc_json: r#"{"operation":"transport","bucket":"test"}"#.to_string(),
2313 auth_method: AuthMethod {
2314 workload_identity: None,
2315 secret_ref: Some(SecretRef {
2316 name: "writer-secret".to_string(),
2317 }),
2318 },
2319 ca_bundle_ref: None,
2320 encryption_key_ref: None,
2321 }),
2322 };
2323
2324 let sts = kanidm
2325 .create_statefulset(&replica_group, None, Some(&config))
2326 .unwrap();
2327 let pod = sts.spec.unwrap().template.spec.unwrap();
2328 assert!(
2329 pod.containers
2330 .iter()
2331 .all(|c| c.name != "data-mover-transport")
2332 );
2333 let sidecar = pod
2334 .init_containers
2335 .as_ref()
2336 .unwrap()
2337 .iter()
2338 .find(|c| c.name == "data-mover-transport")
2339 .expect("transport native sidecar should be present");
2340 assert_eq!(sidecar.restart_policy.as_deref(), Some("Always"));
2341 assert!(sidecar.readiness_probe.is_none());
2342 assert_eq!(
2343 sidecar.image.as_deref(),
2344 Some("ghcr.io/pando85/kaniop-data-mover:latest")
2345 );
2346 assert_eq!(
2347 sidecar.command.as_ref().unwrap(),
2348 &vec!["/bin/kaniop-data-mover".to_string()]
2349 );
2350 assert_eq!(
2351 sidecar.args.as_ref().unwrap(),
2352 &vec![
2353 "transport".to_string(),
2354 "--operation-doc".to_string(),
2355 r#"{"operation":"transport","bucket":"test"}"#.to_string(),
2356 ]
2357 );
2358
2359 let env = sidecar.env.as_ref().unwrap();
2360 assert!(env.iter().any(|e| e.name == "POD_NAME"));
2361 assert!(env.iter().any(|e| e.name == "KANIDM_PRIMARY_NODE"));
2362 assert!(env.iter().any(|e| e.name == "AWS_ACCESS_KEY_ID"));
2363
2364 let mounts = sidecar.volume_mounts.as_ref().unwrap();
2365 assert!(
2366 mounts
2367 .iter()
2368 .any(|m| m.name == "kanidm-data" && m.read_only == Some(true))
2369 );
2370 assert!(
2371 mounts
2372 .iter()
2373 .any(|m| m.name == "kanidm-tmp" && m.mount_path == "/tmp")
2374 );
2375
2376 let volumes = pod.volumes.as_ref().unwrap();
2377 assert!(volumes.iter().any(|v| v.name == "kanidm-tmp"));
2378
2379 let sc = sidecar.security_context.as_ref().unwrap();
2380 assert_eq!(sc.run_as_non_root, Some(true));
2381 assert_eq!(sc.allow_privilege_escalation, Some(false));
2382 assert_eq!(sc.read_only_root_filesystem, Some(true));
2383 assert!(sc.run_as_user.is_none());
2384 assert!(
2385 sc.capabilities
2386 .as_ref()
2387 .unwrap()
2388 .drop
2389 .as_ref()
2390 .unwrap()
2391 .contains(&"ALL".to_string())
2392 );
2393 }
2394
2395 #[test]
2396 fn transport_sidecar_absent_for_non_primary_group() {
2397 use super::StatefulSetExt;
2398 use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2399 use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2400
2401 use super::tests::create_kanidm_with_replica_group;
2402 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2403 replica_group.primary_node = false;
2404 kanidm.spec.replica_groups = vec![replica_group.clone()];
2405
2406 let config = BackupConfig {
2407 schedule: "0 2 * * *".to_string(),
2408 local_versions: 7,
2409 transport: Some(TransportSidecarConfig {
2410 operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2411 auth_method: AuthMethod {
2412 workload_identity: None,
2413 secret_ref: Some(SecretRef {
2414 name: "writer-secret".to_string(),
2415 }),
2416 },
2417 ca_bundle_ref: None,
2418 encryption_key_ref: None,
2419 }),
2420 };
2421
2422 let sts = kanidm
2423 .create_statefulset(&replica_group, None, Some(&config))
2424 .unwrap();
2425 let pod = sts.spec.unwrap().template.spec.unwrap();
2426 assert!(
2427 pod.containers
2428 .iter()
2429 .all(|c| c.name != "data-mover-transport")
2430 );
2431 assert!(
2432 pod.init_containers
2433 .as_ref()
2434 .is_none_or(|containers| containers
2435 .iter()
2436 .all(|c| c.name != "data-mover-transport"))
2437 );
2438 }
2439
2440 #[test]
2441 fn transport_sidecar_absent_without_config() {
2442 use super::StatefulSetExt;
2443 use super::tests::create_kanidm_with_replica_group;
2444 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2445 replica_group.primary_node = true;
2446 kanidm.spec.replica_groups = vec![replica_group.clone()];
2447
2448 let sts = kanidm
2449 .create_statefulset(&replica_group, None, None)
2450 .unwrap();
2451 let pod = sts.spec.unwrap().template.spec.unwrap();
2452 assert!(
2453 pod.containers
2454 .iter()
2455 .all(|c| c.name != "data-mover-transport")
2456 );
2457 assert!(
2458 pod.init_containers
2459 .as_ref()
2460 .is_none_or(|containers| containers
2461 .iter()
2462 .all(|c| c.name != "data-mover-transport"))
2463 );
2464 }
2465
2466 #[test]
2467 fn transport_sidecar_with_ca_bundle() {
2468 use super::StatefulSetExt;
2469 use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2470 use kaniop_backup_core::crd::{AuthMethod, CaBundleRef, SecretRef};
2471
2472 use super::tests::create_kanidm_with_replica_group;
2473 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2474 replica_group.primary_node = true;
2475 kanidm.spec.replica_groups = vec![replica_group.clone()];
2476
2477 let config = BackupConfig {
2478 schedule: "0 2 * * *".to_string(),
2479 local_versions: 7,
2480 transport: Some(TransportSidecarConfig {
2481 operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2482 auth_method: AuthMethod {
2483 workload_identity: None,
2484 secret_ref: Some(SecretRef {
2485 name: "writer-secret".to_string(),
2486 }),
2487 },
2488 ca_bundle_ref: Some(CaBundleRef {
2489 name: "ca-config-map".to_string(),
2490 key: "ca.crt".to_string(),
2491 }),
2492 encryption_key_ref: None,
2493 }),
2494 };
2495
2496 let sts = kanidm
2497 .create_statefulset(&replica_group, None, Some(&config))
2498 .unwrap();
2499 let pod = sts.spec.unwrap().template.spec.unwrap();
2500
2501 let sidecar = pod
2502 .init_containers
2503 .as_ref()
2504 .unwrap()
2505 .iter()
2506 .find(|c| c.name == "data-mover-transport")
2507 .unwrap();
2508 let env = sidecar.env.as_ref().unwrap();
2509 assert!(env.iter().any(|e| e.name == "SSL_CERT_FILE"));
2510
2511 let mounts = sidecar.volume_mounts.as_ref().unwrap();
2512 assert!(mounts.iter().any(|m| m.name == "ca-bundle"));
2513
2514 let volumes = pod.volumes.as_ref().unwrap();
2515 let ca_volume = volumes.iter().find(|v| v.name == "ca-bundle").unwrap();
2516 let config_map = ca_volume.config_map.as_ref().unwrap();
2517 assert_eq!(config_map.name, "ca-config-map");
2518 assert_eq!(config_map.items.as_ref().unwrap()[0].key, "ca.crt");
2519 }
2520
2521 #[test]
2522 fn transport_sidecar_includes_encryption_key_env_when_key_ref_set() {
2523 use super::StatefulSetExt;
2524 use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2525 use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2526
2527 use super::tests::create_kanidm_with_replica_group;
2528 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2529 replica_group.primary_node = true;
2530 kanidm.spec.replica_groups = vec![replica_group.clone()];
2531
2532 let config = BackupConfig {
2533 schedule: "0 2 * * *".to_string(),
2534 local_versions: 7,
2535 transport: Some(TransportSidecarConfig {
2536 operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2537 auth_method: AuthMethod {
2538 workload_identity: None,
2539 secret_ref: Some(SecretRef {
2540 name: "writer-secret".to_string(),
2541 }),
2542 },
2543 ca_bundle_ref: None,
2544 encryption_key_ref: Some(SecretRef {
2545 name: "kek-secret".to_string(),
2546 }),
2547 }),
2548 };
2549
2550 let sts = kanidm
2551 .create_statefulset(&replica_group, None, Some(&config))
2552 .unwrap();
2553 let pod = sts.spec.unwrap().template.spec.unwrap();
2554
2555 let sidecar = pod
2556 .init_containers
2557 .as_ref()
2558 .unwrap()
2559 .iter()
2560 .find(|c| c.name == "data-mover-transport")
2561 .unwrap();
2562 let env = sidecar.env.as_ref().unwrap();
2563 let enc_env = env.iter().find(|e| e.name == "KANIOP_ENCRYPTION_KEY");
2564 assert!(
2565 enc_env.is_some(),
2566 "KANIOP_ENCRYPTION_KEY env var must be present"
2567 );
2568 let enc_env = enc_env.unwrap();
2569 let secret_ref = enc_env
2570 .value_from
2571 .as_ref()
2572 .unwrap()
2573 .secret_key_ref
2574 .as_ref()
2575 .unwrap();
2576 assert_eq!(secret_ref.name, "kek-secret");
2577 assert_eq!(secret_ref.key, "encryption-key");
2578 }
2579
2580 #[test]
2581 fn transport_sidecar_omits_encryption_key_env_when_no_key_ref() {
2582 use super::StatefulSetExt;
2583 use crate::kanidm::reconcile::transport::{BackupConfig, TransportSidecarConfig};
2584 use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2585
2586 use super::tests::create_kanidm_with_replica_group;
2587 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2588 replica_group.primary_node = true;
2589 kanidm.spec.replica_groups = vec![replica_group.clone()];
2590
2591 let config = BackupConfig {
2592 schedule: "0 2 * * *".to_string(),
2593 local_versions: 7,
2594 transport: Some(TransportSidecarConfig {
2595 operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2596 auth_method: AuthMethod {
2597 workload_identity: None,
2598 secret_ref: Some(SecretRef {
2599 name: "writer-secret".to_string(),
2600 }),
2601 },
2602 ca_bundle_ref: None,
2603 encryption_key_ref: None,
2604 }),
2605 };
2606
2607 let sts = kanidm
2608 .create_statefulset(&replica_group, None, Some(&config))
2609 .unwrap();
2610 let pod = sts.spec.unwrap().template.spec.unwrap();
2611
2612 let sidecar = pod
2613 .init_containers
2614 .as_ref()
2615 .unwrap()
2616 .iter()
2617 .find(|c| c.name == "data-mover-transport")
2618 .unwrap();
2619 let env = sidecar.env.as_ref().unwrap();
2620 assert!(
2621 !env.iter().any(|e| e.name == "KANIOP_ENCRYPTION_KEY"),
2622 "KANIOP_ENCRYPTION_KEY must be absent when key_ref is None"
2623 );
2624 }
2625}