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 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
92pub 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 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 .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}