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