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: "us-east-1".to_string(),
300 endpoint: "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}