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}