Skip to main content

kaniop_operator/kanidm/controller/
mod.rs

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::ResourceExt;
31use kube::api::{Api, PartialObjectMeta};
32use kube::client::Client;
33use kube::runtime::controller::{self, Controller};
34use kube::runtime::reflector::ObjectRef;
35use kube::runtime::reflector::store::Writer;
36use kube::runtime::reflector::{ReflectHandle, Store};
37use kube::runtime::{WatchStreamExt, watcher};
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
97/// Map a TLS secret event to the Kanidm objects that mount it.
98///
99/// The TLS secret is user-provided (e.g. created by cert-manager), so it
100/// carries neither kaniop labels nor owner references pointing to the Kanidm:
101/// match by namespace and effective TLS secret name against the Kanidm store.
102fn 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
117/// User-owned CA ConfigMaps have no Kaniop owner reference or labels. Map
118/// their metadata events to Kanidm resources selecting that ConfigMap.
119fn 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
139/// Map a KanidmBackupSchedule event to the Kanidm object it references.
140/// The schedule's spec.kanidmRef.name identifies the target Kanidm in the same namespace.
141fn 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
156/// Map a KanidmBackupRepository event to all Kanidm objects in the same namespace.
157///
158/// Any Kanidm in the namespace might reference this repository through a schedule,
159/// so we trigger reconciliation for all of them.
160fn 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
174#[allow(clippy::too_many_arguments)]
175fn run_controller(
176    kanidm_watcher: impl futures::Stream<Item = Result<Kanidm, watcher::Error>> + Send + 'static,
177    kanidm_store: Store<Kanidm>,
178    statefulset_subscriber: ReflectHandle<StatefulSet>,
179    service_subscriber: ReflectHandle<Service>,
180    ingress_subscriber: ReflectHandle<Ingress>,
181    secret_subscriber: ReflectHandle<Secret>,
182    replica_cert_secret_subscriber: ReflectHandle<Secret>,
183    tls_secret_trigger: impl futures::Stream<Item = Result<PartialObjectMeta<Secret>, watcher::Error>>
184    + Send
185    + 'static,
186    mail_sender_ca_trigger: impl futures::Stream<
187        Item = Result<PartialObjectMeta<ConfigMap>, watcher::Error>,
188    > + Send
189    + 'static,
190    schedule_trigger: impl futures::Stream<Item = Result<KanidmBackupSchedule, watcher::Error>>
191    + Send
192    + 'static,
193    repository_trigger: impl futures::Stream<Item = Result<KanidmBackupRepository, watcher::Error>>
194    + Send
195    + 'static,
196    http_route_subscriber: Option<ReflectHandle<HttpRoute>>,
197    backend_tls_policy_subscriber: Option<ReflectHandle<BackendTlsPolicy>>,
198    deployment_subscriber: ReflectHandle<Deployment>,
199    config_map_subscriber: ReflectHandle<ConfigMap>,
200    reload_rx: mpsc::Receiver<()>,
201    ctx: Arc<Context>,
202) -> BoxFuture<'static, ()> {
203    let kanidm_store_for_tls = kanidm_store.clone();
204    let kanidm_store_for_mail_ca = kanidm_store.clone();
205    let kanidm_store_for_schedule = kanidm_store.clone();
206    let kanidm_store_for_repository = kanidm_store.clone();
207    let mut controller = Controller::for_stream(kanidm_watcher, kanidm_store)
208        .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
209        .owns_shared_stream(statefulset_subscriber)
210        .owns_shared_stream(service_subscriber)
211        .owns_shared_stream(ingress_subscriber)
212        .owns_shared_stream(secret_subscriber)
213        .owns_shared_stream(replica_cert_secret_subscriber)
214        .owns_shared_stream(deployment_subscriber)
215        .owns_shared_stream(config_map_subscriber)
216        .watches_stream(tls_secret_trigger, move |secret| {
217            map_tls_secret_to_kanidms(&kanidm_store_for_tls, &secret)
218        })
219        .watches_stream(mail_sender_ca_trigger, move |cm| {
220            map_mail_sender_ca_config_map_to_kanidms(&kanidm_store_for_mail_ca, &cm)
221        })
222        .watches_stream(schedule_trigger, move |schedule| {
223            map_schedule_to_kanidm(&kanidm_store_for_schedule, &schedule)
224        })
225        .watches_stream(repository_trigger, move |repository| {
226            map_repository_to_kanidms(&kanidm_store_for_repository, &repository)
227        });
228
229    if let Some(subscriber) = http_route_subscriber {
230        controller = controller.owns_shared_stream(subscriber);
231    }
232
233    if let Some(subscriber) = backend_tls_policy_subscriber {
234        controller = controller.owns_shared_stream(subscriber);
235    }
236
237    controller
238        .reconcile_all_on(reload_rx.map(|_| ()))
239        .shutdown_on_signal()
240        .run(
241            backoff_reconciler!(reconcile_kanidm),
242            |_obj, _error: &Error, _ctx| unreachable!(),
243            ctx,
244        )
245        .filter_map(|x| async move { std::result::Result::ok(x) })
246        .for_each(|_| futures::future::ready(()))
247        .boxed()
248}
249
250/// Initialize Kanidm controller and shared state
251pub async fn run(
252    state: State,
253    client: Client,
254    namespace_api: Api<Namespace>,
255    namespace_r: ResourceReflector<Namespace>,
256    kanidm_api: Api<Kanidm>,
257    kanidm_r: ResourceReflector<Kanidm>,
258) {
259    let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
260    let service = check_api_queryable::<Service>(client.clone()).await;
261    let ingress = check_api_queryable::<Ingress>(client.clone()).await;
262    let secret = check_api_queryable::<Secret>(client.clone()).await;
263    let http_route_api = check_api_queryable_optional::<HttpRoute>(client.clone()).await;
264    let backend_tls_policy_api =
265        check_api_queryable_optional::<BackendTlsPolicy>(client.clone()).await;
266    let deployment = check_api_queryable::<Deployment>(client.clone()).await;
267    let config_map = check_api_queryable::<ConfigMap>(client.clone()).await;
268
269    let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
270    let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
271    let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
272    let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
273    let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
274    let deployment_r = create_subscriber::<Deployment>(SUBSCRIBE_BUFFER_SIZE);
275    let config_map_r = create_subscriber::<ConfigMap>(SUBSCRIBE_BUFFER_SIZE);
276
277    let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
278
279    let http_route_r = if http_route_api.is_some() {
280        Some(create_subscriber::<HttpRoute>(SUBSCRIBE_BUFFER_SIZE))
281    } else {
282        None
283    };
284
285    let backend_tls_policy_r = if backend_tls_policy_api.is_some() {
286        Some(create_subscriber::<BackendTlsPolicy>(SUBSCRIBE_BUFFER_SIZE))
287    } else {
288        None
289    };
290
291    let stores = Stores {
292        stateful_set_store: statefulset_r.store,
293        service_store: service_r.store,
294        ingress_store: ingress_r.store,
295        secret_store: secret_r.store,
296        http_route_store: http_route_r.as_ref().map(|r| r.store.clone()),
297        backend_tls_policy_store: backend_tls_policy_r.as_ref().map(|r| r.store.clone()),
298        deployment_store: deployment_r.store,
299        config_map_store: config_map_r.store,
300    };
301
302    let ctx = Arc::new(Context::new(
303        state.to_context(client.clone(), CONTROLLER_ID),
304        stores,
305    ));
306    let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
307
308    let statefulset_watcher = create_watcher(
309        statefulset,
310        statefulset_r.writer,
311        reload_tx.clone(),
312        CONTROLLER_ID,
313        kaniop_ctx.clone(),
314    );
315    let service_watcher = create_watcher(
316        service,
317        service_r.writer,
318        reload_tx.clone(),
319        CONTROLLER_ID,
320        kaniop_ctx.clone(),
321    );
322    let ingress_watcher = create_watcher(
323        ingress,
324        ingress_r.writer,
325        reload_tx.clone(),
326        CONTROLLER_ID,
327        kaniop_ctx.clone(),
328    );
329    let secret_watcher = create_watcher(
330        secret.clone(),
331        secret_r.writer,
332        reload_tx.clone(),
333        CONTROLLER_ID,
334        kaniop_ctx.clone(),
335    );
336    let deployment_watcher = create_watcher(
337        deployment,
338        deployment_r.writer,
339        reload_tx.clone(),
340        CONTROLLER_ID,
341        kaniop_ctx.clone(),
342    );
343    let config_map_watcher = create_watcher(
344        config_map,
345        config_map_r.writer,
346        reload_tx.clone(),
347        CONTROLLER_ID,
348        kaniop_ctx.clone(),
349    );
350
351    let replica_cert_secrets_watcher =
352        create_replica_cert_watcher(secret.clone(), replica_cert_secret_r.writer, ctx.clone());
353
354    // TLS secrets are user-provided (e.g. created by cert-manager) and carry no
355    // kaniop label to filter on: watch metadata of `kubernetes.io/tls` secrets
356    // and let the mapper match them by name against the Kanidm store.
357    let tls_secret_metrics_ctx = kaniop_ctx.clone();
358    let tls_secret_api = Api::<PartialObjectMeta<Secret>>::all(client.clone());
359    let tls_secret_trigger = watcher(
360        tls_secret_api,
361        watcher::Config::default()
362            .fields("type=kubernetes.io/tls")
363            .any_semantic(),
364    )
365    .default_backoff()
366    .touched_objects()
367    .inspect_err(move |e| {
368        error!(error = %e, "unexpected error when watching TLS secrets");
369        tls_secret_metrics_ctx.metrics.watch_operations_failed_inc();
370    });
371
372    // Watch metadata of external ConfigMaps. Their data updates change resourceVersion,
373    // triggering a reconciliation and hash-based mail-sender rollout.
374    let ca_config_map_api = Api::<PartialObjectMeta<ConfigMap>>::all(client.clone());
375    let mail_sender_ca_trigger =
376        watcher(ca_config_map_api, watcher::Config::default().any_semantic())
377            .default_backoff()
378            .touched_objects();
379
380    // Watch KanidmBackupSchedule and KanidmBackupRepository to trigger Kanidm reconciliation
381    // when backup configuration changes (e.g., schedule suspension, repository readiness).
382    let schedule_api = check_api_queryable_optional::<KanidmBackupSchedule>(client.clone()).await;
383    let repository_api =
384        check_api_queryable_optional::<KanidmBackupRepository>(client.clone()).await;
385
386    let schedule_trigger = match schedule_api {
387        Some(api) => watcher(api, watcher::Config::default().any_semantic())
388            .default_backoff()
389            .touched_objects()
390            .boxed(),
391        None => futures::stream::pending().boxed(),
392    };
393
394    let repository_trigger = match repository_api {
395        Some(api) => watcher(api, watcher::Config::default().any_semantic())
396            .default_backoff()
397            .touched_objects()
398            .boxed(),
399        None => futures::stream::pending().boxed(),
400    };
401
402    let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
403        .default_backoff()
404        .reflect(namespace_r.writer)
405        .for_each(|res| {
406            let ctx = ctx.clone();
407            async move {
408                match res {
409                    Ok(event) => trace!(?event, "received namespace event"),
410                    Err(e) => {
411                        error!(error = %e, "unexpected error when watching namespace");
412                        ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
413                    }
414                }
415            }
416        });
417
418    info!(controller = CONTROLLER_ID, "starting controller");
419    let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
420        .default_backoff()
421        .reflect(kanidm_r.writer)
422        .touched_objects();
423
424    let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
425        (Some(api), Some(r)) => {
426            let watcher = create_watcher(
427                api,
428                r.writer,
429                reload_tx.clone(),
430                CONTROLLER_ID,
431                kaniop_ctx.clone(),
432            );
433            (Some(watcher), Some(r.subscriber))
434        }
435        _ => (None, None),
436    };
437
438    let (backend_tls_policy_watcher, backend_tls_policy_subscriber) =
439        match (backend_tls_policy_api, backend_tls_policy_r) {
440            (Some(api), Some(r)) => {
441                let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
442                (Some(watcher), Some(r.subscriber))
443            }
444            _ => (None, None),
445        };
446
447    let kanidm_controller = run_controller(
448        kanidm_watcher,
449        kanidm_r.store,
450        statefulset_r.subscriber,
451        service_r.subscriber,
452        ingress_r.subscriber,
453        secret_r.subscriber,
454        replica_cert_secret_r.subscriber,
455        tls_secret_trigger,
456        mail_sender_ca_trigger,
457        schedule_trigger,
458        repository_trigger,
459        http_route_subscriber,
460        backend_tls_policy_subscriber,
461        deployment_r.subscriber,
462        config_map_r.subscriber,
463        reload_rx,
464        ctx.clone(),
465    );
466
467    ctx.kaniop_ctx.metrics.ready_set(1);
468    tokio::select! {
469        _ = kanidm_controller => {},
470        _ = namespace_watcher => {},
471        _ = statefulset_watcher => {},
472        _ = service_watcher => {},
473        _ = ingress_watcher => {},
474        _ = secret_watcher => {},
475        _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
476        _ = backend_tls_policy_watcher.unwrap_or(futures::future::pending().boxed()) => {},
477        _ = replica_cert_secrets_watcher => {},
478        _ = deployment_watcher => {},
479        _ = config_map_watcher => {},
480    }
481}
482
483#[cfg(test)]
484mod tests {
485    use super::{
486        map_mail_sender_ca_config_map_to_kanidms, map_repository_to_kanidms,
487        map_schedule_to_kanidm, map_tls_secret_to_kanidms,
488    };
489    use crate::kanidm::crd::{CaBundleRef, Kanidm, KanidmSpec, MailSenderSpec};
490
491    use k8s_openapi::api::core::v1::{ConfigMap, Secret};
492    use kaniop_backup_core::crd::{
493        AuthMethod, KanidmBackupRepository, KanidmBackupRepositorySpec, KanidmBackupSchedule,
494        KanidmBackupScheduleSpec, RepositoryAuthentication, S3Config, ScheduleKanidmRef,
495        ScheduleRepositoryRef, SecretRef,
496    };
497    use kube::api::{ObjectMeta, PartialObjectMeta};
498    use kube::runtime::reflector;
499    use kube::runtime::watcher;
500
501    fn kanidm(name: &str, namespace: &str, tls_secret_name: Option<&str>) -> Kanidm {
502        Kanidm {
503            metadata: ObjectMeta {
504                name: Some(name.to_string()),
505                namespace: Some(namespace.to_string()),
506                ..Default::default()
507            },
508            spec: KanidmSpec {
509                domain: "idm.example.com".to_string(),
510                tls_secret_name: tls_secret_name.map(str::to_string),
511                ..Default::default()
512            },
513            ..Default::default()
514        }
515    }
516
517    fn secret_meta(name: &str, namespace: &str) -> PartialObjectMeta<Secret> {
518        PartialObjectMeta {
519            metadata: ObjectMeta {
520                name: Some(name.to_string()),
521                namespace: Some(namespace.to_string()),
522                ..Default::default()
523            },
524            ..Default::default()
525        }
526    }
527
528    #[test]
529    fn test_map_mail_sender_ca_config_map_to_kanidms() {
530        let (store, mut writer) = reflector::store();
531        let mut a = kanidm("a", "ns1", None);
532        a.spec.mail_sender = Some(MailSenderSpec {
533            ca_bundle_ref: Some(CaBundleRef {
534                name: "shared-ca".into(),
535                key: "ca.crt".into(),
536            }),
537            ..Default::default()
538        });
539        writer.apply_watcher_event(&watcher::Event::Apply(a));
540
541        let mut b = kanidm("b", "ns1", None);
542        b.spec.mail_sender = Some(MailSenderSpec {
543            ca_bundle_ref: Some(CaBundleRef {
544                name: "other-ca".into(),
545                key: "ca.crt".into(),
546            }),
547            ..Default::default()
548        });
549        writer.apply_watcher_event(&watcher::Event::Apply(b));
550
551        let mut c = kanidm("c", "ns2", None);
552        c.spec.mail_sender = Some(MailSenderSpec {
553            ca_bundle_ref: Some(CaBundleRef {
554                name: "shared-ca".into(),
555                key: "ca.crt".into(),
556            }),
557            ..Default::default()
558        });
559        writer.apply_watcher_event(&watcher::Event::Apply(c));
560        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("d", "ns1", None)));
561
562        let cm = |name: &str, namespace: &str| PartialObjectMeta::<ConfigMap> {
563            metadata: ObjectMeta {
564                name: Some(name.to_string()),
565                namespace: Some(namespace.to_string()),
566                ..Default::default()
567            },
568            ..Default::default()
569        };
570        let refs = map_mail_sender_ca_config_map_to_kanidms(&store, &cm("shared-ca", "ns1"));
571        assert_eq!(refs.len(), 1);
572        assert_eq!(refs[0].name, "a");
573        assert!(
574            map_mail_sender_ca_config_map_to_kanidms(&store, &cm("shared-ca", "ns3")).is_empty()
575        );
576        assert!(
577            map_mail_sender_ca_config_map_to_kanidms(&store, &cm("unrelated", "ns1")).is_empty()
578        );
579    }
580
581    #[test]
582    fn test_map_tls_secret_to_kanidms() {
583        let (store, mut writer) = reflector::store();
584        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
585        writer.apply_watcher_event(&watcher::Event::Apply(kanidm(
586            "b",
587            "ns1",
588            Some("custom-tls"),
589        )));
590        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
591
592        // default secret name `{name}-tls`
593        let refs = map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns1"));
594        assert_eq!(refs.len(), 1);
595        assert_eq!(refs[0].name, "a");
596
597        // explicit `tlsSecretName`
598        let refs = map_tls_secret_to_kanidms(&store, &secret_meta("custom-tls", "ns1"));
599        assert_eq!(refs.len(), 1);
600        assert_eq!(refs[0].name, "b");
601
602        // same name in another namespace does not match
603        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
604
605        // unrelated secret matches nothing
606        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
607    }
608
609    fn schedule(name: &str, namespace: &str, kanidm_name: &str) -> KanidmBackupSchedule {
610        KanidmBackupSchedule {
611            metadata: ObjectMeta {
612                name: Some(name.to_string()),
613                namespace: Some(namespace.to_string()),
614                ..Default::default()
615            },
616            spec: KanidmBackupScheduleSpec {
617                kanidm_ref: ScheduleKanidmRef {
618                    name: kanidm_name.to_string(),
619                },
620                repository_ref: ScheduleRepositoryRef {
621                    name: "repo".to_string(),
622                },
623                schedule: "0 2 * * *".to_string(),
624                time_zone: "UTC".to_string(),
625                suspend: false,
626                concurrency_policy: "Forbid".to_string(),
627                jitter_seconds: None,
628                local_versions: 7,
629                retention: None,
630            },
631            status: None,
632        }
633    }
634
635    fn repository(name: &str, namespace: &str) -> KanidmBackupRepository {
636        KanidmBackupRepository {
637            metadata: ObjectMeta {
638                name: Some(name.to_string()),
639                namespace: Some(namespace.to_string()),
640                ..Default::default()
641            },
642            spec: KanidmBackupRepositorySpec {
643                s3: S3Config {
644                    bucket: "bucket".to_string(),
645                    prefix: "".to_string(),
646                    region: String::new(),
647                    endpoint: String::new(),
648                    force_path_style: false,
649                    ca_bundle_ref: None,
650                    insecure: false,
651                },
652                authentication: RepositoryAuthentication {
653                    writer: AuthMethod {
654                        workload_identity: None,
655                        secret_ref: Some(SecretRef {
656                            name: "s".to_string(),
657                        }),
658                    },
659                    reader: AuthMethod {
660                        workload_identity: None,
661                        secret_ref: Some(SecretRef {
662                            name: "s".to_string(),
663                        }),
664                    },
665                    deleter: AuthMethod {
666                        workload_identity: None,
667                        secret_ref: Some(SecretRef {
668                            name: "s".to_string(),
669                        }),
670                    },
671                },
672                encryption: None,
673                limits: None,
674            },
675            status: None,
676        }
677    }
678
679    #[test]
680    fn test_map_schedule_to_kanidm_correct_ref() {
681        let (store, mut writer) = reflector::store();
682        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
683        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
684
685        let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "a"));
686        assert_eq!(refs.len(), 1);
687        assert_eq!(refs[0].name, "a");
688    }
689
690    #[test]
691    fn test_map_schedule_to_kanidm_wrong_namespace() {
692        let (store, mut writer) = reflector::store();
693        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
694
695        let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns2", "a"));
696        assert!(refs.is_empty());
697    }
698
699    #[test]
700    fn test_map_schedule_to_kanidm_other_kanidm() {
701        let (store, mut writer) = reflector::store();
702        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
703
704        let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "nonexistent"));
705        assert!(refs.is_empty());
706    }
707
708    #[test]
709    fn test_map_repository_to_kanidms_fans_out() {
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        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
714
715        let refs = map_repository_to_kanidms(&store, &repository("repo", "ns1"));
716        assert_eq!(refs.len(), 2);
717        let names: Vec<_> = refs.iter().map(|r| r.name.as_str()).collect();
718        assert!(names.contains(&"a"));
719        assert!(names.contains(&"b"));
720    }
721
722    #[test]
723    fn test_map_repository_to_kanidms_ignores_other_namespaces() {
724        let (store, mut writer) = reflector::store();
725        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
726
727        let refs = map_repository_to_kanidms(&store, &repository("repo", "ns2"));
728        assert!(refs.is_empty());
729    }
730}