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
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!(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 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 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 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
429
430 assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
432 }
433}