Skip to main content

kaniop_oauth2/reconcile/
mod.rs

1mod secret;
2mod status;
3
4use self::secret::SecretExt;
5use self::status::{
6    CONDITION_FALSE, CONDITION_TRUE, StatusExt, TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED,
7    TYPE_CLAIMS_MAP_UPDATED, TYPE_DISABLE_CONSENT_PROMPT_UPDATED, TYPE_DISABLE_PKCE_UPDATED,
8    TYPE_EXISTS, TYPE_IMAGE_UPDATED, TYPE_LEGACY_CRYPTO_UPDATED, TYPE_PREFER_SHORT_NAME_UPDATED,
9    TYPE_REDIRECT_URL_UPDATED, TYPE_SCOPE_MAP_UPDATED, TYPE_SECRET_INITIALIZED,
10    TYPE_SECRET_KEY_ALIASES_SYNCED, TYPE_SECRET_ROTATED, TYPE_SECRET_TEMPLATE_SYNCED,
11    TYPE_STRICT_REDIRECT_URL_UPDATED, TYPE_SUP_SCOPE_MAP_UPDATED, TYPE_UPDATED,
12};
13use kaniop_k8s_util::image::{ImageOperation, publish_image_error_event, update_image_if_needed};
14
15use crate::{
16    controller::Context,
17    crd::{
18        KanidmClaimMap, KanidmOAuth2Client, KanidmOAuth2ClientStatus, KanidmScopeMap,
19        OAuth2ClientImageStatus,
20    },
21};
22
23use kanidm_proto::internal::OperationError;
24use kaniop_k8s_util::error::{Error, Result};
25use kaniop_operator::controller::context::{IdmClientContext, KubeOperations};
26use kaniop_operator::controller::idm_reconcile_interval;
27use kaniop_operator::controller::kanidm::{KanidmResource, is_resource_watched};
28use kaniop_operator::metrics::{
29    KANIDM_OP_ADD_ORIGIN, KANIDM_OP_CREATE, KANIDM_OP_DELETE, KANIDM_OP_DELETE_CLAIM_MAP,
30    KANIDM_OP_DELETE_IMAGE, KANIDM_OP_DELETE_SCOPE_MAP, KANIDM_OP_DELETE_SUP_SCOPE_MAP,
31    KANIDM_OP_GET_SECRET, KANIDM_OP_REMOVE_ORIGIN, KANIDM_OP_RESET_SECRET, KANIDM_OP_UPDATE,
32    KANIDM_OP_UPDATE_CLAIM_MAP, KANIDM_OP_UPDATE_CLAIM_MAP_JOIN, KANIDM_OP_UPDATE_IMAGE,
33    KANIDM_OP_UPDATE_SCOPE_MAP, KANIDM_OP_UPDATE_SUP_SCOPE_MAP, KANIDM_OUTCOME_CHANGED,
34    KANIDM_RESOURCE_OAUTH2, record_kanidm_sdk_call,
35};
36use kaniop_operator::object_meta_template::ObjectMetaTemplateExt;
37use kaniop_operator::telemetry;
38
39use std::collections::BTreeSet;
40use std::sync::Arc;
41use std::time::Duration;
42
43use futures::future::TryJoinAll;
44use futures::try_join;
45
46use k8s_openapi::NamespaceResourceScope;
47use k8s_openapi::api::core::v1::Secret;
48use kanidm_client::{ClientError, KanidmClient, StatusCode};
49use kanidm_proto::constants::{
50    ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE, ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
51    ATTR_OAUTH2_CONSENT_PROMPT_ENABLE, ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
52    ATTR_OAUTH2_PREFER_SHORT_USERNAME, ATTR_OAUTH2_RS_CLAIM_MAP, ATTR_OAUTH2_RS_ORIGIN,
53    ATTR_OAUTH2_RS_SCOPE_MAP, ATTR_OAUTH2_RS_SUP_SCOPE_MAP, ATTR_OAUTH2_STRICT_REDIRECT_URI,
54};
55use kube::api::{Api, Patch, PatchParams};
56use kube::runtime::controller::Action;
57use kube::runtime::events::{Event, EventType};
58use kube::runtime::finalizer::{Error as FinalizerError, Event as Finalizer, finalizer};
59use kube::{Resource, ResourceExt};
60use serde::{Deserialize, Serialize};
61use serde_json::json;
62
63use tracing::{Span, debug, field, info, instrument, trace, warn};
64
65static OAUTH2_OPERATOR_NAME: &str = "kanidmoauth2clients.kaniop.rs";
66static OAUTH2_FINALIZER: &str = "kanidmoauth2clients.kaniop.rs/finalizer";
67pub const FORCE_SECRET_ROTATION_ANNOTATION: &str = "kaniop.rs/force-secret-rotation";
68pub const SECRET_KEY_ALIASES_GENERATION_ANNOTATION: &str =
69    "kaniop.rs/secret-key-aliases-generation";
70
71pub async fn watched_resource(oauth2: &KanidmOAuth2Client, ctx: Arc<Context>) -> bool {
72    let kanidm = if let Some(k) = ctx.kaniop_ctx.get_kanidm(oauth2) {
73        k
74    } else {
75        trace!(msg = "no kanidm found");
76        return false;
77    };
78
79    is_resource_watched(
80        oauth2,
81        &kanidm,
82        &ctx.kaniop_ctx.namespace_store,
83        &ctx.kaniop_ctx.client,
84    )
85    .await
86}
87
88#[instrument(skip(ctx, oauth2))]
89pub async fn reconcile_oauth2(
90    oauth2: Arc<KanidmOAuth2Client>,
91    ctx: Arc<Context>,
92) -> Result<(Action, bool)> {
93    let trace_id = telemetry::get_trace_id();
94    Span::current().record("trace_id", field::display(&trace_id));
95    let _timer = ctx
96        .kaniop_ctx
97        .metrics
98        .reconcile_count_and_measure(&trace_id);
99    if !ctx.kaniop_ctx.kanidm_write_allowed(&oauth2) {
100        debug!(msg = "Kanidm restore in progress, pausing identity writes");
101        return Ok((Action::requeue(Duration::from_secs(5)), false));
102    }
103    let kanidm_client = ctx.get_idm_client(&oauth2).await?;
104
105    if !watched_resource(&oauth2, ctx.clone()).await {
106        debug!(msg = "resource not watched, skipping reconcile");
107        ctx.kaniop_ctx.recorder
108        .publish(
109            &Event {
110                type_: EventType::Warning,
111                reason: "ResourceNotWatched".to_string(),
112                note: Some("configure `oauth2ClientNamespaceSelector` on Kanidm resource to watch this namespace".to_string()),
113                action: "Reconcile".to_string(),
114                secondary: None,
115            },
116            &oauth2.object_ref(&()),
117        )
118        .await
119        .map_err(|e| {
120            warn!(msg = "failed to publish KanidmError event", %e);
121            Error::kube_error("publish", "event", oauth2.get_namespace(), oauth2.name_any(), e)
122        })?;
123        return Ok((Action::requeue(idm_reconcile_interval()), false));
124    }
125
126    info!(msg = "reconciling oauth2 client");
127    let namespace = oauth2.get_namespace();
128    let status = oauth2
129        .update_status(kanidm_client.clone(), ctx.clone())
130        .await
131        .map_err(|e| {
132            debug!(msg = "failed to reconcile status", %e);
133            ctx.kaniop_ctx.metrics.status_update_errors_inc();
134            e
135        })?;
136    let persons_api: Api<KanidmOAuth2Client> =
137        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
138    let outcome = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
139    let outcome_clone = outcome.clone();
140    let action = finalizer(&persons_api, OAUTH2_FINALIZER, oauth2, move |event| {
141        let outcome = outcome_clone.clone();
142        let ctx = ctx.clone();
143        let status = status.clone();
144        let kanidm_client = kanidm_client.clone();
145        async move {
146            match event {
147                Finalizer::Apply(p) => {
148                    let (action, changed) = p.reconcile(kanidm_client, status, ctx.clone()).await?;
149                    outcome.store(changed, std::sync::atomic::Ordering::Relaxed);
150                    Ok(action)
151                }
152                Finalizer::Cleanup(p) => {
153                    let (action, changed) = p.cleanup(kanidm_client, status, ctx).await?;
154                    outcome.store(changed, std::sync::atomic::Ordering::Relaxed);
155                    Ok(action)
156                }
157            }
158        }
159    })
160    .await
161    .or_else(|e| match e {
162        FinalizerError::RemoveFinalizer(kube::Error::Api(ae)) if ae.code == 404 => {
163            debug!(msg = "resource already removed during finalizer cleanup");
164            Ok(Action::requeue(idm_reconcile_interval()))
165        }
166        _ => Err(Error::FinalizerError(
167            "failed on oauth2 client finalizer".to_string(),
168            Box::new(e),
169        )),
170    })?;
171    let changed = outcome.load(std::sync::atomic::Ordering::Relaxed);
172    Ok((action, changed))
173}
174
175impl KanidmOAuth2Client {
176    // Method kube_patch are provided by KubeOperations trait
177    pub async fn patch<K>(&self, ctx: &Context, resource: K) -> Result<K>
178    where
179        K: Resource<Scope = NamespaceResourceScope>
180            + Serialize
181            + Clone
182            + std::fmt::Debug
183            + for<'de> Deserialize<'de>,
184        <K as kube::Resource>::DynamicType: Default,
185        <K as Resource>::Scope: std::marker::Sized,
186    {
187        self.kube_patch(
188            ctx.kaniop_ctx.client.clone(),
189            &ctx.kaniop_ctx.metrics,
190            resource,
191            OAUTH2_OPERATOR_NAME,
192        )
193        .await
194    }
195
196    async fn apply_secret(&self, ctx: &Context, secret: Secret) -> Result<Secret> {
197        self.patch(ctx, secret).await
198    }
199
200    #[inline]
201    fn get_namespace(&self) -> String {
202        // safe unwrap: oauth2 is namespaced scoped
203        self.namespace().unwrap()
204    }
205
206    #[inline]
207    fn force_secret_rotation_requested(&self) -> bool {
208        self.annotations()
209            .get(FORCE_SECRET_ROTATION_ANNOTATION)
210            .is_some()
211    }
212
213    async fn clear_force_secret_rotation_annotation(&self, ctx: Arc<Context>) -> Result<()> {
214        let namespace = self.get_namespace();
215        let patch = Patch::Merge(json!({
216            "metadata": {
217                "annotations": {
218                    FORCE_SECRET_ROTATION_ANNOTATION: null
219                }
220            }
221        }));
222        let params = PatchParams::default();
223        let oauth2_api =
224            Api::<KanidmOAuth2Client>::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
225        oauth2_api
226            .patch(&self.name_any(), &params, &patch)
227            .await
228            .map_err(|e| {
229                Error::KubeError(
230                    format!(
231                        "failed to clear annotation {FORCE_SECRET_ROTATION_ANNOTATION} on {namespace}/{}",
232                        self.name_any()
233                    ),
234                    Box::new(e),
235                )
236            })?;
237        Ok(())
238    }
239
240    async fn patch_alias_generation_annotation(
241        &self,
242        ctx: Arc<Context>,
243        generation: i64,
244    ) -> Result<()> {
245        let namespace = self.get_namespace();
246        let patch = Patch::Merge(json!({
247            "metadata": {
248                "annotations": {
249                    SECRET_KEY_ALIASES_GENERATION_ANNOTATION: generation.to_string()
250                }
251            }
252        }));
253        let params = PatchParams::default();
254        let oauth2_api =
255            Api::<KanidmOAuth2Client>::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
256        oauth2_api
257            .patch(&self.name_any(), &params, &patch)
258            .await
259            .map_err(|e| {
260                Error::KubeError(
261                    format!(
262                        "failed to set annotation {SECRET_KEY_ALIASES_GENERATION_ANNOTATION} on {namespace}/{}",
263                        self.name_any()
264                    ),
265                    Box::new(e),
266                )
267            })?;
268        Ok(())
269    }
270
271    #[inline]
272    async fn reconcile(
273        &self,
274        kanidm_client: Arc<KanidmClient>,
275        status: KanidmOAuth2ClientStatus,
276        ctx: Arc<Context>,
277    ) -> Result<(Action, bool)> {
278        match self
279            .internal_reconcile(kanidm_client, status, ctx.clone())
280            .await
281        {
282            Ok(result) => Ok(result),
283            Err(e) => match &e {
284                Error::KanidmClientError(msg, client_err) => {
285                    let event_note = match client_err.as_ref() {
286                        ClientError::Http(
287                            StatusCode::NOT_FOUND,
288                            Some(OperationError::NoMatchingEntries),
289                            kopid,
290                        ) => {
291                            format!("group not found: {msg}. KOpId: {kopid}")
292                        }
293                        _ => {
294                            format!("{msg}: KanidmClientError: {client_err:?}")
295                        }
296                    };
297                    ctx.kaniop_ctx
298                        .recorder
299                        .publish(
300                            &Event {
301                                type_: EventType::Warning,
302                                reason: "KanidmError".to_string(),
303                                note: Some(event_note),
304                                action: "KanidmRequest".to_string(),
305                                secondary: None,
306                            },
307                            &self.object_ref(&()),
308                        )
309                        .await
310                        .map_err(|e| {
311                            warn!(msg = "failed to publish KanidmError event", %e);
312                            Error::kube_error(
313                                "publish",
314                                "event",
315                                self.get_namespace(),
316                                self.name_any(),
317                                e,
318                            )
319                        })?;
320                    Err(e)
321                }
322                _ => Err(e),
323            },
324        }
325    }
326
327    #[inline]
328    async fn internal_reconcile(
329        &self,
330        kanidm_client: Arc<KanidmClient>,
331        status: KanidmOAuth2ClientStatus,
332        ctx: Arc<Context>,
333    ) -> Result<(Action, bool)> {
334        let name = &self.kanidm_entity_name();
335        let namespace = self.get_namespace();
336        let metrics = &ctx.kaniop_ctx.metrics;
337        let mut require_status_update = false;
338        let mut changed = false;
339        let force_secret_rotation_requested = self.force_secret_rotation_requested();
340
341        if is_oauth2_false(TYPE_EXISTS, status.clone()) {
342            self.create(&kanidm_client, name, metrics).await?;
343            require_status_update = true;
344            changed = true;
345        }
346
347        if is_oauth2_false(TYPE_SECRET_INITIALIZED, status.clone()) {
348            let secret = record_kanidm_sdk_call(
349                metrics,
350                KANIDM_RESOURCE_OAUTH2,
351                KANIDM_OP_GET_SECRET,
352                KANIDM_OUTCOME_CHANGED,
353                self.generate_secret(
354                    &kanidm_client,
355                    self.spec.secret_rotation.as_ref(),
356                    self.spec.secret_key_aliases.as_ref(),
357                ),
358            )
359            .await?;
360            self.apply_secret(&ctx, secret).await?;
361            return Ok((Action::requeue(Duration::from_millis(500)), true));
362        }
363
364        if is_oauth2_false(TYPE_SECRET_KEY_ALIASES_SYNCED, status.clone())
365            && !force_secret_rotation_requested
366        {
367            // Handle secret key aliases sync - regenerate secret if aliases are not synced.
368            // Skip this if force rotation is requested, as rotation will regenerate the secret.
369            // We regenerate when TYPE_SECRET_KEY_ALIASES_SYNCED is False, regardless of annotation.
370            // This ensures we keep regenerating until the secret actually has the correct keys.
371            // The annotation is updated only when TYPE is True (confirmed synced).
372            info!(msg = "regenerating secret due to secretKeyAliases not synced");
373            let secret = record_kanidm_sdk_call(
374                metrics,
375                KANIDM_RESOURCE_OAUTH2,
376                KANIDM_OP_GET_SECRET,
377                KANIDM_OUTCOME_CHANGED,
378                self.generate_secret(
379                    &kanidm_client,
380                    self.spec.secret_rotation.as_ref(),
381                    self.spec.secret_key_aliases.as_ref(),
382                ),
383            )
384            .await?;
385            self.apply_secret(&ctx, secret).await?;
386            return Ok((Action::requeue(Duration::from_millis(500)), true));
387        }
388
389        let current_generation = self.metadata.generation.unwrap_or(0);
390        let annotation_generation = self
391            .annotations()
392            .get(SECRET_KEY_ALIASES_GENERATION_ANNOTATION)
393            .and_then(|v| v.parse::<i64>().ok())
394            .unwrap_or(0);
395        if is_oauth2(TYPE_SECRET_KEY_ALIASES_SYNCED, status.clone())
396            && current_generation > annotation_generation
397        {
398            // Update annotation when aliases are confirmed synced but annotation is outdated.
399            // Do this only after TYPE is True to avoid race conditions.
400            self.patch_alias_generation_annotation(ctx.clone(), current_generation)
401                .await?;
402            require_status_update = true;
403        }
404
405        if force_secret_rotation_requested {
406            if self.spec.public {
407                info!(msg = "skipping forced secret rotation annotation for public OAuth2 client");
408            } else {
409                info!(msg = "rotating OAuth2 client secret due to force annotation");
410                self.rotate_secret(&kanidm_client, name, ctx.clone(), metrics)
411                    .await?;
412            }
413            self.clear_force_secret_rotation_annotation(ctx.clone())
414                .await?;
415            require_status_update = true;
416            changed = true;
417        } else if is_oauth2_false(TYPE_SECRET_ROTATED, status.clone()) {
418            // Handle scheduled secret rotation for confidential clients
419            self.rotate_secret(&kanidm_client, name, ctx.clone(), metrics)
420                .await?;
421            require_status_update = true;
422            changed = true;
423        }
424
425        if is_oauth2_false(TYPE_SECRET_TEMPLATE_SYNCED, status.clone()) {
426            // Note: when the Secret is created in this same reconcile cycle,
427            // TYPE_SECRET_TEMPLATE_SYNCED is absent (not False) in `status` because the Secret
428            // didn't exist when `update_status` ran. The template apply is therefore deferred to
429            // the next reconcile after the watch delivers the new Secret to the store.
430            match ctx.secret_store.find(|s| {
431                s.name_any() == self.secret_name() && s.namespace().as_ref() == Some(&namespace)
432            }) {
433                None => debug!(msg = "secret not yet in store, deferring secretTemplate apply"),
434                Some(secret_meta) => {
435                    // Re-evaluate here rather than reusing the status result: the store may
436                    // have been updated between update_status and now, and we need the
437                    // FilteredMetadata value (including has_discards) which is not carried
438                    // through the status conditions.
439                    if let Some(filtered) = self.needs_meta_template_apply(&secret_meta) {
440                        if filtered.has_discards() {
441                            warn!(
442                                msg = "secretTemplate contains keys already owned by the operator; they will be ignored",
443                                discarded_labels = ?filtered.discarded_labels,
444                                discarded_annotations = ?filtered.discarded_annotations,
445                            );
446                            ctx.kaniop_ctx
447                                .recorder
448                                .publish(
449                                    &Event {
450                                        type_: EventType::Warning,
451                                        reason: "SecretTemplateConflict".to_string(),
452                                        note: Some(format!(
453                                            "secretTemplate contains keys already owned by the \
454                                             operator and will be ignored. Labels: [{}]. \
455                                             Annotations: [{}].",
456                                            filtered
457                                                .discarded_labels
458                                                .iter()
459                                                .cloned()
460                                                .collect::<Vec<_>>()
461                                                .join(", "),
462                                            filtered
463                                                .discarded_annotations
464                                                .iter()
465                                                .cloned()
466                                                .collect::<Vec<_>>()
467                                                .join(", "),
468                                        )),
469                                        action: "ApplySecretTemplate".to_string(),
470                                        secondary: None,
471                                    },
472                                    &self.object_ref(&()),
473                                )
474                                .await
475                                .map_err(|e| {
476                                    warn!(msg = "failed to publish SecretTemplateConflict event", %e);
477Error::kube_error("publish", "event", self.get_namespace(), self.name_any(), e)
478                                })?;
479                        }
480                        self.apply_meta_template(
481                            ctx.kaniop_ctx.client.clone(),
482                            &ctx.kaniop_ctx.metrics,
483                            filtered,
484                        )
485                        .await?;
486                        require_status_update = true;
487                        changed = true;
488                    }
489                }
490            }
491        }
492
493        if is_oauth2_false(TYPE_UPDATED, status.clone()) {
494            self.update(&kanidm_client, name, metrics).await?;
495            require_status_update = true;
496            changed = true;
497        }
498
499        if is_oauth2_false(TYPE_REDIRECT_URL_UPDATED, status.clone()) {
500            self.update_redirect_url(&kanidm_client, name, &status, metrics)
501                .await?;
502            require_status_update = true;
503            changed = true;
504        }
505
506        if is_oauth2_false(TYPE_SCOPE_MAP_UPDATED, status.clone()) {
507            self.update_scope_map(&kanidm_client, name, &status, metrics)
508                .await?;
509            require_status_update = true;
510            changed = true;
511        }
512
513        if is_oauth2_false(TYPE_SUP_SCOPE_MAP_UPDATED, status.clone()) {
514            self.update_sup_scope_map(&kanidm_client, name, &status, metrics)
515                .await?;
516            require_status_update = true;
517            changed = true;
518        }
519
520        if is_oauth2_false(TYPE_CLAIMS_MAP_UPDATED, status.clone()) {
521            self.update_claims_map(&kanidm_client, name, &status, metrics)
522                .await?;
523            require_status_update = true;
524            changed = true;
525        }
526
527        if is_oauth2_false(TYPE_STRICT_REDIRECT_URL_UPDATED, status.clone()) {
528            self.update_strict_redirect_url(&kanidm_client, name, metrics)
529                .await?;
530            require_status_update = true;
531            changed = true;
532        }
533
534        if is_oauth2_false(TYPE_DISABLE_PKCE_UPDATED, status.clone()) {
535            self.update_disable_pkce(&kanidm_client, name, metrics)
536                .await?;
537            require_status_update = true;
538            changed = true;
539        }
540
541        if is_oauth2_false(TYPE_PREFER_SHORT_NAME_UPDATED, status.clone()) {
542            self.update_prefer_short_name(&kanidm_client, name, metrics)
543                .await?;
544            require_status_update = true;
545            changed = true;
546        }
547
548        if is_oauth2_false(TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED, status.clone()) {
549            self.update_allow_localhost_redirect(&kanidm_client, name, metrics)
550                .await?;
551            require_status_update = true;
552            changed = true;
553        }
554
555        if is_oauth2_false(TYPE_LEGACY_CRYPTO_UPDATED, status.clone()) {
556            self.update_legacy_crypto(&kanidm_client, name, metrics)
557                .await?;
558            require_status_update = true;
559            changed = true;
560        }
561
562        if is_oauth2_false(TYPE_DISABLE_CONSENT_PROMPT_UPDATED, status.clone()) {
563            self.update_consent_prompt(&kanidm_client, name, metrics)
564                .await?;
565            require_status_update = true;
566            changed = true;
567        }
568
569        if is_oauth2_false(TYPE_IMAGE_UPDATED, status.clone()) {
570            let image_changed = self
571                .update_image(&kanidm_client, name, &status, ctx.clone(), metrics)
572                .await?;
573            require_status_update = true;
574            changed = changed || image_changed;
575        }
576
577        if require_status_update {
578            trace!(msg = "status update required, requeueing in 500ms");
579            Ok((Action::requeue(Duration::from_millis(500)), changed))
580        } else {
581            Ok((Action::requeue(idm_reconcile_interval()), changed))
582        }
583    }
584
585    async fn create(
586        &self,
587        kanidm_client: &KanidmClient,
588        name: &str,
589        metrics: &kaniop_operator::metrics::ControllerMetrics,
590    ) -> Result<()> {
591        debug!(msg = "create");
592        if self.spec.public {
593            debug!(msg = "create public client");
594            record_kanidm_sdk_call(
595                metrics,
596                KANIDM_RESOURCE_OAUTH2,
597                KANIDM_OP_CREATE,
598                KANIDM_OUTCOME_CHANGED,
599                kanidm_client.idm_oauth2_rs_public_create(
600                    name,
601                    &self.spec.displayname,
602                    &self.spec.origin,
603                ),
604            )
605            .await
606            .map_err(|e| {
607                Error::kanidm_client_error(
608                    "create",
609                    name,
610                    self.kanidm_namespace(),
611                    self.kanidm_name(),
612                    e,
613                )
614            })?;
615        } else {
616            record_kanidm_sdk_call(
617                metrics,
618                KANIDM_RESOURCE_OAUTH2,
619                KANIDM_OP_CREATE,
620                KANIDM_OUTCOME_CHANGED,
621                kanidm_client.idm_oauth2_rs_basic_create(
622                    name,
623                    &self.spec.displayname,
624                    &self.spec.origin,
625                ),
626            )
627            .await
628            .map_err(|e| {
629                Error::kanidm_client_error(
630                    "create",
631                    name,
632                    self.kanidm_namespace(),
633                    self.kanidm_name(),
634                    e,
635                )
636            })?;
637        }
638        Ok(())
639    }
640
641    async fn update(
642        &self,
643        kanidm_client: &KanidmClient,
644        name: &str,
645        metrics: &kaniop_operator::metrics::ControllerMetrics,
646    ) -> Result<()> {
647        debug!(msg = "update");
648        record_kanidm_sdk_call(
649            metrics,
650            KANIDM_RESOURCE_OAUTH2,
651            KANIDM_OP_UPDATE,
652            KANIDM_OUTCOME_CHANGED,
653            kanidm_client.idm_oauth2_rs_update(
654                name,
655                None,
656                Some(&self.spec.displayname),
657                Some(&self.spec.origin),
658                false,
659            ),
660        )
661        .await
662        .map_err(|e| {
663            Error::kanidm_client_error(
664                "update",
665                name,
666                self.kanidm_namespace(),
667                self.kanidm_name(),
668                e,
669            )
670        })?;
671        Ok(())
672    }
673
674    async fn rotate_secret(
675        &self,
676        kanidm_client: &KanidmClient,
677        name: &str,
678        ctx: Arc<Context>,
679        metrics: &kaniop_operator::metrics::ControllerMetrics,
680    ) -> Result<()> {
681        info!(msg = "rotating OAuth2 client secret");
682        // Reset the secret in Kanidm using idm_oauth2_rs_update with reset_secret=true
683        record_kanidm_sdk_call(
684            metrics,
685            KANIDM_RESOURCE_OAUTH2,
686            KANIDM_OP_RESET_SECRET,
687            KANIDM_OUTCOME_CHANGED,
688            kanidm_client.idm_oauth2_rs_update(name, None, None, None, true),
689        )
690        .await
691        .map_err(|e| {
692            Error::kanidm_client_error_attr(
693                "rotate",
694                "secret",
695                name,
696                self.kanidm_namespace(),
697                self.kanidm_name(),
698                e,
699            )
700        })?;
701
702        // Regenerate and patch the Kubernetes secret with the new client secret
703        let secret = record_kanidm_sdk_call(
704            metrics,
705            KANIDM_RESOURCE_OAUTH2,
706            KANIDM_OP_GET_SECRET,
707            KANIDM_OUTCOME_CHANGED,
708            self.generate_secret(
709                kanidm_client,
710                self.spec.secret_rotation.as_ref(),
711                self.spec.secret_key_aliases.as_ref(),
712            ),
713        )
714        .await?;
715        self.apply_secret(&ctx, secret).await?;
716        Ok(())
717    }
718
719    async fn update_redirect_url(
720        &self,
721        kanidm_client: &KanidmClient,
722        name: &str,
723        status: &KanidmOAuth2ClientStatus,
724        metrics: &kaniop_operator::metrics::ControllerMetrics,
725    ) -> Result<()> {
726        debug!(msg = format!("update {ATTR_OAUTH2_RS_ORIGIN} attribute"));
727
728        let current_urls: BTreeSet<_> = status
729            .origin
730            .as_ref()
731            .map(|o| o.iter().filter_map(|u| url::Url::parse(u).ok()).collect())
732            .unwrap_or_default();
733
734        let redirect_url = self
735            .spec
736            .redirect_url
737            .iter()
738            .map(|u| {
739                url::Url::parse(u).map_err(|e| {
740                    Error::UrlParseError(
741                        format!(
742                            "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
743                            namespace = self.kanidm_namespace(),
744                            kanidm = self.kanidm_name(),
745                        ),
746                        e,
747                    )
748                })
749            })
750            .collect::<Result<BTreeSet<_>>>()?;
751
752        let metrics_remove = metrics.clone();
753        let delete_futures = current_urls
754            .difference(&redirect_url)
755            .map(|url| {
756                let metrics = metrics_remove.clone();
757                async move {
758                    record_kanidm_sdk_call(
759                        &metrics,
760                        KANIDM_RESOURCE_OAUTH2,
761                        KANIDM_OP_REMOVE_ORIGIN,
762                        KANIDM_OUTCOME_CHANGED,
763                        kanidm_client.idm_oauth2_client_remove_origin(name, url),
764                    )
765                    .await
766                }
767            })
768            .collect::<TryJoinAll<_>>();
769
770        let metrics_add = metrics.clone();
771        let add_futures = redirect_url
772            .difference(&current_urls)
773            .map(|url| {
774                let metrics = metrics_add.clone();
775                async move {
776                    record_kanidm_sdk_call(
777                        &metrics,
778                        KANIDM_RESOURCE_OAUTH2,
779                        KANIDM_OP_ADD_ORIGIN,
780                        KANIDM_OUTCOME_CHANGED,
781                        kanidm_client.idm_oauth2_client_add_origin(name, url),
782                    )
783                    .await
784                }
785            })
786            .collect::<TryJoinAll<_>>();
787
788        futures::try_join!(delete_futures, add_futures).map_err(|e| {
789            Error::kanidm_client_error_attr(
790                "modify",
791                ATTR_OAUTH2_RS_ORIGIN,
792                name,
793                self.kanidm_namespace(),
794                self.kanidm_name(),
795                e,
796            )
797        })?;
798
799        Ok(())
800    }
801
802    async fn update_scope_map(
803        &self,
804        kanidm_client: &KanidmClient,
805        name: &str,
806        status: &KanidmOAuth2ClientStatus,
807        metrics: &kaniop_operator::metrics::ControllerMetrics,
808    ) -> Result<()> {
809        debug!(msg = format!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute"));
810
811        let current_scope_map: BTreeSet<_> = status
812            .scope_map
813            .as_ref()
814            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
815            .unwrap_or_default();
816
817        let scope_map: BTreeSet<KanidmScopeMap> = self
818            .spec
819            .scope_map
820            .clone()
821            .unwrap_or_default()
822            .clone()
823            .into_iter()
824            .collect();
825
826        let metrics_del = metrics.clone();
827        let delete_futures = current_scope_map
828            .difference(&scope_map)
829            .map(|s| {
830                let metrics = metrics_del.clone();
831                async move {
832                    record_kanidm_sdk_call(
833                        &metrics,
834                        KANIDM_RESOURCE_OAUTH2,
835                        KANIDM_OP_DELETE_SCOPE_MAP,
836                        KANIDM_OUTCOME_CHANGED,
837                        kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group),
838                    )
839                    .await
840                }
841            })
842            .collect::<TryJoinAll<_>>();
843
844        let metrics_add = metrics.clone();
845        let add_futures = scope_map
846            .difference(&current_scope_map)
847            .map(|s| {
848                let metrics = metrics_add.clone();
849                let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
850                async move {
851                    record_kanidm_sdk_call(
852                        &metrics,
853                        KANIDM_RESOURCE_OAUTH2,
854                        KANIDM_OP_UPDATE_SCOPE_MAP,
855                        KANIDM_OUTCOME_CHANGED,
856                        kanidm_client.idm_oauth2_rs_update_scope_map(name, &s.group, scopes),
857                    )
858                    .await
859                }
860            })
861            .collect::<TryJoinAll<_>>();
862
863        try_join!(delete_futures, add_futures).map_err(|e| {
864            Error::kanidm_client_error_attr(
865                "modify",
866                ATTR_OAUTH2_RS_SCOPE_MAP,
867                name,
868                self.kanidm_namespace(),
869                self.kanidm_name(),
870                e,
871            )
872        })?;
873        Ok(())
874    }
875
876    async fn update_sup_scope_map(
877        &self,
878        kanidm_client: &KanidmClient,
879        name: &str,
880        status: &KanidmOAuth2ClientStatus,
881        metrics: &kaniop_operator::metrics::ControllerMetrics,
882    ) -> Result<()> {
883        debug!(msg = format!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute"));
884
885        let current_sup_scope_map: BTreeSet<_> = status
886            .sup_scope_map
887            .as_ref()
888            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
889            .unwrap_or_default();
890
891        let sup_scope_map: BTreeSet<KanidmScopeMap> = self
892            .spec
893            .sup_scope_map
894            .clone()
895            .unwrap_or_default()
896            .clone()
897            .into_iter()
898            .collect();
899
900        let metrics_del = metrics.clone();
901        let delete_futures = current_sup_scope_map
902            .difference(&sup_scope_map)
903            .map(|s| {
904                let metrics = metrics_del.clone();
905                async move {
906                    record_kanidm_sdk_call(
907                        &metrics,
908                        KANIDM_RESOURCE_OAUTH2,
909                        KANIDM_OP_DELETE_SUP_SCOPE_MAP,
910                        KANIDM_OUTCOME_CHANGED,
911                        kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group),
912                    )
913                    .await
914                }
915            })
916            .collect::<TryJoinAll<_>>();
917
918        let metrics_add = metrics.clone();
919        let add_futures = sup_scope_map
920            .difference(&current_sup_scope_map)
921            .map(|s| {
922                let metrics = metrics_add.clone();
923                let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
924                async move {
925                    record_kanidm_sdk_call(
926                        &metrics,
927                        KANIDM_RESOURCE_OAUTH2,
928                        KANIDM_OP_UPDATE_SUP_SCOPE_MAP,
929                        KANIDM_OUTCOME_CHANGED,
930                        kanidm_client.idm_oauth2_rs_update_sup_scope_map(name, &s.group, scopes),
931                    )
932                    .await
933                }
934            })
935            .collect::<TryJoinAll<_>>();
936
937        try_join!(delete_futures, add_futures).map_err(|e| {
938            Error::kanidm_client_error_attr(
939                "modify",
940                ATTR_OAUTH2_RS_SUP_SCOPE_MAP,
941                name,
942                self.kanidm_namespace(),
943                self.kanidm_name(),
944                e,
945            )
946        })?;
947        Ok(())
948    }
949
950    async fn update_claims_map(
951        &self,
952        kanidm_client: &KanidmClient,
953        name: &str,
954        status: &KanidmOAuth2ClientStatus,
955        metrics: &kaniop_operator::metrics::ControllerMetrics,
956    ) -> Result<()> {
957        debug!(msg = format!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute"));
958
959        let current_claims_map: BTreeSet<_> = status
960            .claims_map
961            .as_ref()
962            .map(|v| {
963                KanidmClaimMap::group(
964                    &v.iter()
965                        .filter_map(|c| KanidmClaimMap::from(c))
966                        .collect::<Vec<_>>(),
967                )
968            })
969            .unwrap_or_default();
970
971        let claims_map: BTreeSet<KanidmClaimMap> = self
972            .spec
973            .claim_map
974            .clone()
975            .unwrap_or_default()
976            .clone()
977            .into_iter()
978            .collect();
979
980        let metrics_del = metrics.clone();
981        let delete_futures = current_claims_map
982            .difference(&claims_map)
983            .flat_map(|c| {
984                c.values_map
985                    .iter()
986                    .map(|v| {
987                        let metrics = metrics_del.clone();
988                        async move {
989                            record_kanidm_sdk_call(
990                                &metrics,
991                                KANIDM_RESOURCE_OAUTH2,
992                                KANIDM_OP_DELETE_CLAIM_MAP,
993                                KANIDM_OUTCOME_CHANGED,
994                                kanidm_client
995                                    .idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group),
996                            )
997                            .await
998                        }
999                    })
1000                    .collect::<Vec<_>>()
1001            })
1002            .collect::<TryJoinAll<_>>();
1003
1004        let claims_to_add = claims_map.difference(&current_claims_map);
1005        let metrics_add = metrics.clone();
1006        let add_futures = claims_to_add
1007            .clone()
1008            .flat_map(|c| {
1009                c.values_map
1010                    .iter()
1011                    .map(|v| {
1012                        let metrics = metrics_add.clone();
1013                        let values = v.values.clone();
1014                        async move {
1015                            record_kanidm_sdk_call(
1016                                &metrics,
1017                                KANIDM_RESOURCE_OAUTH2,
1018                                KANIDM_OP_UPDATE_CLAIM_MAP,
1019                                KANIDM_OUTCOME_CHANGED,
1020                                kanidm_client.idm_oauth2_rs_update_claim_map(
1021                                    name, &c.name, &v.group, &values,
1022                                ),
1023                            )
1024                            .await
1025                        }
1026                    })
1027                    .collect::<Vec<_>>()
1028            })
1029            .collect::<TryJoinAll<_>>();
1030
1031        let metrics_join = metrics.clone();
1032        let join_strategy_futures = claims_to_add
1033            .map(|c| {
1034                let metrics = metrics_join.clone();
1035                let join_strategy = c.join_strategy.to_oauth2_claim_map_join();
1036                async move {
1037                    record_kanidm_sdk_call(
1038                        &metrics,
1039                        KANIDM_RESOURCE_OAUTH2,
1040                        KANIDM_OP_UPDATE_CLAIM_MAP_JOIN,
1041                        KANIDM_OUTCOME_CHANGED,
1042                        kanidm_client.idm_oauth2_rs_update_claim_map_join(
1043                            name,
1044                            &c.name,
1045                            join_strategy,
1046                        ),
1047                    )
1048                    .await
1049                }
1050            })
1051            .collect::<TryJoinAll<_>>();
1052
1053        try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
1054            Error::kanidm_client_error_attr(
1055                "modify",
1056                ATTR_OAUTH2_RS_CLAIM_MAP,
1057                name,
1058                self.kanidm_namespace(),
1059                self.kanidm_name(),
1060                e,
1061            )
1062        })?;
1063        Ok(())
1064    }
1065
1066    async fn update_strict_redirect_url(
1067        &self,
1068        kanidm_client: &KanidmClient,
1069        name: &str,
1070        metrics: &kaniop_operator::metrics::ControllerMetrics,
1071    ) -> Result<()> {
1072        debug!(msg = format!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute"));
1073        if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
1074            if strict_redirect_url_enabled {
1075                record_kanidm_sdk_call(
1076                    metrics,
1077                    KANIDM_RESOURCE_OAUTH2,
1078                    KANIDM_OP_UPDATE,
1079                    KANIDM_OUTCOME_CHANGED,
1080                    kanidm_client.idm_oauth2_rs_enable_strict_redirect_uri(name),
1081                )
1082                .await
1083                .map_err(|e| {
1084                    Error::kanidm_client_error_attr(
1085                        "update",
1086                        ATTR_OAUTH2_STRICT_REDIRECT_URI,
1087                        name,
1088                        self.kanidm_namespace(),
1089                        self.kanidm_name(),
1090                        e,
1091                    )
1092                })?;
1093            } else {
1094                record_kanidm_sdk_call(
1095                    metrics,
1096                    KANIDM_RESOURCE_OAUTH2,
1097                    KANIDM_OP_UPDATE,
1098                    KANIDM_OUTCOME_CHANGED,
1099                    kanidm_client.idm_oauth2_rs_disable_strict_redirect_uri(name),
1100                )
1101                .await
1102                .map_err(|e| {
1103                    Error::kanidm_client_error_attr(
1104                        "update",
1105                        ATTR_OAUTH2_STRICT_REDIRECT_URI,
1106                        name,
1107                        self.kanidm_namespace(),
1108                        self.kanidm_name(),
1109                        e,
1110                    )
1111                })?;
1112            }
1113        };
1114        Ok(())
1115    }
1116
1117    async fn update_disable_pkce(
1118        &self,
1119        kanidm_client: &KanidmClient,
1120        name: &str,
1121        metrics: &kaniop_operator::metrics::ControllerMetrics,
1122    ) -> Result<()> {
1123        debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute"));
1124        if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
1125            if disable_pkce {
1126                record_kanidm_sdk_call(
1127                    metrics,
1128                    KANIDM_RESOURCE_OAUTH2,
1129                    KANIDM_OP_UPDATE,
1130                    KANIDM_OUTCOME_CHANGED,
1131                    kanidm_client.idm_oauth2_rs_disable_pkce(name),
1132                )
1133                .await
1134                .map_err(|e| {
1135                    Error::kanidm_client_error_attr(
1136                        "update",
1137                        ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1138                        name,
1139                        self.kanidm_namespace(),
1140                        self.kanidm_name(),
1141                        e,
1142                    )
1143                })?;
1144            } else {
1145                record_kanidm_sdk_call(
1146                    metrics,
1147                    KANIDM_RESOURCE_OAUTH2,
1148                    KANIDM_OP_UPDATE,
1149                    KANIDM_OUTCOME_CHANGED,
1150                    kanidm_client.idm_oauth2_rs_enable_pkce(name),
1151                )
1152                .await
1153                .map_err(|e| {
1154                    Error::kanidm_client_error_attr(
1155                        "update",
1156                        ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1157                        name,
1158                        self.kanidm_namespace(),
1159                        self.kanidm_name(),
1160                        e,
1161                    )
1162                })?;
1163            }
1164        };
1165        Ok(())
1166    }
1167
1168    async fn update_prefer_short_name(
1169        &self,
1170        kanidm_client: &KanidmClient,
1171        name: &str,
1172        metrics: &kaniop_operator::metrics::ControllerMetrics,
1173    ) -> Result<()> {
1174        debug!(msg = format!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute"));
1175        if let Some(prefer_short_username) = self.spec.prefer_short_username {
1176            if prefer_short_username {
1177                record_kanidm_sdk_call(
1178                    metrics,
1179                    KANIDM_RESOURCE_OAUTH2,
1180                    KANIDM_OP_UPDATE,
1181                    KANIDM_OUTCOME_CHANGED,
1182                    kanidm_client.idm_oauth2_rs_prefer_short_username(name),
1183                )
1184                .await
1185                .map_err(|e| {
1186                    Error::kanidm_client_error_attr(
1187                        "update",
1188                        ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1189                        name,
1190                        self.kanidm_namespace(),
1191                        self.kanidm_name(),
1192                        e,
1193                    )
1194                })?;
1195            } else {
1196                record_kanidm_sdk_call(
1197                    metrics,
1198                    KANIDM_RESOURCE_OAUTH2,
1199                    KANIDM_OP_UPDATE,
1200                    KANIDM_OUTCOME_CHANGED,
1201                    kanidm_client.idm_oauth2_rs_prefer_spn_username(name),
1202                )
1203                .await
1204                .map_err(|e| {
1205                    Error::kanidm_client_error_attr(
1206                        "update",
1207                        ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1208                        name,
1209                        self.kanidm_namespace(),
1210                        self.kanidm_name(),
1211                        e,
1212                    )
1213                })?;
1214            }
1215        };
1216        Ok(())
1217    }
1218
1219    async fn update_allow_localhost_redirect(
1220        &self,
1221        kanidm_client: &KanidmClient,
1222        name: &str,
1223        metrics: &kaniop_operator::metrics::ControllerMetrics,
1224    ) -> Result<()> {
1225        debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute"));
1226        if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
1227            if allow_localhost_redirect {
1228                record_kanidm_sdk_call(
1229                    metrics,
1230                    KANIDM_RESOURCE_OAUTH2,
1231                    KANIDM_OP_UPDATE,
1232                    KANIDM_OUTCOME_CHANGED,
1233                    kanidm_client.idm_oauth2_rs_enable_public_localhost_redirect(name),
1234                )
1235                .await
1236                .map_err(|e| {
1237                    Error::kanidm_client_error_attr(
1238                        "update",
1239                        ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1240                        name,
1241                        self.kanidm_namespace(),
1242                        self.kanidm_name(),
1243                        e,
1244                    )
1245                })?;
1246            } else {
1247                record_kanidm_sdk_call(
1248                    metrics,
1249                    KANIDM_RESOURCE_OAUTH2,
1250                    KANIDM_OP_UPDATE,
1251                    KANIDM_OUTCOME_CHANGED,
1252                    kanidm_client.idm_oauth2_rs_disable_public_localhost_redirect(name),
1253                )
1254                .await
1255                .map_err(|e| {
1256                    Error::kanidm_client_error_attr(
1257                        "update",
1258                        ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1259                        name,
1260                        self.kanidm_namespace(),
1261                        self.kanidm_name(),
1262                        e,
1263                    )
1264                })?;
1265            }
1266        };
1267        Ok(())
1268    }
1269
1270    async fn update_legacy_crypto(
1271        &self,
1272        kanidm_client: &KanidmClient,
1273        name: &str,
1274        metrics: &kaniop_operator::metrics::ControllerMetrics,
1275    ) -> Result<()> {
1276        debug!(msg = format!("update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} attribute"));
1277        if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
1278            if legacy_crypto {
1279                record_kanidm_sdk_call(
1280                    metrics,
1281                    KANIDM_RESOURCE_OAUTH2,
1282                    KANIDM_OP_UPDATE,
1283                    KANIDM_OUTCOME_CHANGED,
1284                    kanidm_client.idm_oauth2_rs_enable_legacy_crypto(name),
1285                )
1286                .await
1287                .map_err(|e| {
1288                    Error::kanidm_client_error_attr(
1289                        "update",
1290                        ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1291                        name,
1292                        self.kanidm_namespace(),
1293                        self.kanidm_name(),
1294                        e,
1295                    )
1296                })?;
1297            } else {
1298                record_kanidm_sdk_call(
1299                    metrics,
1300                    KANIDM_RESOURCE_OAUTH2,
1301                    KANIDM_OP_UPDATE,
1302                    KANIDM_OUTCOME_CHANGED,
1303                    kanidm_client.idm_oauth2_rs_disable_legacy_crypto(name),
1304                )
1305                .await
1306                .map_err(|e| {
1307                    Error::kanidm_client_error_attr(
1308                        "update",
1309                        ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1310                        name,
1311                        self.kanidm_namespace(),
1312                        self.kanidm_name(),
1313                        e,
1314                    )
1315                })?;
1316            }
1317        };
1318        Ok(())
1319    }
1320
1321    async fn update_consent_prompt(
1322        &self,
1323        kanidm_client: &KanidmClient,
1324        name: &str,
1325        metrics: &kaniop_operator::metrics::ControllerMetrics,
1326    ) -> Result<()> {
1327        debug!(msg = format!("update {ATTR_OAUTH2_CONSENT_PROMPT_ENABLE} attribute"));
1328        if let Some(disable_consent_prompt) = self.spec.disable_consent_prompt {
1329            if disable_consent_prompt {
1330                record_kanidm_sdk_call(
1331                    metrics,
1332                    KANIDM_RESOURCE_OAUTH2,
1333                    KANIDM_OP_UPDATE,
1334                    KANIDM_OUTCOME_CHANGED,
1335                    kanidm_client.idm_oauth2_rs_disable_consent_prompt(name),
1336                )
1337                .await
1338                .map_err(|e| {
1339                    Error::kanidm_client_error_attr(
1340                        "update",
1341                        ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1342                        name,
1343                        self.kanidm_namespace(),
1344                        self.kanidm_name(),
1345                        e,
1346                    )
1347                })?;
1348            } else {
1349                record_kanidm_sdk_call(
1350                    metrics,
1351                    KANIDM_RESOURCE_OAUTH2,
1352                    KANIDM_OP_UPDATE,
1353                    KANIDM_OUTCOME_CHANGED,
1354                    kanidm_client.idm_oauth2_rs_enable_consent_prompt(name),
1355                )
1356                .await
1357                .map_err(|e| {
1358                    Error::kanidm_client_error_attr(
1359                        "update",
1360                        ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1361                        name,
1362                        self.kanidm_namespace(),
1363                        self.kanidm_name(),
1364                        e,
1365                    )
1366                })?;
1367            }
1368        };
1369        Ok(())
1370    }
1371
1372    async fn update_image(
1373        &self,
1374        kanidm_client: &KanidmClient,
1375        name: &str,
1376        status: &KanidmOAuth2ClientStatus,
1377        ctx: Arc<Context>,
1378        metrics: &kaniop_operator::metrics::ControllerMetrics,
1379    ) -> Result<bool> {
1380        match &self.spec.image {
1381            None => {
1382                debug!(msg = "deleting image from OAuth2 client");
1383                record_kanidm_sdk_call(
1384                    metrics,
1385                    KANIDM_RESOURCE_OAUTH2,
1386                    KANIDM_OP_DELETE_IMAGE,
1387                    KANIDM_OUTCOME_CHANGED,
1388                    kanidm_client.idm_oauth2_rs_delete_image(name),
1389                )
1390                .await
1391                .map_err(|e| {
1392                    Error::kanidm_client_error_attr(
1393                        "delete",
1394                        "image",
1395                        name,
1396                        self.kanidm_namespace(),
1397                        self.kanidm_name(),
1398                        e,
1399                    )
1400                })?;
1401                Ok(true)
1402            }
1403            Some(image_spec) => {
1404                let url = &image_spec.url;
1405                debug!(msg = format!("updating image for OAuth2 client from {url}"));
1406
1407                let namespace = self.kanidm_namespace();
1408                let kanidm = self.kanidm_name();
1409                let namespace_for_closure = namespace.clone();
1410                let kanidm_for_closure = kanidm.clone();
1411                let metrics_clone = metrics.clone();
1412
1413                let update_result =
1414                    update_image_if_needed(url, status.image.as_ref(), |image_value| {
1415                        let metrics = metrics_clone.clone();
1416                        let namespace = namespace_for_closure.clone();
1417                        let kanidm = kanidm_for_closure.clone();
1418                        async move {
1419                            record_kanidm_sdk_call(
1420                                &metrics,
1421                                KANIDM_RESOURCE_OAUTH2,
1422                                KANIDM_OP_UPDATE_IMAGE,
1423                                KANIDM_OUTCOME_CHANGED,
1424                                kanidm_client.idm_oauth2_rs_update_image(name, image_value),
1425                            )
1426                            .await
1427                            .map_err(|e| {
1428                                Error::kanidm_client_error_attr(
1429                                    "update", "image", name, namespace, kanidm, e,
1430                                )
1431                            })
1432                        }
1433                    })
1434                    .await;
1435
1436                match update_result {
1437                    Ok(Some(updated)) => {
1438                        let new_image_status = OAuth2ClientImageStatus {
1439                            url: updated.image_status.url,
1440                            etag: updated.image_status.etag,
1441                            last_modified: updated.image_status.last_modified,
1442                            content_length: updated.image_status.content_length,
1443                            content_hash: Some(updated.image_status.content_hash),
1444                        };
1445
1446                        let namespace = self.namespace().unwrap();
1447                        let name = self.name_any();
1448                        let oauth2_api = Api::<KanidmOAuth2Client>::namespaced(
1449                            ctx.kaniop_ctx.client.clone(),
1450                            &namespace,
1451                        );
1452                        let status_patch = Patch::Apply(KanidmOAuth2Client {
1453                            status: Some(KanidmOAuth2ClientStatus {
1454                                image: Some(new_image_status),
1455                                ..status.clone()
1456                            }),
1457                            ..KanidmOAuth2Client::default()
1458                        });
1459                        oauth2_api
1460                            .patch_status(
1461                                &name,
1462                                &PatchParams::apply(OAUTH2_OPERATOR_NAME),
1463                                &status_patch,
1464                            )
1465                            .await
1466                            .map_err(|e| {
1467                                Error::kube_status_error("KanidmOAuth2Client", &namespace, &name, e)
1468                            })?;
1469                        Ok(true)
1470                    }
1471                    Ok(None) => Ok(false),
1472                    Err(e) => {
1473                        let operation = if matches!(e, Error::HttpError(_, _)) {
1474                            ImageOperation::Fetch
1475                        } else {
1476                            ImageOperation::Download
1477                        };
1478                        Err(publish_image_error_event(
1479                            e,
1480                            operation,
1481                            name,
1482                            &namespace,
1483                            &kanidm,
1484                            &ctx.kaniop_ctx.recorder,
1485                            self,
1486                        )
1487                        .await)
1488                    }
1489                }
1490            }
1491        }
1492    }
1493
1494    async fn cleanup(
1495        &self,
1496        kanidm_client: Arc<KanidmClient>,
1497        status: KanidmOAuth2ClientStatus,
1498        ctx: Arc<Context>,
1499    ) -> Result<(Action, bool)> {
1500        let name = &self.kanidm_entity_name();
1501        let mut changed = false;
1502        if is_oauth2(TYPE_EXISTS, status.clone()) {
1503            debug!(msg = "delete");
1504            record_kanidm_sdk_call(
1505                &ctx.kaniop_ctx.metrics,
1506                KANIDM_RESOURCE_OAUTH2,
1507                KANIDM_OP_DELETE,
1508                KANIDM_OUTCOME_CHANGED,
1509                kanidm_client.idm_oauth2_rs_delete(name),
1510            )
1511            .await
1512            .map_err(|e| {
1513                Error::kanidm_client_error(
1514                    "delete",
1515                    name,
1516                    self.kanidm_namespace(),
1517                    self.kanidm_name(),
1518                    e,
1519                )
1520            })?;
1521            changed = true;
1522        }
1523        Ok((Action::requeue(idm_reconcile_interval()), changed))
1524    }
1525}
1526
1527pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1528    status
1529        .conditions
1530        .unwrap_or_default()
1531        .iter()
1532        .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
1533}
1534
1535pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1536    status
1537        .conditions
1538        .unwrap_or_default()
1539        .iter()
1540        .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
1541}