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::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
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/// Reduce a watcher event stream to the objects whose spec changed or that were deleted.
175///
176/// Status-only updates are dropped: the Kanidm reconciler reads only the spec of these objects,
177/// and their own controllers refresh status periodically (e.g. backup discovery rewrites
178/// `KanidmBackupSchedule.status.discovery.lastScanTime`), which would otherwise reconcile the
179/// Kanidm on every refresh.
180fn 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            // Deleting an object without finalizers does not bump its generation. Clear it so
189            // the generation predicate cannot evaluate it and always forwards the deletion.
190            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
276/// Initialize Kanidm controller and shared state
277pub 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    // TLS secrets are user-provided (e.g. created by cert-manager) and carry no
381    // kaniop label to filter on: watch metadata of `kubernetes.io/tls` secrets
382    // and let the mapper match them by name against the Kanidm store.
383    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    // Watch metadata of external ConfigMaps. Their data updates change resourceVersion,
399    // triggering a reconciliation and hash-based mail-sender rollout.
400    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    // Watch KanidmBackupSchedule and KanidmBackupRepository to trigger Kanidm reconciliation
407    // when backup configuration changes (e.g., schedule suspension, repository readiness).
408    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    // Repository status (readiness, usage lock) gates the backup transport, so status updates
421    // must keep triggering a Kanidm reconciliation.
422    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        // default secret name `{name}-tls`
622        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        // explicit `tlsSecretName`
627        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        // same name in another namespace does not match
632        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
633
634        // unrelated secret matches nothing
635        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        // created, spec changed, deleted
796        assert_eq!(generations, vec![Some(1), Some(2), None]);
797        assert!(forwarded[1].spec.suspend);
798    }
799}