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
96fn 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
170pub 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 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 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 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 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
431
432 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
434 }
435}