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
127    let operation_doc_json = build_transport_operation_doc(kanidm, repository)?;
128    let encryption_key_ref = repository
129        .spec
130        .encryption
131        .as_ref()
132        .and_then(|e| e.key_ref.clone());
133    Some(TransportSidecarConfig {
134        operation_doc_json,
135        auth_method: repository.spec.authentication.writer.clone(),
136        ca_bundle_ref: repository.spec.s3.ca_bundle_ref.clone(),
137        encryption_key_ref,
138    })
139}
140
141fn is_repository_ready(repo: &KanidmBackupRepository) -> bool {
142    repo.status
143        .as_ref()
144        .and_then(|status| {
145            status
146                .conditions
147                .iter()
148                .find(|condition| condition.type_ == "Ready")
149                .map(|condition| condition.status == "True" && condition.reason == "Accepted")
150        })
151        .unwrap_or(false)
152}
153
154fn build_transport_operation_doc(
155    kanidm: &Kanidm,
156    repository: &KanidmBackupRepository,
157) -> Option<String> {
158    let namespace_uid = kanidm.namespace().unwrap_or_default();
159    let kanidm_uid = kanidm.metadata.uid.clone().unwrap_or_default();
160    let kanidm_name = kanidm.name_any();
161    let domain = kanidm.spec.domain.clone();
162    let kanidm_version = kanidm
163        .status
164        .as_ref()
165        .and_then(|status| status.version.as_ref())
166        .map(|version| version.image_tag.clone())
167        .unwrap_or_default();
168
169    let s3 = &repository.spec.s3;
170    let encryption = repository.spec.encryption.as_ref();
171    let doc = serde_json::json!({
172        "apiVersion": "backup.kaniop.rs/v1alpha1",
173        "kind": "OperationDocument",
174        "operation": "transport",
175        "watchDir": "/data/backups",
176        "filePrefix": "backup-",
177        "fileSuffix": ".json.gz",
178        "pollIntervalSecs": 60,
179        "minFileAgeSecs": 120,
180        "bucket": s3.bucket,
181        "prefix": s3.prefix,
182        "endpoint": s3.endpoint,
183        "region": s3.region,
184        "forcePathStyle": s3.force_path_style,
185        "insecure": s3.insecure,
186        "caBundlePath": s3.ca_bundle_ref.as_ref().map(|_| "/etc/ssl/certs/ca-certificates.crt"),
187        "namespaceUid": namespace_uid,
188        "kanidmUid": kanidm_uid,
189        "kanidmName": kanidm_name,
190        "domain": domain,
191        "kanidmVersion": kanidm_version,
192        "imageDigest": null,
193        "consistency": "kanidm-online",
194        "reason": "scheduled",
195        "encryptionMode": encryption.map(|value| serde_json::json!(value.mode)),
196        "encryptionKeyId": encryption.and_then(|value| value.key_id.clone()),
197        "maxConcurrentParts": 4,
198        "maxRetries": 3
199    });
200
201    serde_json::to_string(&doc).ok()
202}
203
204#[cfg(test)]
205mod tests {
206    use super::*;
207    use kaniop_backup_core::crd::{
208        AuthMethod, KanidmBackupRepositorySpec, KanidmBackupScheduleSpec, RepositoryAuthentication,
209        S3Config, ScheduleKanidmRef, ScheduleRepositoryRef, SecretRef,
210    };
211    use kube::api::ObjectMeta;
212
213    use crate::kanidm::crd::{
214        KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
215    };
216
217    fn make_kanidm_with_status(name: &str, namespace: &str, version_tag: Option<&str>) -> Kanidm {
218        let status = version_tag.map(|tag| crate::kanidm::crd::KanidmStatus {
219            version: Some(crate::kanidm::crd::KanidmVersionStatus {
220                image_tag: tag.to_string(),
221                upgrade_check_result: crate::kanidm::crd::KanidmUpgradeCheckResult::Passed,
222                compatibility_result: crate::kanidm::crd::VersionCompatibilityResult::Compatible,
223            }),
224            ..Default::default()
225        });
226        Kanidm {
227            metadata: ObjectMeta {
228                name: Some(name.to_string()),
229                namespace: Some(namespace.to_string()),
230                uid: Some("kanidm-uid-123".to_string()),
231                ..Default::default()
232            },
233            spec: KanidmSpec {
234                domain: "idm.example.com".to_string(),
235                storage: Some(KanidmStorage {
236                    volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
237                    ..Default::default()
238                }),
239                replica_groups: vec![ReplicaGroup {
240                    name: "default".to_string(),
241                    replicas: 1,
242                    primary_node: true,
243                    ..Default::default()
244                }],
245                ..Default::default()
246            },
247            status,
248        }
249    }
250
251    fn make_schedule(
252        name: &str,
253        kanidm_name: &str,
254        repo_name: &str,
255        suspend: bool,
256    ) -> KanidmBackupSchedule {
257        KanidmBackupSchedule {
258            metadata: ObjectMeta {
259                name: Some(name.to_string()),
260                namespace: Some("default".to_string()),
261                ..Default::default()
262            },
263            spec: KanidmBackupScheduleSpec {
264                kanidm_ref: ScheduleKanidmRef {
265                    name: kanidm_name.to_string(),
266                },
267                repository_ref: ScheduleRepositoryRef {
268                    name: repo_name.to_string(),
269                },
270                schedule: "0 2 * * *".to_string(),
271                time_zone: "UTC".to_string(),
272                suspend,
273                concurrency_policy: "Forbid".to_string(),
274                jitter_seconds: None,
275                local_versions: 7,
276                retention: None,
277            },
278            status: None,
279        }
280    }
281
282    fn make_repository(name: &str, ready: bool) -> KanidmBackupRepository {
283        let method = AuthMethod {
284            workload_identity: None,
285            secret_ref: Some(SecretRef {
286                name: "backup-secret".to_string(),
287            }),
288        };
289        let mut repo = KanidmBackupRepository {
290            metadata: ObjectMeta {
291                name: Some(name.to_string()),
292                namespace: Some("default".to_string()),
293                ..Default::default()
294            },
295            spec: KanidmBackupRepositorySpec {
296                s3: S3Config {
297                    bucket: "test-bucket".to_string(),
298                    prefix: "backups".to_string(),
299                    region: Some("us-east-1".to_string()),
300                    endpoint: Some("https://s3.example.com".to_string()),
301                    force_path_style: false,
302                    ca_bundle_ref: None,
303                    insecure: false,
304                },
305                authentication: RepositoryAuthentication {
306                    writer: method.clone(),
307                    reader: method.clone(),
308                    deleter: method,
309                },
310                encryption: None,
311                limits: None,
312            },
313            status: None,
314        };
315        if ready {
316            repo.status = Some(kaniop_backup_core::crd::KanidmBackupRepositoryStatus {
317                observed_generation: Some(1),
318                conditions: vec![k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
319                    type_: "Ready".to_string(),
320                    status: "True".to_string(),
321                    observed_generation: Some(1),
322                    last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
323                        k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
324                    ),
325                    reason: "Accepted".to_string(),
326                    message: "Repository configuration accepted".to_string(),
327                }],
328            });
329        }
330        repo
331    }
332
333    #[test]
334    fn no_schedule_means_no_backup_config() {
335        let kanidm = make_kanidm_with_status("test-kanidm", "default", None);
336        assert!(resolve_backup_config(&kanidm, &[], &[]).is_none());
337    }
338
339    #[test]
340    fn suspended_schedule_disables_native_backup_and_transport() {
341        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
342        let schedule = make_schedule("sched", "test-kanidm", "repo", true);
343        let repo = make_repository("repo", true);
344        assert!(resolve_backup_config(&kanidm, &[schedule], &[repo]).is_none());
345    }
346
347    #[test]
348    fn schedule_drives_native_backup_even_when_repository_is_not_ready() {
349        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
350        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
351        let repo = make_repository("repo", false);
352        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
353        assert_eq!(config.schedule, "0 2 * * *");
354        assert_eq!(config.local_versions, 7);
355        assert!(config.transport.is_none());
356    }
357
358    #[test]
359    fn native_backup_does_not_wait_for_kanidm_status() {
360        let kanidm = make_kanidm_with_status("test-kanidm", "default", None);
361        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
362        let repo = make_repository("repo", true);
363        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
364        assert!(config.transport.is_none());
365    }
366
367    #[test]
368    fn ready_repository_adds_transport() {
369        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
370        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
371        let repo = make_repository("repo", true);
372        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
373        let transport = config.transport.expect("transport should be configured");
374        assert!(transport.operation_doc_json.contains("transport"));
375        assert!(transport.operation_doc_json.contains("test-bucket"));
376    }
377
378    #[test]
379    fn multiple_schedules_fail_closed_even_if_one_is_suspended() {
380        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
381        let schedule1 = make_schedule("sched1", "test-kanidm", "repo1", false);
382        let schedule2 = make_schedule("sched2", "test-kanidm", "repo2", true);
383        let repo1 = make_repository("repo1", true);
384        let repo2 = make_repository("repo2", true);
385        assert!(resolve_backup_config(&kanidm, &[schedule1, schedule2], &[repo1, repo2]).is_none());
386    }
387
388    #[test]
389    fn invalid_backup_target_fails_closed() {
390        let mut kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
391        kanidm.spec.storage = None;
392        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
393        let repo = make_repository("repo", true);
394        assert!(resolve_backup_config(&kanidm, &[schedule], &[repo]).is_none());
395    }
396
397    #[test]
398    fn transport_config_includes_encryption_key_ref_when_client_side() {
399        use kaniop_backup_core::crd::{EncryptionMode, RepositoryEncryption};
400
401        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
402        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
403        let mut repo = make_repository("repo", true);
404        repo.spec.encryption = Some(RepositoryEncryption {
405            mode: EncryptionMode::ClientSide,
406            key_id: None,
407            key_ref: Some(SecretRef {
408                name: "kek-secret".to_string(),
409            }),
410        });
411        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
412        let transport = config.transport.expect("transport should be configured");
413        assert!(transport.encryption_key_ref.is_some());
414        assert_eq!(transport.encryption_key_ref.unwrap().name, "kek-secret");
415    }
416
417    #[test]
418    fn transport_config_omits_encryption_key_ref_when_no_encryption() {
419        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
420        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
421        let repo = make_repository("repo", true);
422        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
423        let transport = config.transport.expect("transport should be configured");
424        assert!(transport.encryption_key_ref.is_none());
425    }
426
427    #[test]
428    fn transport_config_omits_encryption_key_ref_when_provider_managed() {
429        use kaniop_backup_core::crd::{EncryptionMode, RepositoryEncryption};
430
431        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
432        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
433        let mut repo = make_repository("repo", true);
434        repo.spec.encryption = Some(RepositoryEncryption {
435            mode: EncryptionMode::ProviderManaged,
436            key_id: None,
437            key_ref: None,
438        });
439        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
440        let transport = config.transport.expect("transport should be configured");
441        assert!(transport.encryption_key_ref.is_none());
442    }
443}