1use kaniop_backup_core::crd::{
2 AuthMethod, CaBundleRef, EncryptionKeyRef, KanidmBackupRepository, KanidmBackupSchedule,
3};
4use kube::ResourceExt;
5use tracing::debug;
6
7use crate::kanidm::crd::Kanidm;
8use crate::kanidm::restore::RESTORE_ANNOTATION;
9
10pub const TRANSPORT_SIDECAR_NAME: &str = "data-mover-transport";
11
12#[derive(Debug, Clone)]
13pub struct TransportSidecarConfig {
14 pub operation_doc_json: String,
15 pub auth_method: AuthMethod,
16 pub ca_bundle_ref: Option<CaBundleRef>,
17 pub encryption_key_ref: Option<EncryptionKeyRef>,
18}
19
20#[derive(Debug, Clone)]
21pub struct BackupConfig {
22 pub schedule: String,
23 pub local_versions: u32,
24 pub transport: Option<TransportSidecarConfig>,
25}
26
27pub fn backup_target_validation_error(kanidm: &Kanidm) -> Option<String> {
28 let pvc_backed = kanidm.spec.storage.as_ref().is_some_and(|storage| {
29 storage.volume_claim_template.is_some()
30 && storage.empty_dir.is_none()
31 && storage.ephemeral.is_none()
32 });
33 if !pvc_backed {
34 return Some("backup requires PVC-backed storage".to_string());
35 }
36
37 let primary_count = kanidm
38 .spec
39 .replica_groups
40 .iter()
41 .filter(|group| group.primary_node)
42 .count();
43 if primary_count != 1 {
44 return Some(format!(
45 "backup requires exactly one primary replica group; found {primary_count}"
46 ));
47 }
48
49 None
50}
51
52pub fn resolve_backup_config(
53 kanidm: &Kanidm,
54 schedules: &[KanidmBackupSchedule],
55 repositories: &[KanidmBackupRepository],
56) -> Option<BackupConfig> {
57 let kanidm_name = kanidm.name_any();
58 let matching_schedules: Vec<_> = schedules
59 .iter()
60 .filter(|schedule| schedule.spec.kanidm_ref.name == kanidm_name)
61 .collect();
62
63 if matching_schedules.len() != 1 {
64 if matching_schedules.len() > 1 {
65 debug!(
66 kanidm = %kanidm_name,
67 schedules = matching_schedules.len(),
68 "multiple KanidmBackupSchedules target Kanidm; backup configuration is disabled"
69 );
70 }
71 return None;
72 }
73
74 let schedule = matching_schedules[0];
75 if schedule.spec.suspend || kanidm.annotations().contains_key(RESTORE_ANNOTATION) {
76 return None;
77 }
78
79 if let Some(reason) = backup_target_validation_error(kanidm) {
80 debug!(kanidm = %kanidm_name, %reason, "invalid Kanidm backup target");
81 return None;
82 }
83
84 Some(BackupConfig {
85 schedule: schedule.spec.schedule.clone(),
86 local_versions: schedule.spec.local_versions,
87 transport: resolve_transport_sidecar_config(kanidm, schedule, repositories),
88 })
89}
90
91fn resolve_transport_sidecar_config(
92 kanidm: &Kanidm,
93 schedule: &KanidmBackupSchedule,
94 repositories: &[KanidmBackupRepository],
95) -> Option<TransportSidecarConfig> {
96 let kanidm_name = kanidm.name_any();
97 if kanidm.status.is_none() {
98 debug!(
99 kanidm = %kanidm_name,
100 "Kanidm status not yet populated, deferring transport sidecar injection"
101 );
102 return None;
103 }
104
105 let kanidm_version = kanidm
106 .status
107 .as_ref()
108 .and_then(|status| status.version.as_ref())
109 .map(|version| version.image_tag.clone())
110 .unwrap_or_default();
111 if kanidm_version.is_empty() {
112 debug!(
113 kanidm = %kanidm_name,
114 "Kanidm version not yet populated, deferring transport sidecar injection"
115 );
116 return None;
117 }
118
119 let repo_name = &schedule.spec.repository_ref.name;
120 let repository = repositories
121 .iter()
122 .find(|repo| repo.name_any() == *repo_name)?;
123 if !is_repository_ready(repository) {
124 return None;
125 }
126 if !is_encryption_key_ready(repository) {
127 debug!(
128 kanidm = %kanidm_name,
129 repository = %repo_name,
130 "EncryptionKeyReady is False, deferring transport sidecar injection"
131 );
132 return None;
133 }
134 if repository
138 .status
139 .as_ref()
140 .is_some_and(|status| status.usage_started == Some(false))
141 {
142 debug!(
143 kanidm = %kanidm_name,
144 repository = %repo_name,
145 "Repository usage lock not yet established, deferring transport sidecar injection"
146 );
147 return None;
148 }
149
150 let operation_doc_json = build_transport_operation_doc(kanidm, repository)?;
151 let encryption_key_ref = repository
152 .spec
153 .encryption
154 .as_ref()
155 .and_then(|e| e.key_ref.clone());
156 Some(TransportSidecarConfig {
157 operation_doc_json,
158 auth_method: repository.spec.authentication.writer.clone(),
159 ca_bundle_ref: repository.spec.s3.ca_bundle_ref.clone(),
160 encryption_key_ref,
161 })
162}
163
164fn is_repository_ready(repo: &KanidmBackupRepository) -> bool {
165 repo.status
166 .as_ref()
167 .and_then(|status| {
168 status
169 .conditions
170 .iter()
171 .find(|condition| condition.type_ == "Ready")
172 .map(|condition| condition.status == "True" && condition.reason == "Accepted")
173 })
174 .unwrap_or(false)
175}
176
177fn is_encryption_key_ready(repo: &KanidmBackupRepository) -> bool {
178 let has_client_side = repo
179 .spec
180 .encryption
181 .as_ref()
182 .is_some_and(|e| e.mode == kaniop_backup_core::crd::EncryptionMode::ClientSide);
183 if !has_client_side {
184 return true;
185 }
186 repo.status
187 .as_ref()
188 .and_then(|status| {
189 status
190 .conditions
191 .iter()
192 .find(|condition| condition.type_ == "EncryptionKeyReady")
193 .map(|condition| condition.status == "True")
194 })
195 .unwrap_or(false)
196}
197
198fn build_transport_operation_doc(
199 kanidm: &Kanidm,
200 repository: &KanidmBackupRepository,
201) -> Option<String> {
202 let namespace = kanidm.namespace().unwrap_or_default();
206 let kanidm_uid = kanidm.metadata.uid.clone().unwrap_or_default();
207 let kanidm_name = kanidm.name_any();
208 let domain = kanidm.spec.domain.clone();
209 let kanidm_version = kanidm
210 .status
211 .as_ref()
212 .and_then(|status| status.version.as_ref())
213 .map(|version| version.image_tag.clone())
214 .unwrap_or_default();
215
216 let s3 = &repository.spec.s3;
217 let encryption = repository.spec.encryption.as_ref();
218 let doc = serde_json::json!({
219 "apiVersion": "backup.kaniop.rs/v1alpha1",
220 "kind": "OperationDocument",
221 "operation": "transport",
222 "watchDir": "/data/backups",
223 "filePrefix": "backup-",
224 "fileSuffix": ".json.gz",
225 "pollIntervalSecs": 60,
226 "minFileAgeSecs": 120,
227 "bucket": s3.bucket,
228 "prefix": s3.prefix,
229 "endpoint": s3.endpoint,
230 "region": s3.region,
231 "forcePathStyle": s3.force_path_style,
232 "insecure": s3.insecure,
233 "caBundlePath": s3.ca_bundle_ref.as_ref().map(|_| kaniop_backup_core::auth::ca_bundle_path()),
234 "namespaceUid": namespace,
235 "kanidmUid": kanidm_uid,
236 "kanidmName": kanidm_name,
237 "domain": domain,
238 "kanidmVersion": kanidm_version,
239 "imageDigest": null,
240 "consistency": "kanidm-online",
241 "reason": "scheduled",
242 "encryptionMode": encryption.map(|value| serde_json::json!(value.mode)),
243 "encryptionKeyId": encryption.and_then(|value| value.key_id.clone()),
244 "maxConcurrentParts": 4,
245 "maxRetries": 3
246 });
247
248 serde_json::to_string(&doc).ok()
249}
250
251#[cfg(test)]
252mod tests {
253 use super::*;
254 use kaniop_backup_core::crd::{
255 AuthMethod, EncryptionKeyRef, EncryptionMode, KanidmBackupRepositorySpec,
256 KanidmBackupScheduleSpec, RepositoryAuthentication, RepositoryEncryption, S3Config,
257 ScheduleKanidmRef, ScheduleRepositoryRef, SecretRef,
258 };
259 use kube::api::ObjectMeta;
260
261 use crate::kanidm::crd::{
262 KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
263 };
264
265 fn make_kanidm_with_status(name: &str, namespace: &str, version_tag: Option<&str>) -> Kanidm {
266 let status = version_tag.map(|tag| crate::kanidm::crd::KanidmStatus {
267 version: Some(crate::kanidm::crd::KanidmVersionStatus {
268 image_tag: tag.to_string(),
269 upgrade_check_result: crate::kanidm::crd::KanidmUpgradeCheckResult::Passed,
270 compatibility_result: crate::kanidm::crd::VersionCompatibilityResult::Compatible,
271 }),
272 ..Default::default()
273 });
274 Kanidm {
275 metadata: ObjectMeta {
276 name: Some(name.to_string()),
277 namespace: Some(namespace.to_string()),
278 uid: Some("kanidm-uid-123".to_string()),
279 ..Default::default()
280 },
281 spec: KanidmSpec {
282 domain: "idm.example.com".to_string(),
283 storage: Some(KanidmStorage {
284 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
285 ..Default::default()
286 }),
287 replica_groups: vec![ReplicaGroup {
288 name: "default".to_string(),
289 replicas: 1,
290 primary_node: true,
291 ..Default::default()
292 }],
293 ..Default::default()
294 },
295 status,
296 }
297 }
298
299 fn make_schedule(
300 name: &str,
301 kanidm_name: &str,
302 repo_name: &str,
303 suspend: bool,
304 ) -> KanidmBackupSchedule {
305 KanidmBackupSchedule {
306 metadata: ObjectMeta {
307 name: Some(name.to_string()),
308 namespace: Some("default".to_string()),
309 ..Default::default()
310 },
311 spec: KanidmBackupScheduleSpec {
312 kanidm_ref: ScheduleKanidmRef {
313 name: kanidm_name.to_string(),
314 },
315 repository_ref: ScheduleRepositoryRef {
316 name: repo_name.to_string(),
317 },
318 schedule: "0 2 * * *".to_string(),
319 time_zone: "UTC".to_string(),
320 suspend,
321 concurrency_policy: "Forbid".to_string(),
322 jitter_seconds: None,
323 local_versions: 7,
324 retention: None,
325 },
326 status: None,
327 }
328 }
329
330 fn make_repository(name: &str, ready: bool) -> KanidmBackupRepository {
331 let method = AuthMethod {
332 workload_identity: None,
333 secret_ref: Some(SecretRef {
334 name: "backup-secret".to_string(),
335 }),
336 };
337 let mut repo = KanidmBackupRepository {
338 metadata: ObjectMeta {
339 name: Some(name.to_string()),
340 namespace: Some("default".to_string()),
341 ..Default::default()
342 },
343 spec: KanidmBackupRepositorySpec {
344 s3: S3Config {
345 bucket: "test-bucket".to_string(),
346 prefix: "backups".to_string(),
347 region: "us-east-1".to_string(),
348 endpoint: "https://s3.example.com".to_string(),
349 force_path_style: false,
350 ca_bundle_ref: None,
351 insecure: false,
352 },
353 authentication: RepositoryAuthentication {
354 writer: method.clone(),
355 reader: method.clone(),
356 deleter: method,
357 },
358 encryption: None,
359 limits: None,
360 },
361 status: None,
362 };
363 if ready {
364 repo.status = Some(kaniop_backup_core::crd::KanidmBackupRepositoryStatus {
365 observed_generation: Some(1),
366 usage_started: None,
367 conditions: vec![k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
368 type_: "Ready".to_string(),
369 status: "True".to_string(),
370 observed_generation: Some(1),
371 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
372 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
373 ),
374 reason: "Accepted".to_string(),
375 message: "Repository configuration accepted".to_string(),
376 }],
377 });
378 }
379 repo
380 }
381
382 #[test]
383 fn no_schedule_means_no_backup_config() {
384 let kanidm = make_kanidm_with_status("test-kanidm", "default", None);
385 assert!(resolve_backup_config(&kanidm, &[], &[]).is_none());
386 }
387
388 #[test]
389 fn suspended_schedule_disables_native_backup_and_transport() {
390 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
391 let schedule = make_schedule("sched", "test-kanidm", "repo", true);
392 let repo = make_repository("repo", true);
393 assert!(resolve_backup_config(&kanidm, &[schedule], &[repo]).is_none());
394 }
395
396 #[test]
397 fn schedule_drives_native_backup_even_when_repository_is_not_ready() {
398 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
399 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
400 let repo = make_repository("repo", false);
401 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
402 assert_eq!(config.schedule, "0 2 * * *");
403 assert_eq!(config.local_versions, 7);
404 assert!(config.transport.is_none());
405 }
406
407 #[test]
408 fn native_backup_does_not_wait_for_kanidm_status() {
409 let kanidm = make_kanidm_with_status("test-kanidm", "default", None);
410 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
411 let repo = make_repository("repo", true);
412 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
413 assert!(config.transport.is_none());
414 }
415
416 #[test]
417 fn unlocked_repository_cannot_start_transport() {
418 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
419 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
420 let mut repo = make_repository("repo", true);
421 repo.status.as_mut().unwrap().usage_started = Some(false);
422 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
423 assert!(config.transport.is_none());
424 }
425
426 #[test]
427 fn disabled_upgrade_checks_still_render_backup_transport_and_source_version() {
428 let mut kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.12.0"));
429 kanidm.spec.disable_upgrade_checks = true;
430 let version = kanidm.status.as_mut().unwrap().version.as_mut().unwrap();
431 version.upgrade_check_result = crate::kanidm::crd::KanidmUpgradeCheckResult::Skipped;
432 version.compatibility_result = crate::kanidm::crd::VersionCompatibilityResult::NotChecked;
433
434 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
435 let repo = make_repository("repo", true);
436 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
437 let transport = config
438 .transport
439 .expect("transport must not depend on upgrade checks");
440 let operation: serde_json::Value =
441 serde_json::from_str(&transport.operation_doc_json).unwrap();
442 assert_eq!(operation["kanidmVersion"], "1.12.0");
443 }
444
445 #[test]
446 fn ready_repository_adds_transport() {
447 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
448 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
449 let repo = make_repository("repo", true);
450 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
451 let transport = config.transport.expect("transport should be configured");
452 assert!(transport.operation_doc_json.contains("transport"));
453 assert!(transport.operation_doc_json.contains("test-bucket"));
454 }
455
456 #[test]
457 fn multiple_schedules_fail_closed_even_if_one_is_suspended() {
458 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
459 let schedule1 = make_schedule("sched1", "test-kanidm", "repo1", false);
460 let schedule2 = make_schedule("sched2", "test-kanidm", "repo2", true);
461 let repo1 = make_repository("repo1", true);
462 let repo2 = make_repository("repo2", true);
463 assert!(resolve_backup_config(&kanidm, &[schedule1, schedule2], &[repo1, repo2]).is_none());
464 }
465
466 #[test]
467 fn invalid_backup_target_fails_closed() {
468 let mut kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
469 kanidm.spec.storage = None;
470 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
471 let repo = make_repository("repo", true);
472 assert!(resolve_backup_config(&kanidm, &[schedule], &[repo]).is_none());
473 }
474
475 #[test]
476 fn transport_config_includes_encryption_key_ref_when_client_side() {
477 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
478 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
479 let mut repo = make_repository("repo", true);
480 repo.spec.encryption = Some(RepositoryEncryption {
481 mode: EncryptionMode::ClientSide,
482 key_id: None,
483 key_ref: Some(EncryptionKeyRef {
484 name: "kek-secret".to_string(),
485 key: "encryption-key".to_string(),
486 }),
487 });
488 repo.status.as_mut().unwrap().conditions.push(
489 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
490 type_: "EncryptionKeyReady".to_string(),
491 status: "True".to_string(),
492 observed_generation: Some(1),
493 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
494 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
495 ),
496 reason: "KeyPresent".to_string(),
497 message: "Key available".to_string(),
498 },
499 );
500 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
501 let transport = config.transport.expect("transport should be configured");
502 assert!(transport.encryption_key_ref.is_some());
503 assert_eq!(transport.encryption_key_ref.unwrap().name, "kek-secret");
504 }
505
506 #[test]
507 fn transport_config_omits_encryption_key_ref_when_no_encryption() {
508 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
509 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
510 let repo = make_repository("repo", true);
511 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
512 let transport = config.transport.expect("transport should be configured");
513 assert!(transport.encryption_key_ref.is_none());
514 }
515
516 #[test]
517 fn transport_config_omits_encryption_key_ref_when_provider_managed() {
518 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
519 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
520 let mut repo = make_repository("repo", true);
521 repo.spec.encryption = Some(RepositoryEncryption {
522 mode: EncryptionMode::ProviderManaged,
523 key_id: None,
524 key_ref: None,
525 });
526 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
527 let transport = config.transport.expect("transport should be configured");
528 assert!(transport.encryption_key_ref.is_none());
529 }
530
531 #[test]
532 fn is_encryption_key_ready_true_when_no_encryption() {
533 let repo = make_repository("repo", true);
534 assert!(is_encryption_key_ready(&repo));
535 }
536
537 #[test]
538 fn is_encryption_key_ready_true_when_provider_managed() {
539 let mut repo = make_repository("repo", true);
540 repo.spec.encryption = Some(RepositoryEncryption {
541 mode: EncryptionMode::ProviderManaged,
542 key_id: None,
543 key_ref: None,
544 });
545 assert!(is_encryption_key_ready(&repo));
546 }
547
548 #[test]
549 fn is_encryption_key_ready_false_when_client_side_no_status() {
550 let mut repo = make_repository("repo", true);
551 repo.spec.encryption = Some(RepositoryEncryption {
552 mode: EncryptionMode::ClientSide,
553 key_id: None,
554 key_ref: Some(EncryptionKeyRef {
555 name: "kek-secret".to_string(),
556 key: "encryption-key".to_string(),
557 }),
558 });
559 repo.status
560 .as_mut()
561 .unwrap()
562 .conditions
563 .retain(|c| c.type_ != "EncryptionKeyReady");
564 assert!(!is_encryption_key_ready(&repo));
565 }
566
567 #[test]
568 fn is_encryption_key_ready_false_when_client_side_condition_false() {
569 let mut repo = make_repository("repo", true);
570 repo.spec.encryption = Some(RepositoryEncryption {
571 mode: EncryptionMode::ClientSide,
572 key_id: None,
573 key_ref: Some(EncryptionKeyRef {
574 name: "kek-secret".to_string(),
575 key: "encryption-key".to_string(),
576 }),
577 });
578 repo.status.as_mut().unwrap().conditions.push(
579 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
580 type_: "EncryptionKeyReady".to_string(),
581 status: "False".to_string(),
582 observed_generation: Some(1),
583 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
584 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
585 ),
586 reason: "MissingSecret".to_string(),
587 message: "Secret not found".to_string(),
588 },
589 );
590 assert!(!is_encryption_key_ready(&repo));
591 }
592
593 #[test]
594 fn is_encryption_key_ready_true_when_client_side_condition_true() {
595 let mut repo = make_repository("repo", true);
596 repo.spec.encryption = Some(RepositoryEncryption {
597 mode: EncryptionMode::ClientSide,
598 key_id: None,
599 key_ref: Some(EncryptionKeyRef {
600 name: "kek-secret".to_string(),
601 key: "encryption-key".to_string(),
602 }),
603 });
604 repo.status.as_mut().unwrap().conditions.push(
605 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
606 type_: "EncryptionKeyReady".to_string(),
607 status: "True".to_string(),
608 observed_generation: Some(1),
609 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
610 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
611 ),
612 reason: "KeyPresent".to_string(),
613 message: "Key available".to_string(),
614 },
615 );
616 assert!(is_encryption_key_ready(&repo));
617 }
618
619 #[test]
620 fn transport_not_injected_when_encryption_key_not_ready() {
621 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
622 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
623 let mut repo = make_repository("repo", true);
624 repo.spec.encryption = Some(RepositoryEncryption {
625 mode: EncryptionMode::ClientSide,
626 key_id: None,
627 key_ref: Some(EncryptionKeyRef {
628 name: "kek-secret".to_string(),
629 key: "encryption-key".to_string(),
630 }),
631 });
632 repo.status.as_mut().unwrap().conditions.push(
633 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
634 type_: "EncryptionKeyReady".to_string(),
635 status: "False".to_string(),
636 observed_generation: Some(1),
637 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
638 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
639 ),
640 reason: "MissingSecret".to_string(),
641 message: "Secret not found".to_string(),
642 },
643 );
644 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
645 assert!(
646 config.transport.is_none(),
647 "sidecar must not be injected when KEK is missing"
648 );
649 }
650
651 #[test]
652 fn transport_injected_when_encryption_key_ready() {
653 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
654 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
655 let mut repo = make_repository("repo", true);
656 repo.spec.encryption = Some(RepositoryEncryption {
657 mode: EncryptionMode::ClientSide,
658 key_id: None,
659 key_ref: Some(EncryptionKeyRef {
660 name: "kek-secret".to_string(),
661 key: "encryption-key".to_string(),
662 }),
663 });
664 repo.status.as_mut().unwrap().conditions.push(
665 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
666 type_: "EncryptionKeyReady".to_string(),
667 status: "True".to_string(),
668 observed_generation: Some(1),
669 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
670 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
671 ),
672 reason: "KeyPresent".to_string(),
673 message: "Key available".to_string(),
674 },
675 );
676 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
677 assert!(
678 config.transport.is_some(),
679 "sidecar should be injected when KEK is ready"
680 );
681 }
682}