kaniop_operator/kanidm/controller/
mod.rs

1pub mod context;
2
3use super::controller::context::{Context, Stores};
4use super::crd::Kanidm;
5use super::reconcile::reconcile_kanidm;
6
7use crate::backoff_reconciler;
8use crate::controller::{
9    ControllerId, RELOAD_BUFFER_SIZE, ResourceReflector, SUBSCRIBE_BUFFER_SIZE, State,
10    check_api_queryable, create_subscriber, create_watcher,
11};
12use crate::error::Error;
13
14use std::sync::Arc;
15
16use futures::StreamExt;
17use futures::channel::mpsc;
18use k8s_openapi::api::apps::v1::StatefulSet;
19use k8s_openapi::api::core::v1::{Namespace, Secret, Service};
20use k8s_openapi::api::networking::v1::Ingress;
21use kube::api::Api;
22use kube::client::Client;
23use kube::runtime::controller::{self, Controller};
24use kube::runtime::{WatchStreamExt, watcher};
25use tokio::time::Duration;
26use tracing::{error, info, trace};
27
28pub const CONTROLLER_ID: ControllerId = "kanidm";
29
30/// Initialize Kanidm controller and shared state
31pub async fn run(
32    state: State,
33    client: Client,
34    namespace_api: Api<Namespace>,
35    namespace_r: ResourceReflector<Namespace>,
36    kanidm_api: Api<Kanidm>,
37    kanidm_r: ResourceReflector<Kanidm>,
38) {
39    let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
40    let service = check_api_queryable::<Service>(client.clone()).await;
41    let ingress = check_api_queryable::<Ingress>(client.clone()).await;
42    let secret = check_api_queryable::<Secret>(client.clone()).await;
43
44    let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
45    let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
46    let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
47    let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
48
49    let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
50
51    let stores = Stores {
52        stateful_set_store: statefulset_r.store,
53        service_store: service_r.store,
54        ingress_store: ingress_r.store,
55        secret_store: secret_r.store,
56    };
57
58    let ctx = Arc::new(Context::new(
59        state.to_context(client, CONTROLLER_ID),
60        stores,
61    ));
62    let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
63    let statefulset_watcher = create_watcher(
64        statefulset,
65        statefulset_r.writer,
66        reload_tx.clone(),
67        CONTROLLER_ID,
68        kaniop_ctx.clone(),
69    );
70    let service_watcher = create_watcher(
71        service,
72        service_r.writer,
73        reload_tx.clone(),
74        CONTROLLER_ID,
75        kaniop_ctx.clone(),
76    );
77    let ingress_watcher = create_watcher(
78        ingress,
79        ingress_r.writer,
80        reload_tx.clone(),
81        CONTROLLER_ID,
82        kaniop_ctx.clone(),
83    );
84    let secret_watcher = create_watcher(
85        secret,
86        secret_r.writer,
87        reload_tx.clone(),
88        CONTROLLER_ID,
89        kaniop_ctx,
90    );
91
92    let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
93        .default_backoff()
94        .reflect(namespace_r.writer)
95        .for_each(|res| {
96            let ctx = ctx.clone();
97            async move {
98                match res {
99                    Ok(event) => {
100                        trace!(msg = format!("receive namespace event: {event:?}"),)
101                    }
102                    Err(e) => {
103                        error!(msg = format!("unexpected error when watching namespace"), %e);
104                        ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
105                    }
106                }
107            }
108        });
109
110    info!(msg = format!("starting {CONTROLLER_ID} controller"));
111    // TODO: watcher::Config::default().streaming_lists() when stabilized in K8s
112    // https://kubernetes.io/docs/reference/using-api/api-concepts/#streaming-lists
113    let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
114        .default_backoff()
115        .reflect(kanidm_r.writer)
116        .touched_objects();
117
118    let kanidm_controller = Controller::for_stream(kanidm_watcher, kanidm_r.store)
119        // debounce to filter out reconcile calls that happen quick succession (only taking the latest)
120        .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
121        .owns_shared_stream(statefulset_r.subscriber)
122        .owns_shared_stream(service_r.subscriber)
123        .owns_shared_stream(ingress_r.subscriber)
124        .owns_shared_stream(secret_r.subscriber)
125        .reconcile_all_on(reload_rx.map(|_| ()))
126        .shutdown_on_signal()
127        .run(
128            backoff_reconciler!(reconcile_kanidm),
129            |_obj, _error: &Error, _ctx| unreachable!(),
130            ctx.clone(),
131        )
132        .filter_map(|x| async move { std::result::Result::ok(x) })
133        .for_each(|_| futures::future::ready(()));
134
135    ctx.kaniop_ctx.metrics.ready_set(1);
136    tokio::select! {
137        _ = kanidm_controller => {},
138        _ = namespace_watcher => {},
139        _ = statefulset_watcher => {},
140        _ = service_watcher => {},
141        _ = ingress_watcher => {},
142        _ = secret_watcher => {},
143    }
144}