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, metadata_watcher, 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_schedule_to_kanidm(
121 kanidm_store: &Store<Kanidm>,
122 schedule: &KanidmBackupSchedule,
123) -> Vec<ObjectRef<Kanidm>> {
124 let namespace = schedule.namespace();
125 let kanidm_name = &schedule.spec.kanidm_ref.name;
126
127 kanidm_store
128 .state()
129 .into_iter()
130 .filter(|kanidm| kanidm.namespace() == namespace && kanidm.name_any() == *kanidm_name)
131 .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
132 .collect()
133}
134
135fn map_repository_to_kanidms(
140 kanidm_store: &Store<Kanidm>,
141 repository: &KanidmBackupRepository,
142) -> Vec<ObjectRef<Kanidm>> {
143 let namespace = repository.namespace();
144
145 kanidm_store
146 .state()
147 .into_iter()
148 .filter(|kanidm| kanidm.namespace() == namespace)
149 .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
150 .collect()
151}
152
153#[allow(clippy::too_many_arguments)]
154fn run_controller(
155 kanidm_watcher: impl futures::Stream<Item = Result<Kanidm, watcher::Error>> + Send + 'static,
156 kanidm_store: Store<Kanidm>,
157 statefulset_subscriber: ReflectHandle<StatefulSet>,
158 service_subscriber: ReflectHandle<Service>,
159 ingress_subscriber: ReflectHandle<Ingress>,
160 secret_subscriber: ReflectHandle<Secret>,
161 replica_cert_secret_subscriber: ReflectHandle<Secret>,
162 tls_secret_trigger: impl futures::Stream<Item = Result<PartialObjectMeta<Secret>, watcher::Error>>
163 + Send
164 + 'static,
165 schedule_trigger: impl futures::Stream<Item = Result<KanidmBackupSchedule, watcher::Error>>
166 + Send
167 + 'static,
168 repository_trigger: impl futures::Stream<Item = Result<KanidmBackupRepository, watcher::Error>>
169 + Send
170 + 'static,
171 http_route_subscriber: Option<ReflectHandle<HTTPRoute>>,
172 backend_tls_policy_subscriber: Option<ReflectHandle<BackendTLSPolicy>>,
173 deployment_subscriber: ReflectHandle<Deployment>,
174 config_map_subscriber: ReflectHandle<ConfigMap>,
175 reload_rx: mpsc::Receiver<()>,
176 ctx: Arc<Context>,
177) -> BoxFuture<'static, ()> {
178 let kanidm_store_for_tls = kanidm_store.clone();
179 let kanidm_store_for_schedule = kanidm_store.clone();
180 let kanidm_store_for_repository = kanidm_store.clone();
181 let mut controller = Controller::for_stream(kanidm_watcher, kanidm_store)
182 .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
183 .owns_shared_stream(statefulset_subscriber)
184 .owns_shared_stream(service_subscriber)
185 .owns_shared_stream(ingress_subscriber)
186 .owns_shared_stream(secret_subscriber)
187 .owns_shared_stream(replica_cert_secret_subscriber)
188 .owns_shared_stream(deployment_subscriber)
189 .owns_shared_stream(config_map_subscriber)
190 .watches_stream(tls_secret_trigger, move |secret| {
191 map_tls_secret_to_kanidms(&kanidm_store_for_tls, &secret)
192 })
193 .watches_stream(schedule_trigger, move |schedule| {
194 map_schedule_to_kanidm(&kanidm_store_for_schedule, &schedule)
195 })
196 .watches_stream(repository_trigger, move |repository| {
197 map_repository_to_kanidms(&kanidm_store_for_repository, &repository)
198 });
199
200 if let Some(subscriber) = http_route_subscriber {
201 controller = controller.owns_shared_stream(subscriber);
202 }
203
204 if let Some(subscriber) = backend_tls_policy_subscriber {
205 controller = controller.owns_shared_stream(subscriber);
206 }
207
208 controller
209 .reconcile_all_on(reload_rx.map(|_| ()))
210 .shutdown_on_signal()
211 .run(
212 backoff_reconciler!(reconcile_kanidm),
213 |_obj, _error: &Error, _ctx| unreachable!(),
214 ctx,
215 )
216 .filter_map(|x| async move { std::result::Result::ok(x) })
217 .for_each(|_| futures::future::ready(()))
218 .boxed()
219}
220
221pub async fn run(
223 state: State,
224 client: Client,
225 namespace_api: Api<Namespace>,
226 namespace_r: ResourceReflector<Namespace>,
227 kanidm_api: Api<Kanidm>,
228 kanidm_r: ResourceReflector<Kanidm>,
229) {
230 let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
231 let service = check_api_queryable::<Service>(client.clone()).await;
232 let ingress = check_api_queryable::<Ingress>(client.clone()).await;
233 let secret = check_api_queryable::<Secret>(client.clone()).await;
234 let http_route_api = check_api_queryable_optional::<HTTPRoute>(client.clone()).await;
235 let backend_tls_policy_api =
236 check_api_queryable_optional::<BackendTLSPolicy>(client.clone()).await;
237 let deployment = check_api_queryable::<Deployment>(client.clone()).await;
238 let config_map = check_api_queryable::<ConfigMap>(client.clone()).await;
239
240 let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
241 let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
242 let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
243 let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
244 let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
245 let deployment_r = create_subscriber::<Deployment>(SUBSCRIBE_BUFFER_SIZE);
246 let config_map_r = create_subscriber::<ConfigMap>(SUBSCRIBE_BUFFER_SIZE);
247
248 let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
249
250 let http_route_r = if http_route_api.is_some() {
251 Some(create_subscriber::<HTTPRoute>(SUBSCRIBE_BUFFER_SIZE))
252 } else {
253 None
254 };
255
256 let backend_tls_policy_r = if backend_tls_policy_api.is_some() {
257 Some(create_subscriber::<BackendTLSPolicy>(SUBSCRIBE_BUFFER_SIZE))
258 } else {
259 None
260 };
261
262 let stores = Stores {
263 stateful_set_store: statefulset_r.store,
264 service_store: service_r.store,
265 ingress_store: ingress_r.store,
266 secret_store: secret_r.store,
267 http_route_store: http_route_r.as_ref().map(|r| r.store.clone()),
268 backend_tls_policy_store: backend_tls_policy_r.as_ref().map(|r| r.store.clone()),
269 deployment_store: deployment_r.store,
270 config_map_store: config_map_r.store,
271 };
272
273 let ctx = Arc::new(Context::new(
274 state.to_context(client.clone(), CONTROLLER_ID),
275 stores,
276 ));
277 let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
278
279 let statefulset_watcher = create_watcher(
280 statefulset,
281 statefulset_r.writer,
282 reload_tx.clone(),
283 CONTROLLER_ID,
284 kaniop_ctx.clone(),
285 );
286 let service_watcher = create_watcher(
287 service,
288 service_r.writer,
289 reload_tx.clone(),
290 CONTROLLER_ID,
291 kaniop_ctx.clone(),
292 );
293 let ingress_watcher = create_watcher(
294 ingress,
295 ingress_r.writer,
296 reload_tx.clone(),
297 CONTROLLER_ID,
298 kaniop_ctx.clone(),
299 );
300 let secret_watcher = create_watcher(
301 secret.clone(),
302 secret_r.writer,
303 reload_tx.clone(),
304 CONTROLLER_ID,
305 kaniop_ctx.clone(),
306 );
307 let deployment_watcher = create_watcher(
308 deployment,
309 deployment_r.writer,
310 reload_tx.clone(),
311 CONTROLLER_ID,
312 kaniop_ctx.clone(),
313 );
314 let config_map_watcher = create_watcher(
315 config_map,
316 config_map_r.writer,
317 reload_tx.clone(),
318 CONTROLLER_ID,
319 kaniop_ctx.clone(),
320 );
321
322 let replica_cert_secrets_watcher =
323 create_replica_cert_watcher(secret.clone(), replica_cert_secret_r.writer, ctx.clone());
324
325 let tls_secret_metrics_ctx = kaniop_ctx.clone();
329 let tls_secret_trigger = metadata_watcher(
330 secret,
331 watcher::Config::default()
332 .fields("type=kubernetes.io/tls")
333 .any_semantic(),
334 )
335 .default_backoff()
336 .touched_objects()
337 .inspect_err(move |e| {
338 error!(error = %e, "unexpected error when watching TLS secrets");
339 tls_secret_metrics_ctx.metrics.watch_operations_failed_inc();
340 });
341
342 let schedule_api = check_api_queryable_optional::<KanidmBackupSchedule>(client.clone()).await;
345 let repository_api =
346 check_api_queryable_optional::<KanidmBackupRepository>(client.clone()).await;
347
348 let schedule_trigger = match schedule_api {
349 Some(api) => watcher(api, watcher::Config::default().any_semantic())
350 .default_backoff()
351 .touched_objects()
352 .boxed(),
353 None => futures::stream::pending().boxed(),
354 };
355
356 let repository_trigger = match repository_api {
357 Some(api) => watcher(api, watcher::Config::default().any_semantic())
358 .default_backoff()
359 .touched_objects()
360 .boxed(),
361 None => futures::stream::pending().boxed(),
362 };
363
364 let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
365 .default_backoff()
366 .reflect(namespace_r.writer)
367 .for_each(|res| {
368 let ctx = ctx.clone();
369 async move {
370 match res {
371 Ok(event) => trace!(?event, "received namespace event"),
372 Err(e) => {
373 error!(error = %e, "unexpected error when watching namespace");
374 ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
375 }
376 }
377 }
378 });
379
380 info!(controller = CONTROLLER_ID, "starting controller");
381 let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
382 .default_backoff()
383 .reflect(kanidm_r.writer)
384 .touched_objects();
385
386 let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
387 (Some(api), Some(r)) => {
388 let watcher = create_watcher(
389 api,
390 r.writer,
391 reload_tx.clone(),
392 CONTROLLER_ID,
393 kaniop_ctx.clone(),
394 );
395 (Some(watcher), Some(r.subscriber))
396 }
397 _ => (None, None),
398 };
399
400 let (backend_tls_policy_watcher, backend_tls_policy_subscriber) =
401 match (backend_tls_policy_api, backend_tls_policy_r) {
402 (Some(api), Some(r)) => {
403 let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
404 (Some(watcher), Some(r.subscriber))
405 }
406 _ => (None, None),
407 };
408
409 let kanidm_controller = run_controller(
410 kanidm_watcher,
411 kanidm_r.store,
412 statefulset_r.subscriber,
413 service_r.subscriber,
414 ingress_r.subscriber,
415 secret_r.subscriber,
416 replica_cert_secret_r.subscriber,
417 tls_secret_trigger,
418 schedule_trigger,
419 repository_trigger,
420 http_route_subscriber,
421 backend_tls_policy_subscriber,
422 deployment_r.subscriber,
423 config_map_r.subscriber,
424 reload_rx,
425 ctx.clone(),
426 );
427
428 ctx.kaniop_ctx.metrics.ready_set(1);
429 tokio::select! {
430 _ = kanidm_controller => {},
431 _ = namespace_watcher => {},
432 _ = statefulset_watcher => {},
433 _ = service_watcher => {},
434 _ = ingress_watcher => {},
435 _ = secret_watcher => {},
436 _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
437 _ = backend_tls_policy_watcher.unwrap_or(futures::future::pending().boxed()) => {},
438 _ = replica_cert_secrets_watcher => {},
439 _ = deployment_watcher => {},
440 _ = config_map_watcher => {},
441 }
442}
443
444#[cfg(test)]
445mod tests {
446 use super::{map_repository_to_kanidms, map_schedule_to_kanidm, map_tls_secret_to_kanidms};
447 use crate::kanidm::crd::{Kanidm, KanidmSpec};
448
449 use k8s_openapi::api::core::v1::Secret;
450 use kaniop_backup_core::crd::{
451 AuthMethod, KanidmBackupRepository, KanidmBackupRepositorySpec, KanidmBackupSchedule,
452 KanidmBackupScheduleSpec, RepositoryAuthentication, S3Config, ScheduleKanidmRef,
453 ScheduleRepositoryRef, SecretRef,
454 };
455 use kube::api::{ObjectMeta, PartialObjectMeta};
456 use kube::runtime::reflector;
457 use kube::runtime::watcher;
458
459 fn kanidm(name: &str, namespace: &str, tls_secret_name: Option<&str>) -> Kanidm {
460 Kanidm {
461 metadata: ObjectMeta {
462 name: Some(name.to_string()),
463 namespace: Some(namespace.to_string()),
464 ..Default::default()
465 },
466 spec: KanidmSpec {
467 domain: "idm.example.com".to_string(),
468 tls_secret_name: tls_secret_name.map(str::to_string),
469 ..Default::default()
470 },
471 ..Default::default()
472 }
473 }
474
475 fn secret_meta(name: &str, namespace: &str) -> PartialObjectMeta<Secret> {
476 PartialObjectMeta {
477 metadata: ObjectMeta {
478 name: Some(name.to_string()),
479 namespace: Some(namespace.to_string()),
480 ..Default::default()
481 },
482 ..Default::default()
483 }
484 }
485
486 #[test]
487 fn test_map_tls_secret_to_kanidms() {
488 let (store, mut writer) = reflector::store();
489 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
490 writer.apply_watcher_event(&watcher::Event::Apply(kanidm(
491 "b",
492 "ns1",
493 Some("custom-tls"),
494 )));
495 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
496
497 let refs = map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns1"));
499 assert_eq!(refs.len(), 1);
500 assert_eq!(refs[0].name, "a");
501
502 let refs = map_tls_secret_to_kanidms(&store, &secret_meta("custom-tls", "ns1"));
504 assert_eq!(refs.len(), 1);
505 assert_eq!(refs[0].name, "b");
506
507 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
509
510 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
512 }
513
514 fn schedule(name: &str, namespace: &str, kanidm_name: &str) -> KanidmBackupSchedule {
515 KanidmBackupSchedule {
516 metadata: ObjectMeta {
517 name: Some(name.to_string()),
518 namespace: Some(namespace.to_string()),
519 ..Default::default()
520 },
521 spec: KanidmBackupScheduleSpec {
522 kanidm_ref: ScheduleKanidmRef {
523 name: kanidm_name.to_string(),
524 },
525 repository_ref: ScheduleRepositoryRef {
526 name: "repo".to_string(),
527 },
528 schedule: "0 2 * * *".to_string(),
529 time_zone: "UTC".to_string(),
530 suspend: false,
531 concurrency_policy: "Forbid".to_string(),
532 jitter_seconds: None,
533 local_versions: 7,
534 retention: None,
535 },
536 status: None,
537 }
538 }
539
540 fn repository(name: &str, namespace: &str) -> KanidmBackupRepository {
541 KanidmBackupRepository {
542 metadata: ObjectMeta {
543 name: Some(name.to_string()),
544 namespace: Some(namespace.to_string()),
545 ..Default::default()
546 },
547 spec: KanidmBackupRepositorySpec {
548 s3: S3Config {
549 bucket: "bucket".to_string(),
550 prefix: "".to_string(),
551 region: String::new(),
552 endpoint: String::new(),
553 force_path_style: false,
554 ca_bundle_ref: None,
555 insecure: false,
556 },
557 authentication: RepositoryAuthentication {
558 writer: AuthMethod {
559 workload_identity: None,
560 secret_ref: Some(SecretRef {
561 name: "s".to_string(),
562 }),
563 },
564 reader: AuthMethod {
565 workload_identity: None,
566 secret_ref: Some(SecretRef {
567 name: "s".to_string(),
568 }),
569 },
570 deleter: AuthMethod {
571 workload_identity: None,
572 secret_ref: Some(SecretRef {
573 name: "s".to_string(),
574 }),
575 },
576 },
577 encryption: None,
578 limits: None,
579 },
580 status: None,
581 }
582 }
583
584 #[test]
585 fn test_map_schedule_to_kanidm_correct_ref() {
586 let (store, mut writer) = reflector::store();
587 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
588 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
589
590 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "a"));
591 assert_eq!(refs.len(), 1);
592 assert_eq!(refs[0].name, "a");
593 }
594
595 #[test]
596 fn test_map_schedule_to_kanidm_wrong_namespace() {
597 let (store, mut writer) = reflector::store();
598 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
599
600 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns2", "a"));
601 assert!(refs.is_empty());
602 }
603
604 #[test]
605 fn test_map_schedule_to_kanidm_other_kanidm() {
606 let (store, mut writer) = reflector::store();
607 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
608
609 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "nonexistent"));
610 assert!(refs.is_empty());
611 }
612
613 #[test]
614 fn test_map_repository_to_kanidms_fans_out() {
615 let (store, mut writer) = reflector::store();
616 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
617 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
618 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
619
620 let refs = map_repository_to_kanidms(&store, &repository("repo", "ns1"));
621 assert_eq!(refs.len(), 2);
622 let names: Vec<_> = refs.iter().map(|r| r.name.as_str()).collect();
623 assert!(names.contains(&"a"));
624 assert!(names.contains(&"b"));
625 }
626
627 #[test]
628 fn test_map_repository_to_kanidms_ignores_other_namespaces() {
629 let (store, mut writer) = reflector::store();
630 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
631
632 let refs = map_repository_to_kanidms(&store, &repository("repo", "ns2"));
633 assert!(refs.is_empty());
634 }
635}