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