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