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_k8s_util::error::Error;
16
17use std::sync::Arc;
18
19use futures::FutureExt;
20use futures::StreamExt;
21use futures::channel::mpsc;
22use futures::future::BoxFuture;
23use gateway_api::apis::standard::httproutes::HTTPRoute;
24use k8s_openapi::api::apps::v1::{Deployment, StatefulSet};
25use k8s_openapi::api::core::v1::{ConfigMap, Namespace, Secret, Service};
26use k8s_openapi::api::networking::v1::Ingress;
27use kube::ResourceExt;
28use kube::api::Api;
29use kube::client::Client;
30use kube::runtime::controller::{self, Controller};
31use kube::runtime::reflector::ObjectRef;
32use kube::runtime::reflector::store::Writer;
33use kube::runtime::reflector::{ReflectHandle, Store};
34use kube::runtime::{WatchStreamExt, watcher};
35use tokio::time::Duration;
36use tracing::{debug, error, info, trace};
37
38pub const CONTROLLER_ID: ControllerId = "kanidm";
39
40fn create_replica_cert_watcher(
41    api: Api<Secret>,
42    writer: Writer<Secret>,
43    ctx: Arc<Context>,
44) -> BoxFuture<'static, ()> {
45    let replica_cert_label = serde_plain::to_string(&SecretType::ReplicaCert).unwrap();
46
47    watcher(
48        api,
49        watcher::Config::default().labels(&format!("{}={}", SECRET_TYPE_LABEL, replica_cert_label)),
50    )
51    .default_backoff()
52    .reflect_shared(writer)
53    .for_each(move |res| {
54        let ctx = ctx.clone();
55        async move {
56            match res {
57                Ok(event) => {
58                    trace!(msg = "watched replica cert event", ?event);
59                    match event {
60                        watcher::Event::InitApply(secret) | watcher::Event::Apply(secret) => {
61                            debug!(
62                                msg = "init or apply event for replica cert secret trigger reconcile",
63                                namespace = secret.namespace().unwrap(),
64                                name = secret.name_any()
65                            );
66                            let _ignore_errors = ctx.insert_repl_cert_exp(&secret).await.map_err(
67                                |e| error!(msg = "failed to get replica cert expiration, automatic certificate renewal may be affected", %e),
68                            );
69                        }
70                        watcher::Event::Delete(secret) => {
71                            debug!(
72                                msg = "delete event for replica cert secret",
73                                namespace = secret.namespace().unwrap(),
74                                name = secret.name_any()
75                            );
76                            ctx.remove_repl_cert_exp(&ObjectRef::from(&secret))
77                                .await;
78                            ctx.remove_repl_cert_host(&ObjectRef::from(&secret))
79                                .await;
80                        }
81                        _ => {}
82                    }
83                }
84                Err(e) => {
85                    error!(msg = "unexpected error when watching replica cert secrets", %e);
86                    ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
87                }
88            }
89        }
90    })
91    .boxed()
92}
93
94#[allow(clippy::too_many_arguments)]
95fn run_controller(
96    kanidm_watcher: impl futures::Stream<Item = Result<Kanidm, watcher::Error>> + Send + 'static,
97    kanidm_store: Store<Kanidm>,
98    statefulset_subscriber: ReflectHandle<StatefulSet>,
99    service_subscriber: ReflectHandle<Service>,
100    ingress_subscriber: ReflectHandle<Ingress>,
101    secret_subscriber: ReflectHandle<Secret>,
102    replica_cert_secret_subscriber: ReflectHandle<Secret>,
103    http_route_subscriber: Option<ReflectHandle<HTTPRoute>>,
104    deployment_subscriber: ReflectHandle<Deployment>,
105    config_map_subscriber: ReflectHandle<ConfigMap>,
106    reload_rx: mpsc::Receiver<()>,
107    ctx: Arc<Context>,
108) -> BoxFuture<'static, ()> {
109    let mut controller = Controller::for_stream(kanidm_watcher, kanidm_store)
110        .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
111        .owns_shared_stream(statefulset_subscriber)
112        .owns_shared_stream(service_subscriber)
113        .owns_shared_stream(ingress_subscriber)
114        .owns_shared_stream(secret_subscriber)
115        .owns_shared_stream(replica_cert_secret_subscriber)
116        .owns_shared_stream(deployment_subscriber)
117        .owns_shared_stream(config_map_subscriber);
118
119    if let Some(subscriber) = http_route_subscriber {
120        controller = controller.owns_shared_stream(subscriber);
121    }
122
123    controller
124        .reconcile_all_on(reload_rx.map(|_| ()))
125        .shutdown_on_signal()
126        .run(
127            backoff_reconciler!(reconcile_kanidm),
128            |_obj, _error: &Error, _ctx| unreachable!(),
129            ctx,
130        )
131        .filter_map(|x| async move { std::result::Result::ok(x) })
132        .for_each(|_| futures::future::ready(()))
133        .boxed()
134}
135
136/// Initialize Kanidm controller and shared state
137pub async fn run(
138    state: State,
139    client: Client,
140    namespace_api: Api<Namespace>,
141    namespace_r: ResourceReflector<Namespace>,
142    kanidm_api: Api<Kanidm>,
143    kanidm_r: ResourceReflector<Kanidm>,
144) {
145    let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
146    let service = check_api_queryable::<Service>(client.clone()).await;
147    let ingress = check_api_queryable::<Ingress>(client.clone()).await;
148    let secret = check_api_queryable::<Secret>(client.clone()).await;
149    let http_route_api = check_api_queryable_optional::<HTTPRoute>(client.clone()).await;
150    let deployment = check_api_queryable::<Deployment>(client.clone()).await;
151    let config_map = check_api_queryable::<ConfigMap>(client.clone()).await;
152
153    let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
154    let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
155    let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
156    let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
157    let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
158    let deployment_r = create_subscriber::<Deployment>(SUBSCRIBE_BUFFER_SIZE);
159    let config_map_r = create_subscriber::<ConfigMap>(SUBSCRIBE_BUFFER_SIZE);
160
161    let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
162
163    let http_route_r = if http_route_api.is_some() {
164        Some(create_subscriber::<HTTPRoute>(SUBSCRIBE_BUFFER_SIZE))
165    } else {
166        None
167    };
168
169    let stores = Stores {
170        stateful_set_store: statefulset_r.store,
171        service_store: service_r.store,
172        ingress_store: ingress_r.store,
173        secret_store: secret_r.store,
174        http_route_store: http_route_r.as_ref().map(|r| r.store.clone()),
175        deployment_store: deployment_r.store,
176        config_map_store: config_map_r.store,
177    };
178
179    let ctx = Arc::new(Context::new(
180        state.to_context(client, CONTROLLER_ID),
181        stores,
182    ));
183    let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
184
185    let statefulset_watcher = create_watcher(
186        statefulset,
187        statefulset_r.writer,
188        reload_tx.clone(),
189        CONTROLLER_ID,
190        kaniop_ctx.clone(),
191    );
192    let service_watcher = create_watcher(
193        service,
194        service_r.writer,
195        reload_tx.clone(),
196        CONTROLLER_ID,
197        kaniop_ctx.clone(),
198    );
199    let ingress_watcher = create_watcher(
200        ingress,
201        ingress_r.writer,
202        reload_tx.clone(),
203        CONTROLLER_ID,
204        kaniop_ctx.clone(),
205    );
206    let secret_watcher = create_watcher(
207        secret.clone(),
208        secret_r.writer,
209        reload_tx.clone(),
210        CONTROLLER_ID,
211        kaniop_ctx.clone(),
212    );
213    let deployment_watcher = create_watcher(
214        deployment,
215        deployment_r.writer,
216        reload_tx.clone(),
217        CONTROLLER_ID,
218        kaniop_ctx.clone(),
219    );
220    let config_map_watcher = create_watcher(
221        config_map,
222        config_map_r.writer,
223        reload_tx.clone(),
224        CONTROLLER_ID,
225        kaniop_ctx.clone(),
226    );
227
228    let replica_cert_secrets_watcher =
229        create_replica_cert_watcher(secret, replica_cert_secret_r.writer, ctx.clone());
230
231    let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
232        .default_backoff()
233        .reflect(namespace_r.writer)
234        .for_each(|res| {
235            let ctx = ctx.clone();
236            async move {
237                match res {
238                    Ok(event) => {
239                        trace!(msg = format!("receive namespace event: {event:?}"),)
240                    }
241                    Err(e) => {
242                        error!(msg = format!("unexpected error when watching namespace"), %e);
243                        ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
244                    }
245                }
246            }
247        });
248
249    info!(msg = format!("starting {CONTROLLER_ID} controller"));
250    let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
251        .default_backoff()
252        .reflect(kanidm_r.writer)
253        .touched_objects();
254
255    let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
256        (Some(api), Some(r)) => {
257            let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
258            (Some(watcher), Some(r.subscriber))
259        }
260        _ => (None, None),
261    };
262
263    let kanidm_controller = run_controller(
264        kanidm_watcher,
265        kanidm_r.store,
266        statefulset_r.subscriber,
267        service_r.subscriber,
268        ingress_r.subscriber,
269        secret_r.subscriber,
270        replica_cert_secret_r.subscriber,
271        http_route_subscriber,
272        deployment_r.subscriber,
273        config_map_r.subscriber,
274        reload_rx,
275        ctx.clone(),
276    );
277
278    ctx.kaniop_ctx.metrics.ready_set(1);
279    tokio::select! {
280        _ = kanidm_controller => {},
281        _ = namespace_watcher => {},
282        _ = statefulset_watcher => {},
283        _ = service_watcher => {},
284        _ = ingress_watcher => {},
285        _ = secret_watcher => {},
286        _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
287        _ = replica_cert_secrets_watcher => {},
288        _ = deployment_watcher => {},
289        _ = config_map_watcher => {},
290    }
291}