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, 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 }
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
90pub 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 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 .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}