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::channel::mpsc;
22use futures::future::BoxFuture;
23use gateway_api::apis::standard::backendtlspolicies::BackendTLSPolicy;
24use gateway_api::apis::standard::httproutes::HTTPRoute;
25use k8s_openapi::api::apps::v1::{Deployment, StatefulSet};
26use k8s_openapi::api::core::v1::{ConfigMap, Namespace, Secret, Service};
27use k8s_openapi::api::networking::v1::Ingress;
28use kube::ResourceExt;
29use kube::api::Api;
30use kube::client::Client;
31use kube::runtime::controller::{self, Controller};
32use kube::runtime::reflector::ObjectRef;
33use kube::runtime::reflector::store::Writer;
34use kube::runtime::reflector::{ReflectHandle, Store};
35use kube::runtime::{WatchStreamExt, watcher};
36use tokio::time::Duration;
37use tracing::{debug, error, info, trace};
38
39pub const CONTROLLER_ID: ControllerId = "kanidm";
40
41fn create_replica_cert_watcher(
42 api: Api<Secret>,
43 writer: Writer<Secret>,
44 ctx: Arc<Context>,
45) -> BoxFuture<'static, ()> {
46 let replica_cert_label = serde_plain::to_string(&SecretType::ReplicaCert).unwrap();
47
48 watcher(
49 api,
50 watcher::Config::default().labels(&format!("{}={}", SECRET_TYPE_LABEL, replica_cert_label)),
51 )
52 .default_backoff()
53 .reflect_shared(writer)
54 .for_each(move |res| {
55 let ctx = ctx.clone();
56 async move {
57 match res {
58 Ok(event) => {
59 trace!(msg = "watched replica cert event", ?event);
60 match event {
61 watcher::Event::InitApply(secret) | watcher::Event::Apply(secret) => {
62 debug!(
63 msg = "init or apply event for replica cert secret trigger reconcile",
64 namespace = secret.namespace().unwrap(),
65 name = secret.name_any()
66 );
67 let _ignore_errors = ctx.insert_repl_cert_exp(&secret).await.map_err(
68 |e| error!(msg = "failed to get replica cert expiration, automatic certificate renewal may be affected", %e),
69 );
70 }
71 watcher::Event::Delete(secret) => {
72 debug!(
73 msg = "delete event for replica cert secret",
74 namespace = secret.namespace().unwrap(),
75 name = secret.name_any()
76 );
77 ctx.remove_repl_cert_exp(&ObjectRef::from(&secret))
78 .await;
79 ctx.remove_repl_cert_host(&ObjectRef::from(&secret))
80 .await;
81 }
82 _ => {}
83 }
84 }
85 Err(e) => {
86 error!(msg = "unexpected error when watching replica cert secrets", %e);
87 ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
88 }
89 }
90 }
91 })
92 .boxed()
93}
94
95#[allow(clippy::too_many_arguments)]
96fn run_controller(
97 kanidm_watcher: impl futures::Stream<Item = Result<Kanidm, watcher::Error>> + Send + 'static,
98 kanidm_store: Store<Kanidm>,
99 statefulset_subscriber: ReflectHandle<StatefulSet>,
100 service_subscriber: ReflectHandle<Service>,
101 ingress_subscriber: ReflectHandle<Ingress>,
102 secret_subscriber: ReflectHandle<Secret>,
103 replica_cert_secret_subscriber: ReflectHandle<Secret>,
104 http_route_subscriber: Option<ReflectHandle<HTTPRoute>>,
105 backend_tls_policy_subscriber: Option<ReflectHandle<BackendTLSPolicy>>,
106 deployment_subscriber: ReflectHandle<Deployment>,
107 config_map_subscriber: ReflectHandle<ConfigMap>,
108 reload_rx: mpsc::Receiver<()>,
109 ctx: Arc<Context>,
110) -> BoxFuture<'static, ()> {
111 let mut controller = Controller::for_stream(kanidm_watcher, kanidm_store)
112 .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
113 .owns_shared_stream(statefulset_subscriber)
114 .owns_shared_stream(service_subscriber)
115 .owns_shared_stream(ingress_subscriber)
116 .owns_shared_stream(secret_subscriber)
117 .owns_shared_stream(replica_cert_secret_subscriber)
118 .owns_shared_stream(deployment_subscriber)
119 .owns_shared_stream(config_map_subscriber);
120
121 if let Some(subscriber) = http_route_subscriber {
122 controller = controller.owns_shared_stream(subscriber);
123 }
124
125 if let Some(subscriber) = backend_tls_policy_subscriber {
126 controller = controller.owns_shared_stream(subscriber);
127 }
128
129 controller
130 .reconcile_all_on(reload_rx.map(|_| ()))
131 .shutdown_on_signal()
132 .run(
133 backoff_reconciler!(reconcile_kanidm),
134 |_obj, _error: &Error, _ctx| unreachable!(),
135 ctx,
136 )
137 .filter_map(|x| async move { std::result::Result::ok(x) })
138 .for_each(|_| futures::future::ready(()))
139 .boxed()
140}
141
142pub async fn run(
144 state: State,
145 client: Client,
146 namespace_api: Api<Namespace>,
147 namespace_r: ResourceReflector<Namespace>,
148 kanidm_api: Api<Kanidm>,
149 kanidm_r: ResourceReflector<Kanidm>,
150) {
151 let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
152 let service = check_api_queryable::<Service>(client.clone()).await;
153 let ingress = check_api_queryable::<Ingress>(client.clone()).await;
154 let secret = check_api_queryable::<Secret>(client.clone()).await;
155 let http_route_api = check_api_queryable_optional::<HTTPRoute>(client.clone()).await;
156 let backend_tls_policy_api =
157 check_api_queryable_optional::<BackendTLSPolicy>(client.clone()).await;
158 let deployment = check_api_queryable::<Deployment>(client.clone()).await;
159 let config_map = check_api_queryable::<ConfigMap>(client.clone()).await;
160
161 let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
162 let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
163 let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
164 let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
165 let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
166 let deployment_r = create_subscriber::<Deployment>(SUBSCRIBE_BUFFER_SIZE);
167 let config_map_r = create_subscriber::<ConfigMap>(SUBSCRIBE_BUFFER_SIZE);
168
169 let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
170
171 let http_route_r = if http_route_api.is_some() {
172 Some(create_subscriber::<HTTPRoute>(SUBSCRIBE_BUFFER_SIZE))
173 } else {
174 None
175 };
176
177 let backend_tls_policy_r = if backend_tls_policy_api.is_some() {
178 Some(create_subscriber::<BackendTLSPolicy>(SUBSCRIBE_BUFFER_SIZE))
179 } else {
180 None
181 };
182
183 let stores = Stores {
184 stateful_set_store: statefulset_r.store,
185 service_store: service_r.store,
186 ingress_store: ingress_r.store,
187 secret_store: secret_r.store,
188 http_route_store: http_route_r.as_ref().map(|r| r.store.clone()),
189 backend_tls_policy_store: backend_tls_policy_r.as_ref().map(|r| r.store.clone()),
190 deployment_store: deployment_r.store,
191 config_map_store: config_map_r.store,
192 };
193
194 let ctx = Arc::new(Context::new(
195 state.to_context(client, CONTROLLER_ID),
196 stores,
197 ));
198 let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
199
200 let statefulset_watcher = create_watcher(
201 statefulset,
202 statefulset_r.writer,
203 reload_tx.clone(),
204 CONTROLLER_ID,
205 kaniop_ctx.clone(),
206 );
207 let service_watcher = create_watcher(
208 service,
209 service_r.writer,
210 reload_tx.clone(),
211 CONTROLLER_ID,
212 kaniop_ctx.clone(),
213 );
214 let ingress_watcher = create_watcher(
215 ingress,
216 ingress_r.writer,
217 reload_tx.clone(),
218 CONTROLLER_ID,
219 kaniop_ctx.clone(),
220 );
221 let secret_watcher = create_watcher(
222 secret.clone(),
223 secret_r.writer,
224 reload_tx.clone(),
225 CONTROLLER_ID,
226 kaniop_ctx.clone(),
227 );
228 let deployment_watcher = create_watcher(
229 deployment,
230 deployment_r.writer,
231 reload_tx.clone(),
232 CONTROLLER_ID,
233 kaniop_ctx.clone(),
234 );
235 let config_map_watcher = create_watcher(
236 config_map,
237 config_map_r.writer,
238 reload_tx.clone(),
239 CONTROLLER_ID,
240 kaniop_ctx.clone(),
241 );
242
243 let replica_cert_secrets_watcher =
244 create_replica_cert_watcher(secret, replica_cert_secret_r.writer, ctx.clone());
245
246 let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
247 .default_backoff()
248 .reflect(namespace_r.writer)
249 .for_each(|res| {
250 let ctx = ctx.clone();
251 async move {
252 match res {
253 Ok(event) => {
254 trace!(msg = format!("receive namespace event: {event:?}"),)
255 }
256 Err(e) => {
257 error!(msg = format!("unexpected error when watching namespace"), %e);
258 ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
259 }
260 }
261 }
262 });
263
264 info!(msg = format!("starting {CONTROLLER_ID} controller"));
265 let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
266 .default_backoff()
267 .reflect(kanidm_r.writer)
268 .touched_objects();
269
270 let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
271 (Some(api), Some(r)) => {
272 let watcher = create_watcher(
273 api,
274 r.writer,
275 reload_tx.clone(),
276 CONTROLLER_ID,
277 kaniop_ctx.clone(),
278 );
279 (Some(watcher), Some(r.subscriber))
280 }
281 _ => (None, None),
282 };
283
284 let (backend_tls_policy_watcher, backend_tls_policy_subscriber) =
285 match (backend_tls_policy_api, backend_tls_policy_r) {
286 (Some(api), Some(r)) => {
287 let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
288 (Some(watcher), Some(r.subscriber))
289 }
290 _ => (None, None),
291 };
292
293 let kanidm_controller = run_controller(
294 kanidm_watcher,
295 kanidm_r.store,
296 statefulset_r.subscriber,
297 service_r.subscriber,
298 ingress_r.subscriber,
299 secret_r.subscriber,
300 replica_cert_secret_r.subscriber,
301 http_route_subscriber,
302 backend_tls_policy_subscriber,
303 deployment_r.subscriber,
304 config_map_r.subscriber,
305 reload_rx,
306 ctx.clone(),
307 );
308
309 ctx.kaniop_ctx.metrics.ready_set(1);
310 tokio::select! {
311 _ = kanidm_controller => {},
312 _ = namespace_watcher => {},
313 _ = statefulset_watcher => {},
314 _ = service_watcher => {},
315 _ = ingress_watcher => {},
316 _ = secret_watcher => {},
317 _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
318 _ = backend_tls_policy_watcher.unwrap_or(futures::future::pending().boxed()) => {},
319 _ = replica_cert_secrets_watcher => {},
320 _ = deployment_watcher => {},
321 _ = config_map_watcher => {},
322 }
323}