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    // `namespaceUid` on the wire carries the Kubernetes namespace NAME, not the Namespace object
188    // UID; it selects the `tenants/<x>` keyspace segment that discovery scans (misnomer tracked in
189    // issue #1084).
190    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}