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