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