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
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
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
250pub 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 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 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 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 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 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 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
604
605 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}