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_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_api = Api::<PartialObjectMeta<Secret>>::all(client.clone());
330 let tls_secret_trigger = watcher(
331 tls_secret_api,
332 watcher::Config::default()
333 .fields("type=kubernetes.io/tls")
334 .any_semantic(),
335 )
336 .default_backoff()
337 .touched_objects()
338 .inspect_err(move |e| {
339 error!(error = %e, "unexpected error when watching TLS secrets");
340 tls_secret_metrics_ctx.metrics.watch_operations_failed_inc();
341 });
342
343 let schedule_api = check_api_queryable_optional::<KanidmBackupSchedule>(client.clone()).await;
346 let repository_api =
347 check_api_queryable_optional::<KanidmBackupRepository>(client.clone()).await;
348
349 let schedule_trigger = match schedule_api {
350 Some(api) => watcher(api, watcher::Config::default().any_semantic())
351 .default_backoff()
352 .touched_objects()
353 .boxed(),
354 None => futures::stream::pending().boxed(),
355 };
356
357 let repository_trigger = match repository_api {
358 Some(api) => watcher(api, watcher::Config::default().any_semantic())
359 .default_backoff()
360 .touched_objects()
361 .boxed(),
362 None => futures::stream::pending().boxed(),
363 };
364
365 let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
366 .default_backoff()
367 .reflect(namespace_r.writer)
368 .for_each(|res| {
369 let ctx = ctx.clone();
370 async move {
371 match res {
372 Ok(event) => trace!(?event, "received namespace event"),
373 Err(e) => {
374 error!(error = %e, "unexpected error when watching namespace");
375 ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
376 }
377 }
378 }
379 });
380
381 info!(controller = CONTROLLER_ID, "starting controller");
382 let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
383 .default_backoff()
384 .reflect(kanidm_r.writer)
385 .touched_objects();
386
387 let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
388 (Some(api), Some(r)) => {
389 let watcher = create_watcher(
390 api,
391 r.writer,
392 reload_tx.clone(),
393 CONTROLLER_ID,
394 kaniop_ctx.clone(),
395 );
396 (Some(watcher), Some(r.subscriber))
397 }
398 _ => (None, None),
399 };
400
401 let (backend_tls_policy_watcher, backend_tls_policy_subscriber) =
402 match (backend_tls_policy_api, backend_tls_policy_r) {
403 (Some(api), Some(r)) => {
404 let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
405 (Some(watcher), Some(r.subscriber))
406 }
407 _ => (None, None),
408 };
409
410 let kanidm_controller = run_controller(
411 kanidm_watcher,
412 kanidm_r.store,
413 statefulset_r.subscriber,
414 service_r.subscriber,
415 ingress_r.subscriber,
416 secret_r.subscriber,
417 replica_cert_secret_r.subscriber,
418 tls_secret_trigger,
419 schedule_trigger,
420 repository_trigger,
421 http_route_subscriber,
422 backend_tls_policy_subscriber,
423 deployment_r.subscriber,
424 config_map_r.subscriber,
425 reload_rx,
426 ctx.clone(),
427 );
428
429 ctx.kaniop_ctx.metrics.ready_set(1);
430 tokio::select! {
431 _ = kanidm_controller => {},
432 _ = namespace_watcher => {},
433 _ = statefulset_watcher => {},
434 _ = service_watcher => {},
435 _ = ingress_watcher => {},
436 _ = secret_watcher => {},
437 _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
438 _ = backend_tls_policy_watcher.unwrap_or(futures::future::pending().boxed()) => {},
439 _ = replica_cert_secrets_watcher => {},
440 _ = deployment_watcher => {},
441 _ = config_map_watcher => {},
442 }
443}
444
445#[cfg(test)]
446mod tests {
447 use super::{map_repository_to_kanidms, map_schedule_to_kanidm, map_tls_secret_to_kanidms};
448 use crate::kanidm::crd::{Kanidm, KanidmSpec};
449
450 use k8s_openapi::api::core::v1::Secret;
451 use kaniop_backup_core::crd::{
452 AuthMethod, KanidmBackupRepository, KanidmBackupRepositorySpec, KanidmBackupSchedule,
453 KanidmBackupScheduleSpec, RepositoryAuthentication, S3Config, ScheduleKanidmRef,
454 ScheduleRepositoryRef, SecretRef,
455 };
456 use kube::api::{ObjectMeta, PartialObjectMeta};
457 use kube::runtime::reflector;
458 use kube::runtime::watcher;
459
460 fn kanidm(name: &str, namespace: &str, tls_secret_name: Option<&str>) -> Kanidm {
461 Kanidm {
462 metadata: ObjectMeta {
463 name: Some(name.to_string()),
464 namespace: Some(namespace.to_string()),
465 ..Default::default()
466 },
467 spec: KanidmSpec {
468 domain: "idm.example.com".to_string(),
469 tls_secret_name: tls_secret_name.map(str::to_string),
470 ..Default::default()
471 },
472 ..Default::default()
473 }
474 }
475
476 fn secret_meta(name: &str, namespace: &str) -> PartialObjectMeta<Secret> {
477 PartialObjectMeta {
478 metadata: ObjectMeta {
479 name: Some(name.to_string()),
480 namespace: Some(namespace.to_string()),
481 ..Default::default()
482 },
483 ..Default::default()
484 }
485 }
486
487 #[test]
488 fn test_map_tls_secret_to_kanidms() {
489 let (store, mut writer) = reflector::store();
490 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
491 writer.apply_watcher_event(&watcher::Event::Apply(kanidm(
492 "b",
493 "ns1",
494 Some("custom-tls"),
495 )));
496 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
497
498 let refs = map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns1"));
500 assert_eq!(refs.len(), 1);
501 assert_eq!(refs[0].name, "a");
502
503 let refs = map_tls_secret_to_kanidms(&store, &secret_meta("custom-tls", "ns1"));
505 assert_eq!(refs.len(), 1);
506 assert_eq!(refs[0].name, "b");
507
508 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
510
511 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
513 }
514
515 fn schedule(name: &str, namespace: &str, kanidm_name: &str) -> KanidmBackupSchedule {
516 KanidmBackupSchedule {
517 metadata: ObjectMeta {
518 name: Some(name.to_string()),
519 namespace: Some(namespace.to_string()),
520 ..Default::default()
521 },
522 spec: KanidmBackupScheduleSpec {
523 kanidm_ref: ScheduleKanidmRef {
524 name: kanidm_name.to_string(),
525 },
526 repository_ref: ScheduleRepositoryRef {
527 name: "repo".to_string(),
528 },
529 schedule: "0 2 * * *".to_string(),
530 time_zone: "UTC".to_string(),
531 suspend: false,
532 concurrency_policy: "Forbid".to_string(),
533 jitter_seconds: None,
534 local_versions: 7,
535 retention: None,
536 },
537 status: None,
538 }
539 }
540
541 fn repository(name: &str, namespace: &str) -> KanidmBackupRepository {
542 KanidmBackupRepository {
543 metadata: ObjectMeta {
544 name: Some(name.to_string()),
545 namespace: Some(namespace.to_string()),
546 ..Default::default()
547 },
548 spec: KanidmBackupRepositorySpec {
549 s3: S3Config {
550 bucket: "bucket".to_string(),
551 prefix: "".to_string(),
552 region: String::new(),
553 endpoint: String::new(),
554 force_path_style: false,
555 ca_bundle_ref: None,
556 insecure: false,
557 },
558 authentication: RepositoryAuthentication {
559 writer: AuthMethod {
560 workload_identity: None,
561 secret_ref: Some(SecretRef {
562 name: "s".to_string(),
563 }),
564 },
565 reader: AuthMethod {
566 workload_identity: None,
567 secret_ref: Some(SecretRef {
568 name: "s".to_string(),
569 }),
570 },
571 deleter: AuthMethod {
572 workload_identity: None,
573 secret_ref: Some(SecretRef {
574 name: "s".to_string(),
575 }),
576 },
577 },
578 encryption: None,
579 limits: None,
580 },
581 status: None,
582 }
583 }
584
585 #[test]
586 fn test_map_schedule_to_kanidm_correct_ref() {
587 let (store, mut writer) = reflector::store();
588 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
589 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
590
591 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "a"));
592 assert_eq!(refs.len(), 1);
593 assert_eq!(refs[0].name, "a");
594 }
595
596 #[test]
597 fn test_map_schedule_to_kanidm_wrong_namespace() {
598 let (store, mut writer) = reflector::store();
599 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
600
601 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns2", "a"));
602 assert!(refs.is_empty());
603 }
604
605 #[test]
606 fn test_map_schedule_to_kanidm_other_kanidm() {
607 let (store, mut writer) = reflector::store();
608 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
609
610 let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "nonexistent"));
611 assert!(refs.is_empty());
612 }
613
614 #[test]
615 fn test_map_repository_to_kanidms_fans_out() {
616 let (store, mut writer) = reflector::store();
617 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
618 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
619 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
620
621 let refs = map_repository_to_kanidms(&store, &repository("repo", "ns1"));
622 assert_eq!(refs.len(), 2);
623 let names: Vec<_> = refs.iter().map(|r| r.name.as_str()).collect();
624 assert!(names.contains(&"a"));
625 assert!(names.contains(&"b"));
626 }
627
628 #[test]
629 fn test_map_repository_to_kanidms_ignores_other_namespaces() {
630 let (store, mut writer) = reflector::store();
631 writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
632
633 let refs = map_repository_to_kanidms(&store, &repository("repo", "ns2"));
634 assert!(refs.is_empty());
635 }
636}