kaniop_oauth2/
controller.rs1use crate::crd::KanidmOAuth2Client;
2use crate::reconcile::reconcile_oauth2;
3
4use kaniop_k8s_util::error::{Error, Result};
5use kaniop_operator::backoff_reconciler;
6use kaniop_operator::controller::{
7 ControllerId, State, check_api_queryable,
8 context::{BackoffContext, Context as KaniopContext, IdmClientContext},
9};
10use kaniop_operator::controller::{
11 RELOAD_BUFFER_SIZE, SUBSCRIBE_BUFFER_SIZE, create_metadata_watcher, create_subscriber,
12};
13use kaniop_operator::metrics::ControllerMetrics;
14
15use std::sync::Arc;
16
17use futures::StreamExt;
18use futures::channel::mpsc;
19use k8s_openapi::api::core::v1::Secret;
20use kanidm_client::KanidmClient;
21use kube::api::PartialObjectMeta;
22use kube::client::Client;
23use kube::runtime::controller::{self, Controller};
24use kube::runtime::reflector::{ObjectRef, Store};
25use kube::runtime::watcher;
26use tokio::time::Duration;
27use tracing::info;
28
29pub const CONTROLLER_ID: ControllerId = "oauth2";
30
31#[derive(Clone)]
32pub struct Context {
33 pub kaniop_ctx: KaniopContext<KanidmOAuth2Client>,
34 pub secret_store: Store<PartialObjectMeta<Secret>>,
36}
37
38impl Context {
39 pub fn new(
40 kaniop_ctx: KaniopContext<KanidmOAuth2Client>,
41 secret_store: Store<PartialObjectMeta<Secret>>,
42 ) -> Self {
43 Context {
44 kaniop_ctx,
45 secret_store,
46 }
47 }
48}
49
50impl BackoffContext<KanidmOAuth2Client> for Context {
51 fn metrics(&self) -> &Arc<ControllerMetrics> {
52 self.kaniop_ctx.metrics()
53 }
54 async fn get_backoff(&self, obj_ref: ObjectRef<KanidmOAuth2Client>) -> Duration {
55 self.kaniop_ctx.get_backoff(obj_ref).await
56 }
57
58 async fn reset_backoff(&self, obj_ref: ObjectRef<KanidmOAuth2Client>) {
59 self.kaniop_ctx.reset_backoff(obj_ref).await
60 }
61}
62
63impl IdmClientContext<KanidmOAuth2Client> for Context {
64 async fn get_idm_client(&self, obj: &KanidmOAuth2Client) -> Result<Arc<KanidmClient>> {
65 self.kaniop_ctx.get_idm_client(obj).await
66 }
67}
68
69pub async fn run(state: State, client: Client) {
71 let oauth2 = check_api_queryable::<KanidmOAuth2Client>(client.clone()).await;
72 let secret = check_api_queryable::<PartialObjectMeta<Secret>>(client.clone()).await;
73 let secret_r = create_subscriber::<PartialObjectMeta<Secret>>(SUBSCRIBE_BUFFER_SIZE);
74
75 let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
76 let ctx = Arc::new(Context::new(
77 state.to_context(client, CONTROLLER_ID),
78 secret_r.store,
79 ));
80 let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
81
82 let secret_watcher = create_metadata_watcher(
83 secret,
84 secret_r.writer,
85 reload_tx.clone(),
86 CONTROLLER_ID,
87 kaniop_ctx,
88 );
89 info!(controller = CONTROLLER_ID, "starting controller");
90 let oauth2_controller = Controller::new(oauth2, watcher::Config::default().any_semantic())
93 .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
95 .owns_shared_stream(secret_r.subscriber)
96 .reconcile_all_on(reload_rx.map(|_| ()))
97 .shutdown_on_signal()
98 .run(
99 backoff_reconciler!(reconcile_oauth2),
100 |_obj, _error: &Error, _ctx| unreachable!(),
101 ctx.clone(),
102 )
103 .filter_map(|x| async move { std::result::Result::ok(x) })
104 .for_each(|_| futures::future::ready(()));
105
106 ctx.kaniop_ctx.metrics.ready_set(1);
107 tokio::select! {
108 _ = oauth2_controller => {},
109 _ = secret_watcher => {},
110 }
111}