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 crate::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                        }
77                        _ => {}
78                    }
79                }
80                Err(e) => {
81                    error!(msg = "unexpected error when watching replica cert secrets", %e);
82                    ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
83                }
84            }
85        }
86    })
87    .boxed()
88}
89
90/// Initialize Kanidm controller and shared state
91pub async fn run(
92    state: State,
93    client: Client,
94    namespace_api: Api<Namespace>,
95    namespace_r: ResourceReflector<Namespace>,
96    kanidm_api: Api<Kanidm>,
97    kanidm_r: ResourceReflector<Kanidm>,
98) {
99    let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
100    let service = check_api_queryable::<Service>(client.clone()).await;
101    let ingress = check_api_queryable::<Ingress>(client.clone()).await;
102    let secret = check_api_queryable::<Secret>(client.clone()).await;
103
104    let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
105    let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
106    let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
107    let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
108    let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
109
110    let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
111
112    let stores = Stores {
113        stateful_set_store: statefulset_r.store,
114        service_store: service_r.store,
115        ingress_store: ingress_r.store,
116        secret_store: secret_r.store,
117    };
118
119    let ctx = Arc::new(Context::new(
120        state.to_context(client, CONTROLLER_ID),
121        stores,
122    ));
123    let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
124    let statefulset_watcher = create_watcher(
125        statefulset,
126        statefulset_r.writer,
127        reload_tx.clone(),
128        CONTROLLER_ID,
129        kaniop_ctx.clone(),
130    );
131    let service_watcher = create_watcher(
132        service,
133        service_r.writer,
134        reload_tx.clone(),
135        CONTROLLER_ID,
136        kaniop_ctx.clone(),
137    );
138    let ingress_watcher = create_watcher(
139        ingress,
140        ingress_r.writer,
141        reload_tx.clone(),
142        CONTROLLER_ID,
143        kaniop_ctx.clone(),
144    );
145    let secret_watcher = create_watcher(
146        secret.clone(),
147        secret_r.writer,
148        reload_tx.clone(),
149        CONTROLLER_ID,
150        kaniop_ctx,
151    );
152
153    let replica_cert_secrets_watcher =
154        create_replica_cert_watcher(secret, replica_cert_secret_r.writer, ctx.clone());
155
156    let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
157        .default_backoff()
158        .reflect(namespace_r.writer)
159        .for_each(|res| {
160            let ctx = ctx.clone();
161            async move {
162                match res {
163                    Ok(event) => {
164                        trace!(msg = format!("receive namespace event: {event:?}"),)
165                    }
166                    Err(e) => {
167                        error!(msg = format!("unexpected error when watching namespace"), %e);
168                        ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
169                    }
170                }
171            }
172        });
173
174    info!(msg = format!("starting {CONTROLLER_ID} controller"));
175    // TODO: watcher::Config::default().streaming_lists() when stabilized in K8s (1.34+)
176    // https://kubernetes.io/docs/reference/using-api/api-concepts/#streaming-lists
177    let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
178        .default_backoff()
179        .reflect(kanidm_r.writer)
180        .touched_objects();
181
182    let kanidm_controller = Controller::for_stream(kanidm_watcher, kanidm_r.store)
183        // debounce to filter out reconcile calls that happen quick succession (only taking the latest)
184        .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
185        .owns_shared_stream(statefulset_r.subscriber)
186        .owns_shared_stream(service_r.subscriber)
187        .owns_shared_stream(ingress_r.subscriber)
188        .owns_shared_stream(secret_r.subscriber)
189        .owns_shared_stream(replica_cert_secret_r.subscriber)
190        .reconcile_all_on(reload_rx.map(|_| ()))
191        .shutdown_on_signal()
192        .run(
193            backoff_reconciler!(reconcile_kanidm),
194            |_obj, _error: &Error, _ctx| unreachable!(),
195            ctx.clone(),
196        )
197        .filter_map(|x| async move { std::result::Result::ok(x) })
198        .for_each(|_| futures::future::ready(()));
199
200    ctx.kaniop_ctx.metrics.ready_set(1);
201    tokio::select! {
202        _ = kanidm_controller => {},
203        _ = namespace_watcher => {},
204        _ = statefulset_watcher => {},
205        _ = service_watcher => {},
206        _ = ingress_watcher => {},
207        _ = secret_watcher => {},
208        _ = replica_cert_secrets_watcher => {},
209    }
210}