1use 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 pub deployment_store: Store<Deployment>,
54 pub service_store: Store<Service>,
56 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
80pub 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
97pub 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
108pub 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
122fn 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
146pub 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 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 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 .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 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 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}