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, 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 k8s_openapi::api::apps::v1::StatefulSet;
22use k8s_openapi::api::core::v1::{Namespace, Secret, Service};
23use k8s_openapi::api::networking::v1::Ingress;
24use kube::ResourceExt;
25use kube::api::Api;
26use kube::client::Client;
27use kube::runtime::controller::{self, Controller};
28use kube::runtime::reflector::ObjectRef;
29use kube::runtime::reflector::store::Writer;
30use kube::runtime::{WatchStreamExt, watcher};
31use tokio::time::Duration;
32use tracing::{debug, error, info, trace};
33
34pub const CONTROLLER_ID: ControllerId = "kanidm";
35
36fn create_replica_cert_watcher(
37    api: Api<Secret>,
38    writer: Writer<Secret>,
39    ctx: Arc<Context>,
40) -> futures::future::BoxFuture<'static, ()> {
41    use futures::FutureExt;
42
43    let replica_cert_label = serde_plain::to_string(&SecretType::ReplicaCert).unwrap();
44
45    watcher(
46        api,
47        watcher::Config::default().labels(&format!("{}={}", SECRET_TYPE_LABEL, replica_cert_label)),
48    )
49    .default_backoff()
50    .reflect_shared(writer)
51    .for_each(move |res| {
52        let ctx = ctx.clone();
53        async move {
54            match res {
55                Ok(event) => {
56                    trace!(msg = "watched replica cert event", ?event);
57                    match event {
58                        watcher::Event::InitApply(secret) | watcher::Event::Apply(secret) => {
59                            debug!(
60                                msg = "init or apply event for replica cert secret trigger reconcile",
61                                namespace = secret.namespace().unwrap(),
62                                name = secret.name_any()
63                            );
64                            let _ignore_errors = ctx.insert_repl_cert_exp(&secret).await.map_err(
65                                |e| error!(msg = "failed to get replica cert expiration, automatic certificate renewal may be affected", %e),
66                            );
67                        }
68                        watcher::Event::Delete(secret) => {
69                            debug!(
70                                msg = "delete event for replica cert secret",
71                                namespace = secret.namespace().unwrap(),
72                                name = secret.name_any()
73                            );
74                            ctx.remove_repl_cert_exp(&ObjectRef::from(&secret))
75                                .await;
76                            ctx.remove_repl_cert_host(&ObjectRef::from(&secret))
77                                .await;
78                        }
79                        _ => {}
80                    }
81                }
82                Err(e) => {
83                    error!(msg = "unexpected error when watching replica cert secrets", %e);
84                    ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
85                }
86            }
87        }
88    })
89    .boxed()
90}
91
92/// Initialize Kanidm controller and shared state
93pub async fn run(
94    state: State,
95    client: Client,
96    namespace_api: Api<Namespace>,
97    namespace_r: ResourceReflector<Namespace>,
98    kanidm_api: Api<Kanidm>,
99    kanidm_r: ResourceReflector<Kanidm>,
100) {
101    let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
102    let service = check_api_queryable::<Service>(client.clone()).await;
103    let ingress = check_api_queryable::<Ingress>(client.clone()).await;
104    let secret = check_api_queryable::<Secret>(client.clone()).await;
105
106    let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
107    let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
108    let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
109    let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
110    let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
111
112    let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
113
114    let stores = Stores {
115        stateful_set_store: statefulset_r.store,
116        service_store: service_r.store,
117        ingress_store: ingress_r.store,
118        secret_store: secret_r.store,
119    };
120
121    let ctx = Arc::new(Context::new(
122        state.to_context(client, CONTROLLER_ID),
123        stores,
124    ));
125    let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
126    let statefulset_watcher = create_watcher(
127        statefulset,
128        statefulset_r.writer,
129        reload_tx.clone(),
130        CONTROLLER_ID,
131        kaniop_ctx.clone(),
132    );
133    let service_watcher = create_watcher(
134        service,
135        service_r.writer,
136        reload_tx.clone(),
137        CONTROLLER_ID,
138        kaniop_ctx.clone(),
139    );
140    let ingress_watcher = create_watcher(
141        ingress,
142        ingress_r.writer,
143        reload_tx.clone(),
144        CONTROLLER_ID,
145        kaniop_ctx.clone(),
146    );
147    let secret_watcher = create_watcher(
148        secret.clone(),
149        secret_r.writer,
150        reload_tx.clone(),
151        CONTROLLER_ID,
152        kaniop_ctx,
153    );
154
155    let replica_cert_secrets_watcher =
156        create_replica_cert_watcher(secret, replica_cert_secret_r.writer, ctx.clone());
157
158    let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
159        .default_backoff()
160        .reflect(namespace_r.writer)
161        .for_each(|res| {
162            let ctx = ctx.clone();
163            async move {
164                match res {
165                    Ok(event) => {
166                        trace!(msg = format!("receive namespace event: {event:?}"),)
167                    }
168                    Err(e) => {
169                        error!(msg = format!("unexpected error when watching namespace"), %e);
170                        ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
171                    }
172                }
173            }
174        });
175
176    info!(msg = format!("starting {CONTROLLER_ID} controller"));
177    // TODO: watcher::Config::default().streaming_lists() when stabilized in K8s (1.34+)
178    // https://kubernetes.io/docs/reference/using-api/api-concepts/#streaming-lists
179    let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
180        .default_backoff()
181        .reflect(kanidm_r.writer)
182        .touched_objects();
183
184    let kanidm_controller = Controller::for_stream(kanidm_watcher, kanidm_r.store)
185        // debounce to filter out reconcile calls that happen quick succession (only taking the latest)
186        .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
187        .owns_shared_stream(statefulset_r.subscriber)
188        .owns_shared_stream(service_r.subscriber)
189        .owns_shared_stream(ingress_r.subscriber)
190        .owns_shared_stream(secret_r.subscriber)
191        .owns_shared_stream(replica_cert_secret_r.subscriber)
192        .reconcile_all_on(reload_rx.map(|_| ()))
193        .shutdown_on_signal()
194        .run(
195            backoff_reconciler!(reconcile_kanidm),
196            |_obj, _error: &Error, _ctx| unreachable!(),
197            ctx.clone(),
198        )
199        .filter_map(|x| async move { std::result::Result::ok(x) })
200        .for_each(|_| futures::future::ready(()));
201
202    ctx.kaniop_ctx.metrics.ready_set(1);
203    tokio::select! {
204        _ = kanidm_controller => {},
205        _ = namespace_watcher => {},
206        _ = statefulset_watcher => {},
207        _ = service_watcher => {},
208        _ = ingress_watcher => {},
209        _ = secret_watcher => {},
210        _ = replica_cert_secrets_watcher => {},
211    }
212}