Skip to main content

kaniop_radius/
controller.rs

1//! KanidmRadiusServer controller wiring.
2//!
3//! Owned objects (Deployments, Services, and config Secrets through a
4//! metadata-only watcher) trigger their owner. Referenced inputs carry no
5//! Kaniop label, so metadata-only watchers over all Secrets and ConfigMaps
6//! are mapped by namespace and name to the RADIUS servers that reference
7//! them; their data is never cached. Changes of a referenced `Kanidm` spec
8//! (origin, domain, image, namespace selector) trigger every RADIUS server
9//! pointing at it.
10//!
11//! kube-runtime never runs two reconciles of the same object at once, which
12//! the token executors rely on: `generate_api_token` returns only the bearer
13//! and the new token id is found by listing before and after the mint.
14
15use std::sync::Arc;
16
17use futures::channel::mpsc;
18use futures::{StreamExt, TryStreamExt};
19use k8s_openapi::api::apps::v1::Deployment;
20use k8s_openapi::api::core::v1::{ConfigMap, Secret, Service};
21use kanidm_client::KanidmClient;
22use kaniop_k8s_util::error::{Error, Result};
23use kaniop_operator::backoff_reconciler;
24use kaniop_operator::controller::context::{
25    BackoffContext, Context as KaniopContext, IdmClientContext,
26};
27use kaniop_operator::controller::kanidm::KanidmResource;
28use kaniop_operator::controller::{
29    ControllerId, RELOAD_BUFFER_SIZE, SUBSCRIBE_BUFFER_SIZE, State, check_api_queryable,
30    check_api_queryable_optional, create_metadata_watcher, create_subscriber, create_watcher,
31};
32use kaniop_operator::kanidm::crd::Kanidm;
33use kaniop_operator::metrics::ControllerMetrics;
34use kube::ResourceExt;
35use kube::api::{Api, PartialObjectMeta};
36use kube::client::Client;
37use kube::runtime::controller::{self, Controller};
38use kube::runtime::reflector::{ObjectRef, Store};
39use kube::runtime::{WatchStreamExt, predicates, watcher};
40use tokio::time::Duration;
41use tracing::{error, info};
42
43use crate::crd::{KanidmRadiusServer, RadiusCaKind};
44use crate::reconcile::cleanup::DrainWarnings;
45use crate::reconcile::reconcile_radius;
46
47pub const CONTROLLER_ID: ControllerId = "radius-server";
48
49#[derive(Clone)]
50pub struct Context {
51    pub kaniop_ctx: KaniopContext<KanidmRadiusServer>,
52    /// Our Deployments (cache; status reporting only, never token decisions).
53    pub deployment_store: Store<Deployment>,
54    /// Our Services (cache; status reporting only).
55    pub service_store: Store<Service>,
56    /// Rate limit of the finalizer's drain warning events.
57    pub drain_warnings: Arc<DrainWarnings>,
58}
59
60impl BackoffContext<KanidmRadiusServer> for Context {
61    fn metrics(&self) -> &Arc<ControllerMetrics> {
62        self.kaniop_ctx.metrics()
63    }
64
65    async fn get_backoff(&self, obj_ref: ObjectRef<KanidmRadiusServer>) -> Duration {
66        self.kaniop_ctx.get_backoff(obj_ref).await
67    }
68
69    async fn reset_backoff(&self, obj_ref: ObjectRef<KanidmRadiusServer>) {
70        self.kaniop_ctx.reset_backoff(obj_ref).await
71    }
72}
73
74impl IdmClientContext<KanidmRadiusServer> for Context {
75    async fn get_idm_client(&self, obj: &KanidmRadiusServer) -> Result<Arc<KanidmClient>> {
76        self.kaniop_ctx.get_idm_client(obj).await
77    }
78}
79
80/// RADIUS servers in `namespace` that reference the Secret `name` (NAS
81/// shared secret, EAP TLS Secret, or a Secret-kind Kanidm CA).
82pub fn radius_for_secret(
83    radius: &[Arc<KanidmRadiusServer>],
84    namespace: &str,
85    name: &str,
86) -> Vec<ObjectRef<KanidmRadiusServer>> {
87    referencing(radius, namespace, |r| {
88        r.spec
89            .clients
90            .iter()
91            .any(|c| c.shared_secret_ref.name == name)
92            || r.spec.radius_tls.secret_ref.name == name
93            || kanidm_ca(r, RadiusCaKind::Secret) == Some(name)
94    })
95}
96
97/// RADIUS servers in `namespace` whose Kanidm CA is the ConfigMap `name`.
98pub fn radius_for_config_map(
99    radius: &[Arc<KanidmRadiusServer>],
100    namespace: &str,
101    name: &str,
102) -> Vec<ObjectRef<KanidmRadiusServer>> {
103    referencing(radius, namespace, |r| {
104        kanidm_ca(r, RadiusCaKind::ConfigMap) == Some(name)
105    })
106}
107
108/// RADIUS servers whose `kanidmRef` resolves to `namespace/name`.
109pub fn radius_for_kanidm(
110    radius: &[Arc<KanidmRadiusServer>],
111    namespace: &str,
112    name: &str,
113) -> Vec<ObjectRef<KanidmRadiusServer>> {
114    radius
115        .iter()
116        .filter(|r| r.namespace().is_some())
117        .filter(|r| r.kanidm_namespace() == namespace && r.kanidm_name() == name)
118        .map(|r| ObjectRef::from_obj(r.as_ref()))
119        .collect()
120}
121
122/// Inputs are same-namespace references only.
123fn referencing(
124    radius: &[Arc<KanidmRadiusServer>],
125    namespace: &str,
126    references: impl Fn(&KanidmRadiusServer) -> bool,
127) -> Vec<ObjectRef<KanidmRadiusServer>> {
128    radius
129        .iter()
130        .filter(|r| r.namespace().as_deref() == Some(namespace))
131        .filter(|r| references(r))
132        .map(|r| ObjectRef::from_obj(r.as_ref()))
133        .collect()
134}
135
136fn kanidm_ca(radius: &KanidmRadiusServer, kind: RadiusCaKind) -> Option<&str> {
137    radius
138        .spec
139        .kanidm_tls
140        .as_ref()
141        .and_then(|tls| tls.ca_bundle_ref.as_ref())
142        .filter(|ca| ca.kind == kind)
143        .map(|ca| ca.name.as_str())
144}
145
146/// Start the controller. Returns immediately (controller disabled) when the
147/// CRD is not installed.
148pub async fn run(state: State, client: Client) {
149    let Some(radius_api) = check_api_queryable_optional::<KanidmRadiusServer>(client.clone()).await
150    else {
151        info!(
152            controller = CONTROLLER_ID,
153            "KanidmRadiusServer CRD unavailable; controller disabled"
154        );
155        return;
156    };
157    let deployment = check_api_queryable::<Deployment>(client.clone()).await;
158    let service = check_api_queryable::<Service>(client.clone()).await;
159    let owned_secret = check_api_queryable::<PartialObjectMeta<Secret>>(client.clone()).await;
160
161    let deployment_r = create_subscriber::<Deployment>(SUBSCRIBE_BUFFER_SIZE);
162    let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
163    let secret_r = create_subscriber::<PartialObjectMeta<Secret>>(SUBSCRIBE_BUFFER_SIZE);
164    let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
165
166    let ctx = Arc::new(Context {
167        kaniop_ctx: state.to_context(client.clone(), CONTROLLER_ID),
168        deployment_store: deployment_r.store,
169        service_store: service_r.store,
170        drain_warnings: Arc::default(),
171    });
172    let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
173
174    let deployment_watcher = create_watcher(
175        deployment,
176        deployment_r.writer,
177        reload_tx.clone(),
178        CONTROLLER_ID,
179        kaniop_ctx.clone(),
180    );
181    let service_watcher = create_watcher(
182        service,
183        service_r.writer,
184        reload_tx.clone(),
185        CONTROLLER_ID,
186        kaniop_ctx.clone(),
187    );
188    let secret_watcher = create_metadata_watcher(
189        owned_secret,
190        secret_r.writer,
191        reload_tx,
192        CONTROLLER_ID,
193        kaniop_ctx.clone(),
194    );
195
196    // Referenced inputs: metadata only, every namespace, no cache of data.
197    let input_secret_metrics = kaniop_ctx.clone();
198    let input_secret_trigger = watcher(
199        Api::<PartialObjectMeta<Secret>>::all(client.clone()),
200        watcher::Config::default().any_semantic(),
201    )
202    .default_backoff()
203    .touched_objects()
204    .inspect_err(move |e| {
205        error!(error = %e, "unexpected error when watching referenced RADIUS Secrets");
206        input_secret_metrics.metrics.watch_operations_failed_inc();
207    });
208    let input_config_map_metrics = kaniop_ctx.clone();
209    let input_config_map_trigger = watcher(
210        Api::<PartialObjectMeta<ConfigMap>>::all(client.clone()),
211        watcher::Config::default().any_semantic(),
212    )
213    .default_backoff()
214    .touched_objects()
215    .inspect_err(move |e| {
216        error!(error = %e, "unexpected error when watching referenced RADIUS ConfigMaps");
217        input_config_map_metrics
218            .metrics
219            .watch_operations_failed_inc();
220    });
221    // Only spec changes of a Kanidm matter here; its status churn does not.
222    let kanidm_metrics = kaniop_ctx;
223    let kanidm_trigger = watcher(
224        Api::<Kanidm>::all(client.clone()),
225        watcher::Config::default().any_semantic(),
226    )
227    .default_backoff()
228    .touched_objects()
229    .predicate_filter(predicates::generation, Default::default())
230    .inspect_err(move |e| {
231        error!(error = %e, "unexpected error when watching Kanidm for RADIUS");
232        kanidm_metrics.metrics.watch_operations_failed_inc();
233    });
234
235    let controller = Controller::new(radius_api, watcher::Config::default().any_semantic());
236    let radius_store = controller.store();
237    let secret_store = radius_store.clone();
238    let config_map_store = radius_store.clone();
239    let kanidm_store = radius_store;
240
241    info!(controller = CONTROLLER_ID, "starting controller");
242    let radius_controller = controller
243        // debounce to filter out reconcile calls that happen in quick succession
244        .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
245        .owns_shared_stream(deployment_r.subscriber)
246        .owns_shared_stream(service_r.subscriber)
247        .owns_shared_stream(secret_r.subscriber)
248        .watches_stream(input_secret_trigger, move |secret| {
249            radius_for_secret(
250                &secret_store.state(),
251                &secret.namespace().unwrap_or_default(),
252                &secret.name_any(),
253            )
254        })
255        .watches_stream(input_config_map_trigger, move |config_map| {
256            radius_for_config_map(
257                &config_map_store.state(),
258                &config_map.namespace().unwrap_or_default(),
259                &config_map.name_any(),
260            )
261        })
262        .watches_stream(kanidm_trigger, move |kanidm| {
263            radius_for_kanidm(
264                &kanidm_store.state(),
265                &kanidm.namespace().unwrap_or_default(),
266                &kanidm.name_any(),
267            )
268        })
269        .reconcile_all_on(reload_rx.map(|_| ()))
270        .shutdown_on_signal()
271        .run(
272            backoff_reconciler!(reconcile_radius),
273            |_obj, _error: &Error, _ctx| unreachable!(),
274            ctx.clone(),
275        )
276        .filter_map(|x| async move { std::result::Result::ok(x) })
277        .for_each(|_| futures::future::ready(()));
278
279    ctx.kaniop_ctx.metrics.ready_set(1);
280    tokio::select! {
281        _ = radius_controller => {},
282        _ = deployment_watcher => {},
283        _ = service_watcher => {},
284        _ = secret_watcher => {},
285    }
286}
287
288#[cfg(test)]
289mod tests {
290    use serde_json::json;
291
292    use super::*;
293
294    fn radius(
295        namespace: &str,
296        name: &str,
297        kanidm: serde_json::Value,
298        ca: Option<(&str, &str)>,
299    ) -> Arc<KanidmRadiusServer> {
300        let mut spec = json!({
301            "kanidmRef": kanidm,
302            "authorization": {"requiredGroups": ["allowed@idm.example.com"]},
303            "clients": [
304                {"name": "a", "ipaddr": "192.0.2.1", "sharedSecretRef": {"name": "nas-a", "key": "a"}},
305                {"name": "b", "ipaddr": "192.0.2.2", "sharedSecretRef": {"name": "nas-shared", "key": "b"}}
306            ],
307            "radiusTls": {"secretRef": {"name": "eap-tls"}}
308        });
309        if let Some((kind, ca_name)) = ca {
310            spec["kanidmTls"] =
311                json!({"caBundleRef": {"kind": kind, "name": ca_name, "key": "ca.crt"}});
312        }
313        Arc::new(
314            serde_json::from_value(json!({
315                "apiVersion": "kaniop.rs/v1beta1",
316                "kind": "KanidmRadiusServer",
317                "metadata": {"name": name, "namespace": namespace},
318                "spec": spec
319            }))
320            .unwrap(),
321        )
322    }
323
324    fn names(refs: Vec<ObjectRef<KanidmRadiusServer>>) -> Vec<String> {
325        let mut names: Vec<_> = refs
326            .into_iter()
327            .map(|r| format!("{}/{}", r.namespace.unwrap(), r.name))
328            .collect();
329        names.sort();
330        names
331    }
332
333    fn store() -> Vec<Arc<KanidmRadiusServer>> {
334        vec![
335            radius(
336                "net",
337                "one",
338                json!({"name": "idm"}),
339                Some(("Secret", "private-ca")),
340            ),
341            radius(
342                "net",
343                "two",
344                json!({"name": "idm", "namespace": "identity"}),
345                Some(("ConfigMap", "kanidm-ca")),
346            ),
347            radius(
348                "other",
349                "three",
350                json!({"name": "idm", "namespace": "net"}),
351                None,
352            ),
353        ]
354    }
355
356    #[test]
357    fn controller_id_is_stable_for_metrics() {
358        assert_eq!(CONTROLLER_ID, "radius-server");
359    }
360
361    #[test]
362    fn secrets_map_to_referencing_servers_in_their_namespace() {
363        let store = store();
364        assert_eq!(
365            names(radius_for_secret(&store, "net", "nas-a")),
366            ["net/one", "net/two"]
367        );
368        assert_eq!(
369            names(radius_for_secret(&store, "net", "nas-shared")),
370            ["net/one", "net/two"]
371        );
372        assert_eq!(
373            names(radius_for_secret(&store, "net", "eap-tls")),
374            ["net/one", "net/two"]
375        );
376        assert_eq!(
377            names(radius_for_secret(&store, "other", "eap-tls")),
378            ["other/three"]
379        );
380        // A Secret-kind CA maps; a ConfigMap-kind CA name does not match Secrets.
381        assert_eq!(
382            names(radius_for_secret(&store, "net", "private-ca")),
383            ["net/one"]
384        );
385        assert!(radius_for_secret(&store, "net", "kanidm-ca").is_empty());
386        assert!(radius_for_secret(&store, "net", "unrelated").is_empty());
387        assert!(radius_for_secret(&store, "elsewhere", "nas-a").is_empty());
388    }
389
390    #[test]
391    fn config_maps_map_only_to_config_map_cas() {
392        let store = store();
393        assert_eq!(
394            names(radius_for_config_map(&store, "net", "kanidm-ca")),
395            ["net/two"]
396        );
397        assert!(radius_for_config_map(&store, "net", "private-ca").is_empty());
398        assert!(radius_for_config_map(&store, "other", "kanidm-ca").is_empty());
399        assert!(radius_for_config_map(&store, "net", "eap-tls").is_empty());
400    }
401
402    #[test]
403    fn kanidm_maps_to_servers_by_resolved_reference() {
404        let store = store();
405        // `one` has no namespace in its ref: it resolves to its own namespace.
406        assert_eq!(
407            names(radius_for_kanidm(&store, "net", "idm")),
408            ["net/one", "other/three"]
409        );
410        assert_eq!(
411            names(radius_for_kanidm(&store, "identity", "idm")),
412            ["net/two"]
413        );
414        assert!(radius_for_kanidm(&store, "other", "idm").is_empty());
415        assert!(radius_for_kanidm(&store, "net", "idm2").is_empty());
416    }
417}