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::TryStreamExt;
22use futures::channel::mpsc;
23use futures::future::BoxFuture;
24use gateway_api::apis::standard::backendtlspolicies::BackendTLSPolicy;
25use gateway_api::apis::standard::httproutes::HTTPRoute;
26use k8s_openapi::api::apps::v1::{Deployment, StatefulSet};
27use k8s_openapi::api::core::v1::{ConfigMap, Namespace, Secret, Service};
28use k8s_openapi::api::networking::v1::Ingress;
29use kube::ResourceExt;
30use kube::api::{Api, PartialObjectMeta};
31use kube::client::Client;
32use kube::runtime::controller::{self, Controller};
33use kube::runtime::reflector::ObjectRef;
34use kube::runtime::reflector::store::Writer;
35use kube::runtime::reflector::{ReflectHandle, Store};
36use kube::runtime::{WatchStreamExt, metadata_watcher, watcher};
37use tokio::time::Duration;
38use tracing::{debug, error, info, trace};
39
40pub const CONTROLLER_ID: ControllerId = "kanidm";
41
42fn create_replica_cert_watcher(
43    api: Api<Secret>,
44    writer: Writer<Secret>,
45    ctx: Arc<Context>,
46) -> BoxFuture<'static, ()> {
47    let replica_cert_label = serde_plain::to_string(&SecretType::ReplicaCert).unwrap();
48
49    watcher(
50        api,
51        watcher::Config::default().labels(&format!("{}={}", SECRET_TYPE_LABEL, replica_cert_label)),
52    )
53    .default_backoff()
54    .reflect_shared(writer)
55    .for_each(move |res| {
56        let ctx = ctx.clone();
57        async move {
58            match res {
59                Ok(event) => {
60                    trace!(msg = "watched replica cert event", ?event);
61                    match event {
62                        watcher::Event::InitApply(secret) | watcher::Event::Apply(secret) => {
63                            debug!(
64                                msg = "init or apply event for replica cert secret trigger reconcile",
65                                namespace = secret.namespace().unwrap(),
66                                name = secret.name_any()
67                            );
68                            let _ignore_errors = ctx.insert_repl_cert_exp(&secret).await.map_err(
69                                |e| error!(msg = "failed to get replica cert expiration, automatic certificate renewal may be affected", %e),
70                            );
71                        }
72                        watcher::Event::Delete(secret) => {
73                            debug!(
74                                msg = "delete event for replica cert secret",
75                                namespace = secret.namespace().unwrap(),
76                                name = secret.name_any()
77                            );
78                            ctx.remove_repl_cert_exp(&ObjectRef::from(&secret))
79                                .await;
80                            ctx.remove_repl_cert_host(&ObjectRef::from(&secret))
81                                .await;
82                        }
83                        _ => {}
84                    }
85                }
86                Err(e) => {
87                    error!(msg = "unexpected error when watching replica cert secrets", %e);
88                    ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
89                }
90            }
91        }
92    })
93    .boxed()
94}
95
96/// Map a TLS secret event to the Kanidm objects that mount it.
97///
98/// The TLS secret is user-provided (e.g. created by cert-manager), so it
99/// carries neither kaniop labels nor owner references pointing to the Kanidm:
100/// match by namespace and effective TLS secret name against the Kanidm store.
101fn map_tls_secret_to_kanidms(
102    kanidm_store: &Store<Kanidm>,
103    secret: &PartialObjectMeta<Secret>,
104) -> Vec<ObjectRef<Kanidm>> {
105    kanidm_store
106        .state()
107        .into_iter()
108        .filter(|kanidm| {
109            kanidm.namespace() == secret.namespace()
110                && kanidm.effective_tls_secret_name() == secret.name_any()
111        })
112        .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
113        .collect()
114}
115
116#[allow(clippy::too_many_arguments)]
117fn run_controller(
118    kanidm_watcher: impl futures::Stream<Item = Result<Kanidm, watcher::Error>> + Send + 'static,
119    kanidm_store: Store<Kanidm>,
120    statefulset_subscriber: ReflectHandle<StatefulSet>,
121    service_subscriber: ReflectHandle<Service>,
122    ingress_subscriber: ReflectHandle<Ingress>,
123    secret_subscriber: ReflectHandle<Secret>,
124    replica_cert_secret_subscriber: ReflectHandle<Secret>,
125    tls_secret_trigger: impl futures::Stream<Item = Result<PartialObjectMeta<Secret>, watcher::Error>>
126    + Send
127    + 'static,
128    http_route_subscriber: Option<ReflectHandle<HTTPRoute>>,
129    backend_tls_policy_subscriber: Option<ReflectHandle<BackendTLSPolicy>>,
130    deployment_subscriber: ReflectHandle<Deployment>,
131    config_map_subscriber: ReflectHandle<ConfigMap>,
132    reload_rx: mpsc::Receiver<()>,
133    ctx: Arc<Context>,
134) -> BoxFuture<'static, ()> {
135    let kanidm_store_for_tls = kanidm_store.clone();
136    let mut controller = Controller::for_stream(kanidm_watcher, kanidm_store)
137        .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
138        .owns_shared_stream(statefulset_subscriber)
139        .owns_shared_stream(service_subscriber)
140        .owns_shared_stream(ingress_subscriber)
141        .owns_shared_stream(secret_subscriber)
142        .owns_shared_stream(replica_cert_secret_subscriber)
143        .owns_shared_stream(deployment_subscriber)
144        .owns_shared_stream(config_map_subscriber)
145        .watches_stream(tls_secret_trigger, move |secret| {
146            map_tls_secret_to_kanidms(&kanidm_store_for_tls, &secret)
147        });
148
149    if let Some(subscriber) = http_route_subscriber {
150        controller = controller.owns_shared_stream(subscriber);
151    }
152
153    if let Some(subscriber) = backend_tls_policy_subscriber {
154        controller = controller.owns_shared_stream(subscriber);
155    }
156
157    controller
158        .reconcile_all_on(reload_rx.map(|_| ()))
159        .shutdown_on_signal()
160        .run(
161            backoff_reconciler!(reconcile_kanidm),
162            |_obj, _error: &Error, _ctx| unreachable!(),
163            ctx,
164        )
165        .filter_map(|x| async move { std::result::Result::ok(x) })
166        .for_each(|_| futures::future::ready(()))
167        .boxed()
168}
169
170/// Initialize Kanidm controller and shared state
171pub async fn run(
172    state: State,
173    client: Client,
174    namespace_api: Api<Namespace>,
175    namespace_r: ResourceReflector<Namespace>,
176    kanidm_api: Api<Kanidm>,
177    kanidm_r: ResourceReflector<Kanidm>,
178) {
179    let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
180    let service = check_api_queryable::<Service>(client.clone()).await;
181    let ingress = check_api_queryable::<Ingress>(client.clone()).await;
182    let secret = check_api_queryable::<Secret>(client.clone()).await;
183    let http_route_api = check_api_queryable_optional::<HTTPRoute>(client.clone()).await;
184    let backend_tls_policy_api =
185        check_api_queryable_optional::<BackendTLSPolicy>(client.clone()).await;
186    let deployment = check_api_queryable::<Deployment>(client.clone()).await;
187    let config_map = check_api_queryable::<ConfigMap>(client.clone()).await;
188
189    let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
190    let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
191    let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
192    let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
193    let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
194    let deployment_r = create_subscriber::<Deployment>(SUBSCRIBE_BUFFER_SIZE);
195    let config_map_r = create_subscriber::<ConfigMap>(SUBSCRIBE_BUFFER_SIZE);
196
197    let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
198
199    let http_route_r = if http_route_api.is_some() {
200        Some(create_subscriber::<HTTPRoute>(SUBSCRIBE_BUFFER_SIZE))
201    } else {
202        None
203    };
204
205    let backend_tls_policy_r = if backend_tls_policy_api.is_some() {
206        Some(create_subscriber::<BackendTLSPolicy>(SUBSCRIBE_BUFFER_SIZE))
207    } else {
208        None
209    };
210
211    let stores = Stores {
212        stateful_set_store: statefulset_r.store,
213        service_store: service_r.store,
214        ingress_store: ingress_r.store,
215        secret_store: secret_r.store,
216        http_route_store: http_route_r.as_ref().map(|r| r.store.clone()),
217        backend_tls_policy_store: backend_tls_policy_r.as_ref().map(|r| r.store.clone()),
218        deployment_store: deployment_r.store,
219        config_map_store: config_map_r.store,
220    };
221
222    let ctx = Arc::new(Context::new(
223        state.to_context(client, CONTROLLER_ID),
224        stores,
225    ));
226    let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
227
228    let statefulset_watcher = create_watcher(
229        statefulset,
230        statefulset_r.writer,
231        reload_tx.clone(),
232        CONTROLLER_ID,
233        kaniop_ctx.clone(),
234    );
235    let service_watcher = create_watcher(
236        service,
237        service_r.writer,
238        reload_tx.clone(),
239        CONTROLLER_ID,
240        kaniop_ctx.clone(),
241    );
242    let ingress_watcher = create_watcher(
243        ingress,
244        ingress_r.writer,
245        reload_tx.clone(),
246        CONTROLLER_ID,
247        kaniop_ctx.clone(),
248    );
249    let secret_watcher = create_watcher(
250        secret.clone(),
251        secret_r.writer,
252        reload_tx.clone(),
253        CONTROLLER_ID,
254        kaniop_ctx.clone(),
255    );
256    let deployment_watcher = create_watcher(
257        deployment,
258        deployment_r.writer,
259        reload_tx.clone(),
260        CONTROLLER_ID,
261        kaniop_ctx.clone(),
262    );
263    let config_map_watcher = create_watcher(
264        config_map,
265        config_map_r.writer,
266        reload_tx.clone(),
267        CONTROLLER_ID,
268        kaniop_ctx.clone(),
269    );
270
271    let replica_cert_secrets_watcher =
272        create_replica_cert_watcher(secret.clone(), replica_cert_secret_r.writer, ctx.clone());
273
274    // TLS secrets are user-provided (e.g. created by cert-manager) and carry no
275    // kaniop label to filter on: watch metadata of `kubernetes.io/tls` secrets
276    // and let the mapper match them by name against the Kanidm store.
277    let tls_secret_metrics_ctx = kaniop_ctx.clone();
278    let tls_secret_trigger = metadata_watcher(
279        secret,
280        watcher::Config::default()
281            .fields("type=kubernetes.io/tls")
282            .any_semantic(),
283    )
284    .default_backoff()
285    .touched_objects()
286    .inspect_err(move |e| {
287        error!(msg = "unexpected error when watching TLS secrets", %e);
288        tls_secret_metrics_ctx.metrics.watch_operations_failed_inc();
289    });
290
291    let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
292        .default_backoff()
293        .reflect(namespace_r.writer)
294        .for_each(|res| {
295            let ctx = ctx.clone();
296            async move {
297                match res {
298                    Ok(event) => {
299                        trace!(msg = format!("receive namespace event: {event:?}"),)
300                    }
301                    Err(e) => {
302                        error!(msg = format!("unexpected error when watching namespace"), %e);
303                        ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
304                    }
305                }
306            }
307        });
308
309    info!(msg = format!("starting {CONTROLLER_ID} controller"));
310    let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
311        .default_backoff()
312        .reflect(kanidm_r.writer)
313        .touched_objects();
314
315    let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
316        (Some(api), Some(r)) => {
317            let watcher = create_watcher(
318                api,
319                r.writer,
320                reload_tx.clone(),
321                CONTROLLER_ID,
322                kaniop_ctx.clone(),
323            );
324            (Some(watcher), Some(r.subscriber))
325        }
326        _ => (None, None),
327    };
328
329    let (backend_tls_policy_watcher, backend_tls_policy_subscriber) =
330        match (backend_tls_policy_api, backend_tls_policy_r) {
331            (Some(api), Some(r)) => {
332                let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
333                (Some(watcher), Some(r.subscriber))
334            }
335            _ => (None, None),
336        };
337
338    let kanidm_controller = run_controller(
339        kanidm_watcher,
340        kanidm_r.store,
341        statefulset_r.subscriber,
342        service_r.subscriber,
343        ingress_r.subscriber,
344        secret_r.subscriber,
345        replica_cert_secret_r.subscriber,
346        tls_secret_trigger,
347        http_route_subscriber,
348        backend_tls_policy_subscriber,
349        deployment_r.subscriber,
350        config_map_r.subscriber,
351        reload_rx,
352        ctx.clone(),
353    );
354
355    ctx.kaniop_ctx.metrics.ready_set(1);
356    tokio::select! {
357        _ = kanidm_controller => {},
358        _ = namespace_watcher => {},
359        _ = statefulset_watcher => {},
360        _ = service_watcher => {},
361        _ = ingress_watcher => {},
362        _ = secret_watcher => {},
363        _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
364        _ = backend_tls_policy_watcher.unwrap_or(futures::future::pending().boxed()) => {},
365        _ = replica_cert_secrets_watcher => {},
366        _ = deployment_watcher => {},
367        _ = config_map_watcher => {},
368    }
369}
370
371#[cfg(test)]
372mod tests {
373    use super::map_tls_secret_to_kanidms;
374    use crate::kanidm::crd::{Kanidm, KanidmSpec};
375
376    use k8s_openapi::api::core::v1::Secret;
377    use kube::api::{ObjectMeta, PartialObjectMeta};
378    use kube::runtime::reflector;
379    use kube::runtime::watcher;
380
381    fn kanidm(name: &str, namespace: &str, tls_secret_name: Option<&str>) -> Kanidm {
382        Kanidm {
383            metadata: ObjectMeta {
384                name: Some(name.to_string()),
385                namespace: Some(namespace.to_string()),
386                ..Default::default()
387            },
388            spec: KanidmSpec {
389                domain: "idm.example.com".to_string(),
390                tls_secret_name: tls_secret_name.map(str::to_string),
391                ..Default::default()
392            },
393            ..Default::default()
394        }
395    }
396
397    fn secret_meta(name: &str, namespace: &str) -> PartialObjectMeta<Secret> {
398        PartialObjectMeta {
399            metadata: ObjectMeta {
400                name: Some(name.to_string()),
401                namespace: Some(namespace.to_string()),
402                ..Default::default()
403            },
404            ..Default::default()
405        }
406    }
407
408    #[test]
409    fn test_map_tls_secret_to_kanidms() {
410        let (store, mut writer) = reflector::store();
411        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
412        writer.apply_watcher_event(&watcher::Event::Apply(kanidm(
413            "b",
414            "ns1",
415            Some("custom-tls"),
416        )));
417        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
418
419        // default secret name `{name}-tls`
420        let refs = map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns1"));
421        assert_eq!(refs.len(), 1);
422        assert_eq!(refs[0].name, "a");
423
424        // explicit `tlsSecretName`
425        let refs = map_tls_secret_to_kanidms(&store, &secret_meta("custom-tls", "ns1"));
426        assert_eq!(refs.len(), 1);
427        assert_eq!(refs[0].name, "b");
428
429        // same name in another namespace does not match
430        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
431
432        // unrelated secret matches nothing
433        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
434    }
435}