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!(?event, "watched replica cert event");
61                    match event {
62                        watcher::Event::InitApply(secret) | watcher::Event::Apply(secret) => {
63                            debug!(
64                                namespace = secret.namespace().unwrap(),
65                                name = secret.name_any(),
66                                "init or apply event for replica cert secret trigger reconcile"
67                            );
68                            let _ignore_errors = ctx.insert_repl_cert_exp(&secret).await.map_err(
69                                |e| error!(error = %e, "failed to get replica cert expiration, automatic certificate renewal may be affected"),
70                            );
71                        }
72                        watcher::Event::Delete(secret) => {
73                            debug!(
74                                namespace = secret.namespace().unwrap(),
75                                name = secret.name_any(),
76                                "delete event for replica cert secret"
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!(error = %e, "unexpected error when watching replica cert secrets");
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!(error = %e, "unexpected error when watching TLS secrets");
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) => trace!(?event, "received namespace event"),
299                    Err(e) => {
300                        error!(error = %e, "unexpected error when watching namespace");
301                        ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
302                    }
303                }
304            }
305        });
306
307    info!(controller = CONTROLLER_ID, "starting controller");
308    let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
309        .default_backoff()
310        .reflect(kanidm_r.writer)
311        .touched_objects();
312
313    let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
314        (Some(api), Some(r)) => {
315            let watcher = create_watcher(
316                api,
317                r.writer,
318                reload_tx.clone(),
319                CONTROLLER_ID,
320                kaniop_ctx.clone(),
321            );
322            (Some(watcher), Some(r.subscriber))
323        }
324        _ => (None, None),
325    };
326
327    let (backend_tls_policy_watcher, backend_tls_policy_subscriber) =
328        match (backend_tls_policy_api, backend_tls_policy_r) {
329            (Some(api), Some(r)) => {
330                let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
331                (Some(watcher), Some(r.subscriber))
332            }
333            _ => (None, None),
334        };
335
336    let kanidm_controller = run_controller(
337        kanidm_watcher,
338        kanidm_r.store,
339        statefulset_r.subscriber,
340        service_r.subscriber,
341        ingress_r.subscriber,
342        secret_r.subscriber,
343        replica_cert_secret_r.subscriber,
344        tls_secret_trigger,
345        http_route_subscriber,
346        backend_tls_policy_subscriber,
347        deployment_r.subscriber,
348        config_map_r.subscriber,
349        reload_rx,
350        ctx.clone(),
351    );
352
353    ctx.kaniop_ctx.metrics.ready_set(1);
354    tokio::select! {
355        _ = kanidm_controller => {},
356        _ = namespace_watcher => {},
357        _ = statefulset_watcher => {},
358        _ = service_watcher => {},
359        _ = ingress_watcher => {},
360        _ = secret_watcher => {},
361        _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
362        _ = backend_tls_policy_watcher.unwrap_or(futures::future::pending().boxed()) => {},
363        _ = replica_cert_secrets_watcher => {},
364        _ = deployment_watcher => {},
365        _ = config_map_watcher => {},
366    }
367}
368
369#[cfg(test)]
370mod tests {
371    use super::map_tls_secret_to_kanidms;
372    use crate::kanidm::crd::{Kanidm, KanidmSpec};
373
374    use k8s_openapi::api::core::v1::Secret;
375    use kube::api::{ObjectMeta, PartialObjectMeta};
376    use kube::runtime::reflector;
377    use kube::runtime::watcher;
378
379    fn kanidm(name: &str, namespace: &str, tls_secret_name: Option<&str>) -> Kanidm {
380        Kanidm {
381            metadata: ObjectMeta {
382                name: Some(name.to_string()),
383                namespace: Some(namespace.to_string()),
384                ..Default::default()
385            },
386            spec: KanidmSpec {
387                domain: "idm.example.com".to_string(),
388                tls_secret_name: tls_secret_name.map(str::to_string),
389                ..Default::default()
390            },
391            ..Default::default()
392        }
393    }
394
395    fn secret_meta(name: &str, namespace: &str) -> PartialObjectMeta<Secret> {
396        PartialObjectMeta {
397            metadata: ObjectMeta {
398                name: Some(name.to_string()),
399                namespace: Some(namespace.to_string()),
400                ..Default::default()
401            },
402            ..Default::default()
403        }
404    }
405
406    #[test]
407    fn test_map_tls_secret_to_kanidms() {
408        let (store, mut writer) = reflector::store();
409        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
410        writer.apply_watcher_event(&watcher::Event::Apply(kanidm(
411            "b",
412            "ns1",
413            Some("custom-tls"),
414        )));
415        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
416
417        // default secret name `{name}-tls`
418        let refs = map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns1"));
419        assert_eq!(refs.len(), 1);
420        assert_eq!(refs[0].name, "a");
421
422        // explicit `tlsSecretName`
423        let refs = map_tls_secret_to_kanidms(&store, &secret_meta("custom-tls", "ns1"));
424        assert_eq!(refs.len(), 1);
425        assert_eq!(refs[0].name, "b");
426
427        // same name in another namespace does not match
428        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
429
430        // unrelated secret matches nothing
431        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
432    }
433}