1pub mod context;
2
3use super::controller::context::{Context, Stores};
4use super::crd::Kanidm;
5use super::reconcile::{
6 reconcile_kanidm,
7 secret::{SECRET_TYPE_LABEL, SecretType},
8};
9
10use crate::backoff_reconciler;
11use crate::controller::{
12 ControllerId, RELOAD_BUFFER_SIZE, ResourceReflector, SUBSCRIBE_BUFFER_SIZE, State,
13 check_api_queryable, check_api_queryable_optional, create_subscriber, create_watcher,
14};
15use kaniop_backup_core::crd::{KanidmBackupRepository, KanidmBackupSchedule};
16use kaniop_k8s_util::error::Error;
17
18use std::sync::Arc;
19
20use futures::FutureExt;
21use futures::StreamExt;
22use futures::TryStreamExt;
23use futures::channel::mpsc;
24use futures::future::BoxFuture;
25use gateway_api::apis::standard::backendtlspolicies::BackendTlsPolicy;
26use gateway_api::apis::standard::httproutes::HttpRoute;
27use k8s_openapi::api::apps::v1::{Deployment, StatefulSet};
28use k8s_openapi::api::core::v1::{ConfigMap, Namespace, Secret, Service};
29use k8s_openapi::api::networking::v1::Ingress;
30use kube::api::{Api, PartialObjectMeta};
31use kube::client::Client;
32use kube::runtime::controller::{self, Controller};
33use kube::runtime::reflector::ObjectRef;
34use kube::runtime::reflector::store::Writer;
35use kube::runtime::reflector::{ReflectHandle, Store};
36use kube::runtime::{WatchStreamExt, predicates, watcher};
37use kube::{Resource, ResourceExt};
38use tokio::time::Duration;
39use tracing::{debug, error, info, trace};
40
41pub const CONTROLLER_ID: ControllerId = "kanidm";
42
43fn create_replica_cert_watcher(
44 api: Api<Secret>,
45 writer: Writer<Secret>,
46 ctx: Arc<Context>,
47) -> BoxFuture<'static, ()> {
48 let replica_cert_label = serde_plain::to_string(&SecretType::ReplicaCert).unwrap();
49
50 watcher(
51 api,
52 watcher::Config::default().labels(&format!("{}={}", SECRET_TYPE_LABEL, replica_cert_label)),
53 )
54 .default_backoff()
55 .reflect_shared(writer)
56 .for_each(move |res| {
57 let ctx = ctx.clone();
58 async move {
59 match res {
60 Ok(event) => {
61 trace!(?event, "watched replica cert event");
62 match event {
63 watcher::Event::InitApply(secret) | watcher::Event::Apply(secret) => {
64 debug!(
65 namespace = secret.namespace().unwrap(),
66 name = secret.name_any(),
67 "init or apply event for replica cert secret trigger reconcile"
68 );
69 let _ignore_errors = ctx.insert_repl_cert_exp(&secret).await.map_err(
70 |e| error!(error = %e, "failed to get replica cert expiration, automatic certificate renewal may be affected"),
71 );
72 }
73 watcher::Event::Delete(secret) => {
74 debug!(
75 namespace = secret.namespace().unwrap(),
76 name = secret.name_any(),
77 "delete event for replica cert secret"
78 );
79 ctx.remove_repl_cert_exp(&ObjectRef::from(&secret))
80 .await;
81 ctx.remove_repl_cert_host(&ObjectRef::from(&secret))
82 .await;
83 }
84 _ => {}
85 }
86 }
87 Err(e) => {
88 error!(error = %e, "unexpected error when watching replica cert secrets");
89 ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
90 }
91 }
92 }
93 })
94 .boxed()
95}
96
97fn map_tls_secret_to_kanidms(
103 kanidm_store: &Store<Kanidm>,
104 secret: &PartialObjectMeta<Secret>,
105) -> Vec<ObjectRef<Kanidm>> {
106 kanidm_store
107 .state()
108 .into_iter()
109 .filter(|kanidm| {
110 kanidm.namespace() == secret.namespace()
111 && kanidm.effective_tls_secret_name() == secret.name_any()
112 })
113 .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
114 .collect()
115}
116
117fn map_mail_sender_ca_config_map_to_kanidms(
120 kanidm_store: &Store<Kanidm>,
121 cm: &PartialObjectMeta<ConfigMap>,
122) -> Vec<ObjectRef<Kanidm>> {
123 kanidm_store
124 .state()
125 .into_iter()
126 .filter(|kanidm| {
127 kanidm.namespace() == cm.namespace()
128 && kanidm
129 .spec
130 .mail_sender
131 .as_ref()
132 .and_then(|spec| spec.ca_bundle_ref.as_ref())
133 .is_some_and(|ca_ref| ca_ref.name == cm.name_any())
134 })
135 .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
136 .collect()
137}
138
139fn map_schedule_to_kanidm(
142 kanidm_store: &Store<Kanidm>,
143 schedule: &KanidmBackupSchedule,
144) -> Vec<ObjectRef<Kanidm>> {
145 let namespace = schedule.namespace();
146 let kanidm_name = &schedule.spec.kanidm_ref.name;
147
148 kanidm_store
149 .state()
150 .into_iter()
151 .filter(|kanidm| kanidm.namespace() == namespace && kanidm.name_any() == *kanidm_name)
152 .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
153 .collect()
154}
155
156fn map_repository_to_kanidms(
161 kanidm_store: &Store<Kanidm>,
162 repository: &KanidmBackupRepository,
163) -> Vec<ObjectRef<Kanidm>> {
164 let namespace = repository.namespace();
165
166 kanidm_store
167 .state()
168 .into_iter()
169 .filter(|kanidm| kanidm.namespace() == namespace)
170 .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
171 .collect()
172}
173
174fn spec_changes<K>(
181 events: impl futures::Stream<Item = Result<watcher::Event<K>, watcher::Error>> + Send + 'static,
182) -> impl futures::Stream<Item = Result<K, watcher::Error>> + Send + 'static
183where
184 K: Resource<DynamicType = ()> + Clone + Send + 'static,
185{
186 events
187 .map_ok(|event| match event {
188 watcher::Event::Delete(mut obj) => {
191 obj.meta_mut().generation = None;
192 watcher::Event::Delete(obj)
193 }
194 event => event,
195 })
196 .touched_objects()
197 .predicate_filter(predicates::generation, Default::default())
198}
199
200#[allow(clippy::too_many_arguments)]
201fn run_controller(
202 kanidm_watcher: impl futures::Stream<Item = Result<Kanidm, watcher::Error>> + Send + 'static,
203 kanidm_store: Store<Kanidm>,
204 statefulset_subscriber: ReflectHandle<StatefulSet>,
205 service_subscriber: ReflectHandle<Service>,
206 ingress_subscriber: ReflectHandle<Ingress>,
207 secret_subscriber: ReflectHandle<Secret>,
208 replica_cert_secret_subscriber: ReflectHandle<Secret>,
209 tls_secret_trigger: impl futures::Stream<Item = Result<PartialObjectMeta<Secret>, watcher::Error>>
210 + Send
211 + 'static,
212 mail_sender_ca_trigger: impl futures::Stream<
213 Item = Result<PartialObjectMeta<ConfigMap>, watcher::Error>,
214 > + Send
215 + 'static,
216 schedule_trigger: impl futures::Stream<Item = Result<KanidmBackupSchedule, watcher::Error>>
217 + Send
218 + 'static,
219 repository_trigger: impl futures::Stream<Item = Result<KanidmBackupRepository, watcher::Error>>
220 + Send
221 + 'static,
222 http_route_subscriber: Option<ReflectHandle<HttpRoute>>,
223 backend_tls_policy_subscriber: Option<ReflectHandle<BackendTlsPolicy>>,
224 deployment_subscriber: ReflectHandle<Deployment>,
225 config_map_subscriber: ReflectHandle<ConfigMap>,
226 reload_rx: mpsc::Receiver<()>,
227 ctx: Arc<Context>,
228) -> BoxFuture<'static, ()> {
229 let kanidm_store_for_tls = kanidm_store.clone();
230 let kanidm_store_for_mail_ca = kanidm_store.clone();
231 let kanidm_store_for_schedule = kanidm_store.clone();
232 let kanidm_store_for_repository = kanidm_store.clone();
233 let mut controller = Controller::for_stream(kanidm_watcher, kanidm_store)
234 .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
235 .owns_shared_stream(statefulset_subscriber)
236 .owns_shared_stream(service_subscriber)
237 .owns_shared_stream(ingress_subscriber)
238 .owns_shared_stream(secret_subscriber)
239 .owns_shared_stream(replica_cert_secret_subscriber)
240 .owns_shared_stream(deployment_subscriber)
241 .owns_shared_stream(config_map_subscriber)
242 .watches_stream(tls_secret_trigger, move |secret| {
243 map_tls_secret_to_kanidms(&kanidm_store_for_tls, &secret)
244 })
245 .watches_stream(mail_sender_ca_trigger, move |cm| {
246 map_mail_sender_ca_config_map_to_kanidms(&kanidm_store_for_mail_ca, &cm)
247 })
248 .watches_stream(schedule_trigger, move |schedule| {
249 map_schedule_to_kanidm(&kanidm_store_for_schedule, &schedule)
250 })
251 .watches_stream(repository_trigger, move |repository| {
252 map_repository_to_kanidms(&kanidm_store_for_repository, &repository)
253 });
254
255 if let Some(subscriber) = http_route_subscriber {
256 controller = controller.owns_shared_stream(subscriber);
257 }
258
259 if let Some(subscriber) = backend_tls_policy_subscriber {
260 controller = controller.owns_shared_stream(subscriber);
261 }
262
263 controller
264 .reconcile_all_on(reload_rx.map(|_| ()))
265 .shutdown_on_signal()
266 .run(
267 backoff_reconciler!(reconcile_kanidm),
268 |_obj, _error: &Error, _ctx| unreachable!(),
269 ctx,
270 )
271 .filter_map(|x| async move { std::result::Result::ok(x) })
272 .for_each(|_| futures::future::ready(()))
273 .boxed()
274}
275
276pub async fn run(
278 state: State,
279 client: Client,
280 namespace_api: Api<Namespace>,
281 namespace_r: ResourceReflector<Namespace>,
282 kanidm_api: Api<Kanidm>,
283 kanidm_r: ResourceReflector<Kanidm>,
284) {
285 let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
286 let service = check_api_queryable::<Service>(client.clone()).await;
287 let ingress = check_api_queryable::<Ingress>(client.clone()).await;
288 let secret = check_api_queryable::<Secret>(client.clone()).await;
289 let http_route_api = check_api_queryable_optional::<HttpRoute>(client.clone()).await;
290 let backend_tls_policy_api =
291 check_api_queryable_optional::<BackendTlsPolicy>(client.clone()).await;
292 let deployment = check_api_queryable::<Deployment>(client.clone()).await;
293 let config_map = check_api_queryable::<ConfigMap>(client.clone()).await;
294
295 let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
296 let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
297 let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
298 let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
299 let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
300 let deployment_r = create_subscriber::<Deployment>(SUBSCRIBE_BUFFER_SIZE);
301 let config_map_r = create_subscriber::<ConfigMap>(SUBSCRIBE_BUFFER_SIZE);
302
303 let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
304
305 let http_route_r = if http_route_api.is_some() {
306 Some(create_subscriber::<HttpRoute>(SUBSCRIBE_BUFFER_SIZE))
307 } else {
308 None
309 };
310
311 let backend_tls_policy_r = if backend_tls_policy_api.is_some() {
312 Some(create_subscriber::<BackendTlsPolicy>(SUBSCRIBE_BUFFER_SIZE))
313 } else {
314 None
315 };
316
317 let stores = Stores {
318 stateful_set_store: statefulset_r.store,
319 service_store: service_r.store,
320 ingress_store: ingress_r.store,
321 secret_store: secret_r.store,
322 http_route_store: http_route_r.as_ref().map(|r| r.store.clone()),
323 backend_tls_policy_store: backend_tls_policy_r.as_ref().map(|r| r.store.clone()),
324 deployment_store: deployment_r.store,
325 config_map_store: config_map_r.store,
326 };
327
328 let ctx = Arc::new(Context::new(
329 state.to_context(client.clone(), CONTROLLER_ID),
330 stores,
331 ));
332 let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
333
334 let statefulset_watcher = create_watcher(
335 statefulset,
336 statefulset_r.writer,
337 reload_tx.clone(),
338 CONTROLLER_ID,
339 kaniop_ctx.clone(),
340 );
341 let service_watcher = create_watcher(
342 service,
343 service_r.writer,
344 reload_tx.clone(),
345 CONTROLLER_ID,
346 kaniop_ctx.clone(),
347 );
348 let ingress_watcher = create_watcher(
349 ingress,
350 ingress_r.writer,
351 reload_tx.clone(),
352 CONTROLLER_ID,
353 kaniop_ctx.clone(),
354 );
355 let secret_watcher = create_watcher(
356 secret.clone(),
357 secret_r.writer,
358 reload_tx.clone(),
359 CONTROLLER_ID,
360 kaniop_ctx.clone(),
361 );
362 let deployment_watcher = create_watcher(
363 deployment,
364 deployment_r.writer,
365 reload_tx.clone(),
366 CONTROLLER_ID,
367 kaniop_ctx.clone(),
368 );
369 let config_map_watcher = create_watcher(
370 config_map,
371 config_map_r.writer,
372 reload_tx.clone(),
373 CONTROLLER_ID,
374 kaniop_ctx.clone(),
375 );
376
377 let replica_cert_secrets_watcher =
378 create_replica_cert_watcher(secret.clone(), replica_cert_secret_r.writer, ctx.clone());
379
380 let tls_secret_metrics_ctx = kaniop_ctx.clone();
384 let tls_secret_api = Api::<PartialObjectMeta<Secret>>::all(client.clone());
385 let tls_secret_trigger = watcher(
386 tls_secret_api,
387 watcher::Config::default()
388 .fields("type=kubernetes.io/tls")
389 .any_semantic(),
390 )
391 .default_backoff()
392 .touched_objects()
393 .inspect_err(move |e| {
394 error!(error = %e, "unexpected error when watching TLS secrets");
395 tls_secret_metrics_ctx.metrics.watch_operations_failed_inc();
396 });
397
398 let ca_config_map_api = Api::<PartialObjectMeta<ConfigMap>>::all(client.clone());
401 let mail_sender_ca_trigger =
402 watcher(ca_config_map_api, watcher::Config::default().any_semantic())
403 .default_backoff()
404 .touched_objects();
405
406 let schedule_api = check_api_queryable_optional::<KanidmBackupSchedule>(client.clone()).await;
409 let repository_api =
410 check_api_queryable_optional::<KanidmBackupRepository>(client.clone()).await;
411
412 let schedule_trigger = match schedule_api {
413 Some(api) => {
414 spec_changes(watcher(api, watcher::Config::default().any_semantic()).default_backoff())
415 .boxed()
416 }
417 None => futures::stream::pending().boxed(),
418 };
419
420 let repository_trigger = match repository_api {
423 Some(api) => watcher(api, watcher::Config::default().any_semantic())
424 .default_backoff()
425 .touched_objects()
426 .boxed(),
427 None => futures::stream::pending().boxed(),
428 };
429
430 let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
431 .default_backoff()
432 .reflect(namespace_r.writer)
433 .for_each(|res| {
434 let ctx = ctx.clone();
435 async move {
436 match res {
437 Ok(event) => trace!(?event, "received namespace event"),
438 Err(e) => {
439 error!(error = %e, "unexpected error when watching namespace");
440 ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
441 }
442 }
443 }
444 });
445
446 info!(controller = CONTROLLER_ID, "starting controller");
447 let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
448 .default_backoff()
449 .reflect(kanidm_r.writer)
450 .touched_objects();
451
452 let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
453 (Some(api), Some(r)) => {
454 let watcher = create_watcher(
455 api,
456 r.writer,
457 reload_tx.clone(),
458 CONTROLLER_ID,
459 kaniop_ctx.clone(),
460 );
461 (Some(watcher), Some(r.subscriber))
462 }
463 _ => (None, None),
464 };
465
466 let (backend_tls_policy_watcher, backend_tls_policy_subscriber) =
467 match (backend_tls_policy_api, backend_tls_policy_r) {
468 (Some(api), Some(r)) => {
469 let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
470 (Some(watcher), Some(r.subscriber))
471 }
472 _ => (None, None),
473 };
474
475 let kanidm_controller = run_controller(
476 kanidm_watcher,
477 kanidm_r.store,
478 statefulset_r.subscriber,
479 service_r.subscriber,
480 ingress_r.subscriber,
481 secret_r.subscriber,
482 replica_cert_secret_r.subscriber,
483 tls_secret_trigger,
484 mail_sender_ca_trigger,
485 schedule_trigger,
486 repository_trigger,
487 http_route_subscriber,
488 backend_tls_policy_subscriber,
489 deployment_r.subscriber,
490 config_map_r.subscriber,
491 reload_rx,
492 ctx.clone(),
493 );
494
495 ctx.kaniop_ctx.metrics.ready_set(1);
496 tokio::select! {
497 _ = kanidm_controller => {},
498 _ = namespace_watcher => {},
499 _ = statefulset_watcher => {},
500 _ = service_watcher => {},
501 _ = ingress_watcher => {},
502 _ = secret_watcher => {},
503 _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
504 _ = backend_tls_policy_watcher.unwrap_or(futures::future::pending().boxed()) => {},
505 _ = replica_cert_secrets_watcher => {},
506 _ = deployment_watcher => {},
507 _ = config_map_watcher => {},
508 }
509}
510
511#[cfg(test)]
512mod tests {
513 use super::{
514 map_mail_sender_ca_config_map_to_kanidms, map_repository_to_kanidms,
515 map_schedule_to_kanidm, map_tls_secret_to_kanidms, spec_changes,
516 };
517 use crate::kanidm::crd::{CaBundleRef, Kanidm, KanidmSpec, MailSenderSpec};
518
519 use futures::{StreamExt, TryStreamExt};
520 use k8s_openapi::api::core::v1::{ConfigMap, Secret};
521 use kaniop_backup_core::crd::{
522 AuthMethod, DiscoveryStatus, KanidmBackupRepository, KanidmBackupRepositorySpec,
523 KanidmBackupSchedule, KanidmBackupScheduleSpec, KanidmBackupScheduleStatus,
524 RepositoryAuthentication, S3Config, ScheduleKanidmRef, ScheduleRepositoryRef, SecretRef,
525 };
526 use kube::api::{ObjectMeta, PartialObjectMeta};
527 use kube::runtime::reflector;
528 use kube::runtime::watcher;
529
530 fn kanidm(name: &str, namespace: &str, tls_secret_name: Option<&str>) -> Kanidm {
531 Kanidm {
532 metadata: ObjectMeta {
533 name: Some(name.to_string()),
534 namespace: Some(namespace.to_string()),
535 ..Default::default()
536 },
537 spec: KanidmSpec {
538 domain: "idm.example.com".to_string(),
539 tls_secret_name: tls_secret_name.map(str::to_string),
540 ..Default::default()
541 },
542 ..Default::default()
543 }
544 }
545
546 fn secret_meta(name: &str, namespace: &str) -> PartialObjectMeta<Secret> {
547 PartialObjectMeta {
548 metadata: ObjectMeta {
549 name: Some(name.to_string()),
550 namespace: Some(namespace.to_string()),
551 ..Default::default()
552 },
553 ..Default::default()
554 }
555 }
556
557 #[test]
558 fn test_map_mail_sender_ca_config_map_to_kanidms() {
559 let (store, mut writer) = reflector::store();
560 let mut a = kanidm("a", "ns1", None);
561 a.spec.mail_sender = Some(MailSenderSpec {
562 ca_bundle_ref: Some(CaBundleRef {
563 name: "shared-ca".into(),
564 key: "ca.crt".into(),
565 }),
566 ..Default::default()
567 });
568 writer.apply_watcher_event(&watcher::Event::Apply(a));
569
570 let mut b = kanidm("b", "ns1", None);
571 b.spec.mail_sender = Some(MailSenderSpec {
572 ca_bundle_ref: Some(CaBundleRef {
573 name: "other-ca".into(),
574 key: "ca.crt".into(),
575 }),
576 ..Default::default()
577 });
578 writer.apply_watcher_event(&watcher::Event::Apply(b));
579
580 let mut c = kanidm("c", "ns2", None);
581 c.spec.mail_sender = Some(MailSenderSpec {
582 ca_bundle_ref: Some(CaBundleRef {
583 name: "shared-ca".into(),
584 key: "ca.crt".into(),
585 }),
586 ..Default::default()
587 });
588 writer.apply_watcher_event(&watcher::Event::Apply(c));
589 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("d", "ns1", None)));
590
591 let cm = |name: &str, namespace: &str| PartialObjectMeta::<ConfigMap> {
592 metadata: ObjectMeta {
593 name: Some(name.to_string()),
594 namespace: Some(namespace.to_string()),
595 ..Default::default()
596 },
597 ..Default::default()
598 };
599 let refs = map_mail_sender_ca_config_map_to_kanidms(&store, &cm("shared-ca", "ns1"));
600 assert_eq!(refs.len(), 1);
601 assert_eq!(refs[0].name, "a");
602 assert!(
603 map_mail_sender_ca_config_map_to_kanidms(&store, &cm("shared-ca", "ns3")).is_empty()
604 );
605 assert!(
606 map_mail_sender_ca_config_map_to_kanidms(&store, &cm("unrelated", "ns1")).is_empty()
607 );
608 }
609
610 #[test]
611 fn test_map_tls_secret_to_kanidms() {
612 let (store, mut writer) = reflector::store();
613 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
614 writer.apply_watcher_event(&watcher::Event::Apply(kanidm(
615 "b",
616 "ns1",
617 Some("custom-tls"),
618 )));
619 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
620
621 let refs = map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns1"));
623 assert_eq!(refs.len(), 1);
624 assert_eq!(refs[0].name, "a");
625
626 let refs = map_tls_secret_to_kanidms(&store, &secret_meta("custom-tls", "ns1"));
628 assert_eq!(refs.len(), 1);
629 assert_eq!(refs[0].name, "b");
630
631 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
633
634 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
636 }
637
638 fn schedule(name: &str, namespace: &str, kanidm_name: &str) -> KanidmBackupSchedule {
639 KanidmBackupSchedule {
640 metadata: ObjectMeta {
641 name: Some(name.to_string()),
642 namespace: Some(namespace.to_string()),
643 ..Default::default()
644 },
645 spec: KanidmBackupScheduleSpec {
646 kanidm_ref: ScheduleKanidmRef {
647 name: kanidm_name.to_string(),
648 },
649 repository_ref: ScheduleRepositoryRef {
650 name: "repo".to_string(),
651 },
652 schedule: "0 2 * * *".to_string(),
653 time_zone: "UTC".to_string(),
654 suspend: false,
655 concurrency_policy: "Forbid".to_string(),
656 jitter_seconds: None,
657 local_versions: 7,
658 retention: None,
659 },
660 status: None,
661 }
662 }
663
664 fn repository(name: &str, namespace: &str) -> KanidmBackupRepository {
665 KanidmBackupRepository {
666 metadata: ObjectMeta {
667 name: Some(name.to_string()),
668 namespace: Some(namespace.to_string()),
669 ..Default::default()
670 },
671 spec: KanidmBackupRepositorySpec {
672 s3: S3Config {
673 bucket: "bucket".to_string(),
674 prefix: "".to_string(),
675 region: String::new(),
676 endpoint: String::new(),
677 force_path_style: false,
678 ca_bundle_ref: None,
679 insecure: false,
680 },
681 authentication: RepositoryAuthentication {
682 writer: AuthMethod {
683 workload_identity: None,
684 secret_ref: Some(SecretRef {
685 name: "s".to_string(),
686 }),
687 },
688 reader: AuthMethod {
689 workload_identity: None,
690 secret_ref: Some(SecretRef {
691 name: "s".to_string(),
692 }),
693 },
694 deleter: AuthMethod {
695 workload_identity: None,
696 secret_ref: Some(SecretRef {
697 name: "s".to_string(),
698 }),
699 },
700 },
701 encryption: None,
702 limits: None,
703 },
704 status: None,
705 }
706 }
707
708 #[test]
709 fn test_map_schedule_to_kanidm_correct_ref() {
710 let (store, mut writer) = reflector::store();
711 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
712 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
713
714 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "a"));
715 assert_eq!(refs.len(), 1);
716 assert_eq!(refs[0].name, "a");
717 }
718
719 #[test]
720 fn test_map_schedule_to_kanidm_wrong_namespace() {
721 let (store, mut writer) = reflector::store();
722 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
723
724 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns2", "a"));
725 assert!(refs.is_empty());
726 }
727
728 #[test]
729 fn test_map_schedule_to_kanidm_other_kanidm() {
730 let (store, mut writer) = reflector::store();
731 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
732
733 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "nonexistent"));
734 assert!(refs.is_empty());
735 }
736
737 #[test]
738 fn test_map_repository_to_kanidms_fans_out() {
739 let (store, mut writer) = reflector::store();
740 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
741 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
742 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
743
744 let refs = map_repository_to_kanidms(&store, &repository("repo", "ns1"));
745 assert_eq!(refs.len(), 2);
746 let names: Vec<_> = refs.iter().map(|r| r.name.as_str()).collect();
747 assert!(names.contains(&"a"));
748 assert!(names.contains(&"b"));
749 }
750
751 #[test]
752 fn test_map_repository_to_kanidms_ignores_other_namespaces() {
753 let (store, mut writer) = reflector::store();
754 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
755
756 let refs = map_repository_to_kanidms(&store, &repository("repo", "ns2"));
757 assert!(refs.is_empty());
758 }
759
760 #[tokio::test]
761 async fn test_spec_changes_drops_status_only_updates() {
762 let mut created = schedule("daily", "ns1", "a");
763 created.metadata.uid = Some("uid-1".to_string());
764 created.metadata.generation = Some(1);
765
766 let mut status_refreshed = created.clone();
767 status_refreshed.status = Some(KanidmBackupScheduleStatus {
768 discovery: Some(DiscoveryStatus {
769 last_scan_time: Some("2026-01-01T00:05:00Z".to_string()),
770 ..Default::default()
771 }),
772 ..Default::default()
773 });
774
775 let mut spec_changed = status_refreshed.clone();
776 spec_changed.metadata.generation = Some(2);
777 spec_changed.spec.suspend = true;
778
779 let events = futures::stream::iter([
780 watcher::Event::Apply(created),
781 watcher::Event::Apply(status_refreshed.clone()),
782 watcher::Event::Apply(status_refreshed),
783 watcher::Event::Apply(spec_changed.clone()),
784 watcher::Event::Delete(spec_changed),
785 ])
786 .map(Ok);
787
788 let forwarded: Vec<KanidmBackupSchedule> =
789 spec_changes(events).try_collect().await.unwrap();
790
791 let generations: Vec<_> = forwarded
792 .iter()
793 .map(|schedule| schedule.metadata.generation)
794 .collect();
795 assert_eq!(generations, vec![Some(1), Some(2), None]);
797 assert!(forwarded[1].spec.suspend);
798 }
799}