1use kaniop_backup_core::crd::{
2 AuthMethod, KanidmBackupRepository, KanidmBackupSchedule, SecretRef,
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<String>,
17 pub encryption_key_ref: Option<SecretRef>,
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
135 let operation_doc_json = build_transport_operation_doc(kanidm, repository)?;
136 let encryption_key_ref = repository
137 .spec
138 .encryption
139 .as_ref()
140 .and_then(|e| e.key_ref.clone());
141 Some(TransportSidecarConfig {
142 operation_doc_json,
143 auth_method: repository.spec.authentication.writer.clone(),
144 ca_bundle_ref: repository.spec.s3.ca_bundle_ref.clone(),
145 encryption_key_ref,
146 })
147}
148
149fn is_repository_ready(repo: &KanidmBackupRepository) -> bool {
150 repo.status
151 .as_ref()
152 .and_then(|status| {
153 status
154 .conditions
155 .iter()
156 .find(|condition| condition.type_ == "Ready")
157 .map(|condition| condition.status == "True" && condition.reason == "Accepted")
158 })
159 .unwrap_or(false)
160}
161
162fn is_encryption_key_ready(repo: &KanidmBackupRepository) -> bool {
163 let has_client_side = repo
164 .spec
165 .encryption
166 .as_ref()
167 .is_some_and(|e| e.mode == kaniop_backup_core::crd::EncryptionMode::ClientSide);
168 if !has_client_side {
169 return true;
170 }
171 repo.status
172 .as_ref()
173 .and_then(|status| {
174 status
175 .conditions
176 .iter()
177 .find(|condition| condition.type_ == "EncryptionKeyReady")
178 .map(|condition| condition.status == "True")
179 })
180 .unwrap_or(false)
181}
182
183fn build_transport_operation_doc(
184 kanidm: &Kanidm,
185 repository: &KanidmBackupRepository,
186) -> Option<String> {
187 let namespace = kanidm.namespace().unwrap_or_default();
191 let kanidm_uid = kanidm.metadata.uid.clone().unwrap_or_default();
192 let kanidm_name = kanidm.name_any();
193 let domain = kanidm.spec.domain.clone();
194 let kanidm_version = kanidm
195 .status
196 .as_ref()
197 .and_then(|status| status.version.as_ref())
198 .map(|version| version.image_tag.clone())
199 .unwrap_or_default();
200
201 let s3 = &repository.spec.s3;
202 let encryption = repository.spec.encryption.as_ref();
203 let doc = serde_json::json!({
204 "apiVersion": "backup.kaniop.rs/v1alpha1",
205 "kind": "OperationDocument",
206 "operation": "transport",
207 "watchDir": "/data/backups",
208 "filePrefix": "backup-",
209 "fileSuffix": ".json.gz",
210 "pollIntervalSecs": 60,
211 "minFileAgeSecs": 120,
212 "bucket": s3.bucket,
213 "prefix": s3.prefix,
214 "endpoint": s3.endpoint,
215 "region": s3.region,
216 "forcePathStyle": s3.force_path_style,
217 "insecure": s3.insecure,
218 "caBundlePath": s3.ca_bundle_ref.as_ref().map(|_| "/etc/ssl/certs/ca-certificates.crt"),
219 "namespaceUid": namespace,
220 "kanidmUid": kanidm_uid,
221 "kanidmName": kanidm_name,
222 "domain": domain,
223 "kanidmVersion": kanidm_version,
224 "imageDigest": null,
225 "consistency": "kanidm-online",
226 "reason": "scheduled",
227 "encryptionMode": encryption.map(|value| serde_json::json!(value.mode)),
228 "encryptionKeyId": encryption.and_then(|value| value.key_id.clone()),
229 "maxConcurrentParts": 4,
230 "maxRetries": 3
231 });
232
233 serde_json::to_string(&doc).ok()
234}
235
236#[cfg(test)]
237mod tests {
238 use super::*;
239 use kaniop_backup_core::crd::{
240 AuthMethod, EncryptionMode, KanidmBackupRepositorySpec, KanidmBackupScheduleSpec,
241 RepositoryAuthentication, RepositoryEncryption, S3Config, ScheduleKanidmRef,
242 ScheduleRepositoryRef, SecretRef,
243 };
244 use kube::api::ObjectMeta;
245
246 use crate::kanidm::crd::{
247 KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
248 };
249
250 fn make_kanidm_with_status(name: &str, namespace: &str, version_tag: Option<&str>) -> Kanidm {
251 let status = version_tag.map(|tag| crate::kanidm::crd::KanidmStatus {
252 version: Some(crate::kanidm::crd::KanidmVersionStatus {
253 image_tag: tag.to_string(),
254 upgrade_check_result: crate::kanidm::crd::KanidmUpgradeCheckResult::Passed,
255 compatibility_result: crate::kanidm::crd::VersionCompatibilityResult::Compatible,
256 }),
257 ..Default::default()
258 });
259 Kanidm {
260 metadata: ObjectMeta {
261 name: Some(name.to_string()),
262 namespace: Some(namespace.to_string()),
263 uid: Some("kanidm-uid-123".to_string()),
264 ..Default::default()
265 },
266 spec: KanidmSpec {
267 domain: "idm.example.com".to_string(),
268 storage: Some(KanidmStorage {
269 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
270 ..Default::default()
271 }),
272 replica_groups: vec![ReplicaGroup {
273 name: "default".to_string(),
274 replicas: 1,
275 primary_node: true,
276 ..Default::default()
277 }],
278 ..Default::default()
279 },
280 status,
281 }
282 }
283
284 fn make_schedule(
285 name: &str,
286 kanidm_name: &str,
287 repo_name: &str,
288 suspend: bool,
289 ) -> KanidmBackupSchedule {
290 KanidmBackupSchedule {
291 metadata: ObjectMeta {
292 name: Some(name.to_string()),
293 namespace: Some("default".to_string()),
294 ..Default::default()
295 },
296 spec: KanidmBackupScheduleSpec {
297 kanidm_ref: ScheduleKanidmRef {
298 name: kanidm_name.to_string(),
299 },
300 repository_ref: ScheduleRepositoryRef {
301 name: repo_name.to_string(),
302 },
303 schedule: "0 2 * * *".to_string(),
304 time_zone: "UTC".to_string(),
305 suspend,
306 concurrency_policy: "Forbid".to_string(),
307 jitter_seconds: None,
308 local_versions: 7,
309 retention: None,
310 },
311 status: None,
312 }
313 }
314
315 fn make_repository(name: &str, ready: bool) -> KanidmBackupRepository {
316 let method = AuthMethod {
317 workload_identity: None,
318 secret_ref: Some(SecretRef {
319 name: "backup-secret".to_string(),
320 }),
321 };
322 let mut repo = KanidmBackupRepository {
323 metadata: ObjectMeta {
324 name: Some(name.to_string()),
325 namespace: Some("default".to_string()),
326 ..Default::default()
327 },
328 spec: KanidmBackupRepositorySpec {
329 s3: S3Config {
330 bucket: "test-bucket".to_string(),
331 prefix: "backups".to_string(),
332 region: "us-east-1".to_string(),
333 endpoint: "https://s3.example.com".to_string(),
334 force_path_style: false,
335 ca_bundle_ref: None,
336 insecure: false,
337 },
338 authentication: RepositoryAuthentication {
339 writer: method.clone(),
340 reader: method.clone(),
341 deleter: method,
342 },
343 encryption: None,
344 limits: None,
345 },
346 status: None,
347 };
348 if ready {
349 repo.status = Some(kaniop_backup_core::crd::KanidmBackupRepositoryStatus {
350 observed_generation: Some(1),
351 conditions: vec![k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
352 type_: "Ready".to_string(),
353 status: "True".to_string(),
354 observed_generation: Some(1),
355 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
356 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
357 ),
358 reason: "Accepted".to_string(),
359 message: "Repository configuration accepted".to_string(),
360 }],
361 });
362 }
363 repo
364 }
365
366 #[test]
367 fn no_schedule_means_no_backup_config() {
368 let kanidm = make_kanidm_with_status("test-kanidm", "default", None);
369 assert!(resolve_backup_config(&kanidm, &[], &[]).is_none());
370 }
371
372 #[test]
373 fn suspended_schedule_disables_native_backup_and_transport() {
374 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
375 let schedule = make_schedule("sched", "test-kanidm", "repo", true);
376 let repo = make_repository("repo", true);
377 assert!(resolve_backup_config(&kanidm, &[schedule], &[repo]).is_none());
378 }
379
380 #[test]
381 fn schedule_drives_native_backup_even_when_repository_is_not_ready() {
382 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
383 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
384 let repo = make_repository("repo", false);
385 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
386 assert_eq!(config.schedule, "0 2 * * *");
387 assert_eq!(config.local_versions, 7);
388 assert!(config.transport.is_none());
389 }
390
391 #[test]
392 fn native_backup_does_not_wait_for_kanidm_status() {
393 let kanidm = make_kanidm_with_status("test-kanidm", "default", None);
394 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
395 let repo = make_repository("repo", true);
396 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
397 assert!(config.transport.is_none());
398 }
399
400 #[test]
401 fn ready_repository_adds_transport() {
402 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
403 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
404 let repo = make_repository("repo", true);
405 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
406 let transport = config.transport.expect("transport should be configured");
407 assert!(transport.operation_doc_json.contains("transport"));
408 assert!(transport.operation_doc_json.contains("test-bucket"));
409 }
410
411 #[test]
412 fn multiple_schedules_fail_closed_even_if_one_is_suspended() {
413 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
414 let schedule1 = make_schedule("sched1", "test-kanidm", "repo1", false);
415 let schedule2 = make_schedule("sched2", "test-kanidm", "repo2", true);
416 let repo1 = make_repository("repo1", true);
417 let repo2 = make_repository("repo2", true);
418 assert!(resolve_backup_config(&kanidm, &[schedule1, schedule2], &[repo1, repo2]).is_none());
419 }
420
421 #[test]
422 fn invalid_backup_target_fails_closed() {
423 let mut kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
424 kanidm.spec.storage = None;
425 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
426 let repo = make_repository("repo", true);
427 assert!(resolve_backup_config(&kanidm, &[schedule], &[repo]).is_none());
428 }
429
430 #[test]
431 fn transport_config_includes_encryption_key_ref_when_client_side() {
432 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
433 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
434 let mut repo = make_repository("repo", true);
435 repo.spec.encryption = Some(RepositoryEncryption {
436 mode: EncryptionMode::ClientSide,
437 key_id: None,
438 key_ref: Some(SecretRef {
439 name: "kek-secret".to_string(),
440 }),
441 });
442 repo.status.as_mut().unwrap().conditions.push(
443 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
444 type_: "EncryptionKeyReady".to_string(),
445 status: "True".to_string(),
446 observed_generation: Some(1),
447 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
448 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
449 ),
450 reason: "KeyPresent".to_string(),
451 message: "Key available".to_string(),
452 },
453 );
454 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
455 let transport = config.transport.expect("transport should be configured");
456 assert!(transport.encryption_key_ref.is_some());
457 assert_eq!(transport.encryption_key_ref.unwrap().name, "kek-secret");
458 }
459
460 #[test]
461 fn transport_config_omits_encryption_key_ref_when_no_encryption() {
462 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
463 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
464 let repo = make_repository("repo", true);
465 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
466 let transport = config.transport.expect("transport should be configured");
467 assert!(transport.encryption_key_ref.is_none());
468 }
469
470 #[test]
471 fn transport_config_omits_encryption_key_ref_when_provider_managed() {
472 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
473 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
474 let mut repo = make_repository("repo", true);
475 repo.spec.encryption = Some(RepositoryEncryption {
476 mode: EncryptionMode::ProviderManaged,
477 key_id: None,
478 key_ref: None,
479 });
480 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
481 let transport = config.transport.expect("transport should be configured");
482 assert!(transport.encryption_key_ref.is_none());
483 }
484
485 #[test]
486 fn is_encryption_key_ready_true_when_no_encryption() {
487 let repo = make_repository("repo", true);
488 assert!(is_encryption_key_ready(&repo));
489 }
490
491 #[test]
492 fn is_encryption_key_ready_true_when_provider_managed() {
493 let mut repo = make_repository("repo", true);
494 repo.spec.encryption = Some(RepositoryEncryption {
495 mode: EncryptionMode::ProviderManaged,
496 key_id: None,
497 key_ref: None,
498 });
499 assert!(is_encryption_key_ready(&repo));
500 }
501
502 #[test]
503 fn is_encryption_key_ready_false_when_client_side_no_status() {
504 let mut repo = make_repository("repo", true);
505 repo.spec.encryption = Some(RepositoryEncryption {
506 mode: EncryptionMode::ClientSide,
507 key_id: None,
508 key_ref: Some(SecretRef {
509 name: "kek-secret".to_string(),
510 }),
511 });
512 repo.status
513 .as_mut()
514 .unwrap()
515 .conditions
516 .retain(|c| c.type_ != "EncryptionKeyReady");
517 assert!(!is_encryption_key_ready(&repo));
518 }
519
520 #[test]
521 fn is_encryption_key_ready_false_when_client_side_condition_false() {
522 let mut repo = make_repository("repo", true);
523 repo.spec.encryption = Some(RepositoryEncryption {
524 mode: EncryptionMode::ClientSide,
525 key_id: None,
526 key_ref: Some(SecretRef {
527 name: "kek-secret".to_string(),
528 }),
529 });
530 repo.status.as_mut().unwrap().conditions.push(
531 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
532 type_: "EncryptionKeyReady".to_string(),
533 status: "False".to_string(),
534 observed_generation: Some(1),
535 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
536 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
537 ),
538 reason: "MissingSecret".to_string(),
539 message: "Secret not found".to_string(),
540 },
541 );
542 assert!(!is_encryption_key_ready(&repo));
543 }
544
545 #[test]
546 fn is_encryption_key_ready_true_when_client_side_condition_true() {
547 let mut repo = make_repository("repo", true);
548 repo.spec.encryption = Some(RepositoryEncryption {
549 mode: EncryptionMode::ClientSide,
550 key_id: None,
551 key_ref: Some(SecretRef {
552 name: "kek-secret".to_string(),
553 }),
554 });
555 repo.status.as_mut().unwrap().conditions.push(
556 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
557 type_: "EncryptionKeyReady".to_string(),
558 status: "True".to_string(),
559 observed_generation: Some(1),
560 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
561 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
562 ),
563 reason: "KeyPresent".to_string(),
564 message: "Key available".to_string(),
565 },
566 );
567 assert!(is_encryption_key_ready(&repo));
568 }
569
570 #[test]
571 fn transport_not_injected_when_encryption_key_not_ready() {
572 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
573 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
574 let mut repo = make_repository("repo", true);
575 repo.spec.encryption = Some(RepositoryEncryption {
576 mode: EncryptionMode::ClientSide,
577 key_id: None,
578 key_ref: Some(SecretRef {
579 name: "kek-secret".to_string(),
580 }),
581 });
582 repo.status.as_mut().unwrap().conditions.push(
583 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
584 type_: "EncryptionKeyReady".to_string(),
585 status: "False".to_string(),
586 observed_generation: Some(1),
587 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
588 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
589 ),
590 reason: "MissingSecret".to_string(),
591 message: "Secret not found".to_string(),
592 },
593 );
594 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
595 assert!(
596 config.transport.is_none(),
597 "sidecar must not be injected when KEK is missing"
598 );
599 }
600
601 #[test]
602 fn transport_injected_when_encryption_key_ready() {
603 let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
604 let schedule = make_schedule("sched", "test-kanidm", "repo", false);
605 let mut repo = make_repository("repo", true);
606 repo.spec.encryption = Some(RepositoryEncryption {
607 mode: EncryptionMode::ClientSide,
608 key_id: None,
609 key_ref: Some(SecretRef {
610 name: "kek-secret".to_string(),
611 }),
612 });
613 repo.status.as_mut().unwrap().conditions.push(
614 k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
615 type_: "EncryptionKeyReady".to_string(),
616 status: "True".to_string(),
617 observed_generation: Some(1),
618 last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
619 k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
620 ),
621 reason: "KeyPresent".to_string(),
622 message: "Key available".to_string(),
623 },
624 );
625 let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
626 assert!(
627 config.transport.is_some(),
628 "sidecar should be injected when KEK is ready"
629 );
630 }
631}