Skip to main content

kaniop_operator/kanidm/controller/
mod.rs

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::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
93/// Initialize Kanidm controller and shared state
94pub 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    // TODO: watcher::Config::default().streaming_lists() when stabilized in K8s (1.34+)
193    // https://kubernetes.io/docs/reference/using-api/api-concepts/#streaming-lists
194    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}