Skip to main content

kaniop_operator/kanidm/reconcile/
transport.rs

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}