Skip to main content

kaniop_operator/kanidm/reconcile/
transport.rs

1use kaniop_backup_core::crd::{AuthMethod, KanidmBackupRepository, KanidmBackupSchedule};
2use kube::ResourceExt;
3use tracing::debug;
4
5use crate::kanidm::crd::Kanidm;
6
7pub const TRANSPORT_SIDECAR_NAME: &str = "data-mover-transport";
8
9#[derive(Debug, Clone)]
10pub struct TransportSidecarConfig {
11    pub operation_doc_json: String,
12    pub auth_method: AuthMethod,
13    pub ca_bundle_ref: Option<String>,
14}
15
16pub fn resolve_transport_config(
17    kanidm: &Kanidm,
18    schedules: &[KanidmBackupSchedule],
19    repositories: &[KanidmBackupRepository],
20) -> Option<TransportSidecarConfig> {
21    let kanidm_name = kanidm.name_any();
22
23    if kanidm.status.is_none() {
24        debug!(
25            kanidm = %kanidm_name,
26            "Kanidm status not yet populated, deferring transport sidecar injection"
27        );
28        return None;
29    }
30
31    let kanidm_version = kanidm
32        .status
33        .as_ref()
34        .and_then(|s| s.version.as_ref())
35        .map(|v| v.image_tag.clone())
36        .unwrap_or_default();
37
38    if kanidm_version.is_empty() {
39        debug!(
40            kanidm = %kanidm_name,
41            "Kanidm version not yet populated, deferring transport sidecar injection"
42        );
43        return None;
44    }
45
46    let matching_schedules: Vec<_> = schedules
47        .iter()
48        .filter(|s| !s.spec.suspend && s.spec.kanidm_ref.name == kanidm_name)
49        .collect();
50
51    if matching_schedules.len() != 1 {
52        return None;
53    }
54
55    let schedule = matching_schedules[0];
56    let repo_name = &schedule.spec.repository_ref.name;
57    let repository = repositories.iter().find(|r| r.name_any() == *repo_name)?;
58
59    if !is_repository_ready(repository) {
60        return None;
61    }
62
63    let operation_doc_json = build_transport_operation_doc(kanidm, repository)?;
64
65    Some(TransportSidecarConfig {
66        operation_doc_json,
67        auth_method: repository.spec.authentication.writer.clone(),
68        ca_bundle_ref: repository.spec.s3.ca_bundle_ref.clone(),
69    })
70}
71
72fn is_repository_ready(repo: &KanidmBackupRepository) -> bool {
73    repo.status
74        .as_ref()
75        .and_then(|s| {
76            s.conditions
77                .iter()
78                .find(|c| c.type_ == "Ready")
79                .map(|c| c.status == "True" && c.reason == "Accepted")
80        })
81        .unwrap_or(false)
82}
83
84fn build_transport_operation_doc(
85    kanidm: &Kanidm,
86    repository: &KanidmBackupRepository,
87) -> Option<String> {
88    let namespace_uid = kanidm.namespace().unwrap_or_default();
89    let kanidm_uid = kanidm.metadata.uid.clone().unwrap_or_default();
90    let kanidm_name = kanidm.name_any();
91    let domain = kanidm.spec.domain.clone();
92    let kanidm_version = kanidm
93        .status
94        .as_ref()
95        .and_then(|s| s.version.as_ref())
96        .map(|v| v.image_tag.clone())
97        .unwrap_or_default();
98
99    let s3 = &repository.spec.s3;
100    let encryption = repository.spec.encryption.as_ref();
101
102    let doc = serde_json::json!({
103        "apiVersion": "backup.kaniop.rs/v1alpha1",
104        "kind": "OperationDocument",
105        "operation": "transport",
106        "watchDir": "/data/backups",
107        "filePrefix": "backup-",
108        "fileSuffix": ".json.gz",
109        "pollIntervalSecs": 60,
110        "minFileAgeSecs": 120,
111        "bucket": s3.bucket,
112        "prefix": s3.prefix,
113        "endpoint": s3.endpoint,
114        "region": s3.region,
115        "forcePathStyle": s3.force_path_style,
116        "insecure": s3.insecure,
117        "caBundlePath": s3.ca_bundle_ref.as_ref().map(|_| "/etc/ssl/certs/ca-certificates.crt"),
118        "namespaceUid": namespace_uid,
119        "kanidmUid": kanidm_uid,
120        "kanidmName": kanidm_name,
121        "domain": domain,
122        "kanidmVersion": kanidm_version,
123        "imageDigest": null,
124        "consistency": "kanidm-online",
125        "reason": "scheduled",
126        "encryptionMode": encryption.map(|e| serde_json::json!(e.mode)),
127        "encryptionKeyId": encryption.and_then(|e| e.key_id.clone()),
128        "maxConcurrentParts": 4,
129        "maxRetries": 3
130    });
131
132    serde_json::to_string(&doc).ok()
133}
134
135#[cfg(test)]
136mod tests {
137    use super::*;
138    use kaniop_backup_core::crd::{
139        AuthMethod, KanidmBackupRepositorySpec, KanidmBackupScheduleSpec, RepositoryAuthentication,
140        S3Config, ScheduleKanidmRef, ScheduleRepositoryRef, SecretRef,
141    };
142    use kube::api::ObjectMeta;
143
144    fn make_kanidm(name: &str, namespace: &str) -> Kanidm {
145        make_kanidm_with_status(name, namespace, None)
146    }
147
148    fn make_kanidm_with_status(name: &str, namespace: &str, version_tag: Option<&str>) -> Kanidm {
149        let status = version_tag.map(|tag| crate::kanidm::crd::KanidmStatus {
150            version: Some(crate::kanidm::crd::KanidmVersionStatus {
151                image_tag: tag.to_string(),
152                upgrade_check_result: crate::kanidm::crd::KanidmUpgradeCheckResult::Passed,
153                compatibility_result: crate::kanidm::crd::VersionCompatibilityResult::Compatible,
154            }),
155            ..Default::default()
156        });
157        Kanidm {
158            metadata: ObjectMeta {
159                name: Some(name.to_string()),
160                namespace: Some(namespace.to_string()),
161                uid: Some("kanidm-uid-123".to_string()),
162                ..Default::default()
163            },
164            spec: crate::kanidm::crd::KanidmSpec {
165                domain: "idm.example.com".to_string(),
166                ..Default::default()
167            },
168            status,
169        }
170    }
171
172    fn make_schedule(
173        name: &str,
174        kanidm_name: &str,
175        repo_name: &str,
176        suspend: bool,
177    ) -> KanidmBackupSchedule {
178        KanidmBackupSchedule {
179            metadata: ObjectMeta {
180                name: Some(name.to_string()),
181                namespace: Some("default".to_string()),
182                ..Default::default()
183            },
184            spec: KanidmBackupScheduleSpec {
185                kanidm_ref: ScheduleKanidmRef {
186                    name: kanidm_name.to_string(),
187                },
188                repository_ref: ScheduleRepositoryRef {
189                    name: repo_name.to_string(),
190                },
191                schedule: "0 2 * * *".to_string(),
192                time_zone: "UTC".to_string(),
193                suspend,
194                concurrency_policy: "Forbid".to_string(),
195                jitter_seconds: None,
196                local_versions: 7,
197                retention: None,
198            },
199            status: None,
200        }
201    }
202
203    fn make_repository(name: &str, ready: bool) -> KanidmBackupRepository {
204        let mut repo = KanidmBackupRepository {
205            metadata: ObjectMeta {
206                name: Some(name.to_string()),
207                namespace: Some("default".to_string()),
208                ..Default::default()
209            },
210            spec: KanidmBackupRepositorySpec {
211                s3: S3Config {
212                    bucket: "test-bucket".to_string(),
213                    prefix: "backups".to_string(),
214                    region: Some("us-east-1".to_string()),
215                    endpoint: Some("https://s3.example.com".to_string()),
216                    force_path_style: false,
217                    ca_bundle_ref: None,
218                    insecure: false,
219                },
220                authentication: RepositoryAuthentication {
221                    writer: AuthMethod {
222                        workload_identity: None,
223                        secret_ref: Some(SecretRef {
224                            name: "writer-secret".to_string(),
225                        }),
226                    },
227                    reader: AuthMethod {
228                        workload_identity: None,
229                        secret_ref: Some(SecretRef {
230                            name: "reader-secret".to_string(),
231                        }),
232                    },
233                    deleter: AuthMethod {
234                        workload_identity: None,
235                        secret_ref: Some(SecretRef {
236                            name: "deleter-secret".to_string(),
237                        }),
238                    },
239                },
240                encryption: None,
241                limits: None,
242            },
243            status: None,
244        };
245
246        if ready {
247            repo.status = Some(kaniop_backup_core::crd::KanidmBackupRepositoryStatus {
248                observed_generation: Some(1),
249                conditions: vec![k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
250                    type_: "Ready".to_string(),
251                    status: "True".to_string(),
252                    observed_generation: Some(1),
253                    last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
254                        k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
255                    ),
256                    reason: "Accepted".to_string(),
257                    message: "Repository configuration accepted".to_string(),
258                }],
259            });
260        }
261
262        repo
263    }
264
265    #[test]
266    fn resolve_transport_config_returns_none_when_no_schedule() {
267        let kanidm = make_kanidm("test-kanidm", "default");
268        let config = resolve_transport_config(&kanidm, &[], &[]);
269        assert!(config.is_none());
270    }
271
272    #[test]
273    fn resolve_transport_config_returns_none_when_schedule_suspended() {
274        let kanidm = make_kanidm("test-kanidm", "default");
275        let schedule = make_schedule("sched", "test-kanidm", "repo", true);
276        let repo = make_repository("repo", true);
277        let config = resolve_transport_config(&kanidm, &[schedule], &[repo]);
278        assert!(config.is_none());
279    }
280
281    #[test]
282    fn resolve_transport_config_returns_none_when_repo_not_ready() {
283        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
284        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
285        let repo = make_repository("repo", false);
286        let config = resolve_transport_config(&kanidm, &[schedule], &[repo]);
287        assert!(config.is_none());
288    }
289
290    #[test]
291    fn resolve_transport_config_returns_none_when_status_none() {
292        let kanidm = make_kanidm("test-kanidm", "default");
293        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
294        let repo = make_repository("repo", true);
295        let config = resolve_transport_config(&kanidm, &[schedule], &[repo]);
296        assert!(config.is_none());
297    }
298
299    #[test]
300    fn resolve_transport_config_returns_none_when_version_empty() {
301        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some(""));
302        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
303        let repo = make_repository("repo", true);
304        let config = resolve_transport_config(&kanidm, &[schedule], &[repo]);
305        assert!(config.is_none());
306    }
307
308    #[test]
309    fn resolve_transport_config_returns_none_when_ready_reason_not_accepted() {
310        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
311        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
312        let mut repo = make_repository("repo", false);
313        repo.status = Some(kaniop_backup_core::crd::KanidmBackupRepositoryStatus {
314            observed_generation: Some(1),
315            conditions: vec![k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
316                type_: "Ready".to_string(),
317                status: "True".to_string(),
318                observed_generation: Some(1),
319                last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
320                    k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
321                ),
322                reason: "SomeOtherReason".to_string(),
323                message: "not accepted".to_string(),
324            }],
325        });
326        let config = resolve_transport_config(&kanidm, &[schedule], &[repo]);
327        assert!(config.is_none());
328    }
329
330    #[test]
331    fn resolve_transport_config_returns_config_when_valid() {
332        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
333        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
334        let repo = make_repository("repo", true);
335        let config = resolve_transport_config(&kanidm, &[schedule], &[repo]);
336        assert!(config.is_some());
337        let config = config.unwrap();
338        assert!(config.operation_doc_json.contains("transport"));
339        assert!(config.operation_doc_json.contains("test-bucket"));
340    }
341
342    #[test]
343    fn resolve_transport_config_returns_none_when_multiple_schedules() {
344        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
345        let schedule1 = make_schedule("sched1", "test-kanidm", "repo1", false);
346        let schedule2 = make_schedule("sched2", "test-kanidm", "repo2", false);
347        let repo1 = make_repository("repo1", true);
348        let repo2 = make_repository("repo2", true);
349        let config = resolve_transport_config(&kanidm, &[schedule1, schedule2], &[repo1, repo2]);
350        assert!(config.is_none());
351    }
352}