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!("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!("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!("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!(%e, "failed to publish KanidmError event");
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!("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!(%e, "failed to reconcile status");
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!("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!(%e, "failed to publish KanidmError event");
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!("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!("skipping forced secret rotation annotation for public OAuth2 client");
408            } else {
409                info!("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!("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!(discarded_labels = ?filtered.discarded_labels, discarded_annotations = ?filtered.discarded_annotations, "secretTemplate contains keys already owned by the operator; they will be ignored");
442                            ctx.kaniop_ctx
443                                .recorder
444                                .publish(
445                                    &Event {
446                                        type_: EventType::Warning,
447                                        reason: "SecretTemplateConflict".to_string(),
448                                        note: Some(format!(
449                                            "secretTemplate contains keys already owned by the \
450                                             operator and will be ignored. Labels: [{}]. \
451                                             Annotations: [{}].",
452                                            filtered
453                                                .discarded_labels
454                                                .iter()
455                                                .cloned()
456                                                .collect::<Vec<_>>()
457                                                .join(", "),
458                                            filtered
459                                                .discarded_annotations
460                                                .iter()
461                                                .cloned()
462                                                .collect::<Vec<_>>()
463                                                .join(", "),
464                                        )),
465                                        action: "ApplySecretTemplate".to_string(),
466                                        secondary: None,
467                                    },
468                                    &self.object_ref(&()),
469                                )
470                                .await
471                                .map_err(|e| {
472                                    warn!(%e, "failed to publish SecretTemplateConflict event");
473                                    Error::kube_error(
474                                        "publish",
475                                        "event",
476                                        self.get_namespace(),
477                                        self.name_any(),
478                                        e,
479                                    )
480                                })?;
481                        }
482                        self.apply_meta_template(
483                            ctx.kaniop_ctx.client.clone(),
484                            &ctx.kaniop_ctx.metrics,
485                            filtered,
486                        )
487                        .await?;
488                        require_status_update = true;
489                        changed = true;
490                    }
491                }
492            }
493        }
494
495        if is_oauth2_false(TYPE_UPDATED, status.clone()) {
496            self.update(&kanidm_client, name, metrics).await?;
497            require_status_update = true;
498            changed = true;
499        }
500
501        if is_oauth2_false(TYPE_REDIRECT_URL_UPDATED, status.clone()) {
502            self.update_redirect_url(&kanidm_client, name, &status, metrics)
503                .await?;
504            require_status_update = true;
505            changed = true;
506        }
507
508        if is_oauth2_false(TYPE_SCOPE_MAP_UPDATED, status.clone()) {
509            self.update_scope_map(&kanidm_client, name, &status, metrics)
510                .await?;
511            require_status_update = true;
512            changed = true;
513        }
514
515        if is_oauth2_false(TYPE_SUP_SCOPE_MAP_UPDATED, status.clone()) {
516            self.update_sup_scope_map(&kanidm_client, name, &status, metrics)
517                .await?;
518            require_status_update = true;
519            changed = true;
520        }
521
522        if is_oauth2_false(TYPE_CLAIMS_MAP_UPDATED, status.clone()) {
523            self.update_claims_map(&kanidm_client, name, &status, metrics)
524                .await?;
525            require_status_update = true;
526            changed = true;
527        }
528
529        if is_oauth2_false(TYPE_STRICT_REDIRECT_URL_UPDATED, status.clone()) {
530            self.update_strict_redirect_url(&kanidm_client, name, metrics)
531                .await?;
532            require_status_update = true;
533            changed = true;
534        }
535
536        if is_oauth2_false(TYPE_DISABLE_PKCE_UPDATED, status.clone()) {
537            self.update_disable_pkce(&kanidm_client, name, metrics)
538                .await?;
539            require_status_update = true;
540            changed = true;
541        }
542
543        if is_oauth2_false(TYPE_PREFER_SHORT_NAME_UPDATED, status.clone()) {
544            self.update_prefer_short_name(&kanidm_client, name, metrics)
545                .await?;
546            require_status_update = true;
547            changed = true;
548        }
549
550        if is_oauth2_false(TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED, status.clone()) {
551            self.update_allow_localhost_redirect(&kanidm_client, name, metrics)
552                .await?;
553            require_status_update = true;
554            changed = true;
555        }
556
557        if is_oauth2_false(TYPE_LEGACY_CRYPTO_UPDATED, status.clone()) {
558            self.update_legacy_crypto(&kanidm_client, name, metrics)
559                .await?;
560            require_status_update = true;
561            changed = true;
562        }
563
564        if is_oauth2_false(TYPE_DISABLE_CONSENT_PROMPT_UPDATED, status.clone()) {
565            self.update_consent_prompt(&kanidm_client, name, metrics)
566                .await?;
567            require_status_update = true;
568            changed = true;
569        }
570
571        if is_oauth2_false(TYPE_IMAGE_UPDATED, status.clone()) {
572            let image_changed = self
573                .update_image(&kanidm_client, name, &status, ctx.clone(), metrics)
574                .await?;
575            require_status_update = true;
576            changed = changed || image_changed;
577        }
578
579        if require_status_update {
580            trace!("status update required, requeueing in 500ms");
581            Ok((Action::requeue(Duration::from_millis(500)), changed))
582        } else {
583            Ok((Action::requeue(idm_reconcile_interval()), changed))
584        }
585    }
586
587    async fn create(
588        &self,
589        kanidm_client: &KanidmClient,
590        name: &str,
591        metrics: &kaniop_operator::metrics::ControllerMetrics,
592    ) -> Result<()> {
593        debug!("create");
594        if self.spec.public {
595            debug!("create public client");
596            record_kanidm_sdk_call(
597                metrics,
598                KANIDM_RESOURCE_OAUTH2,
599                KANIDM_OP_CREATE,
600                KANIDM_OUTCOME_CHANGED,
601                kanidm_client.idm_oauth2_rs_public_create(
602                    name,
603                    &self.spec.displayname,
604                    &self.spec.origin,
605                ),
606            )
607            .await
608            .map_err(|e| {
609                Error::kanidm_client_error(
610                    "create",
611                    name,
612                    self.kanidm_namespace(),
613                    self.kanidm_name(),
614                    e,
615                )
616            })?;
617        } else {
618            record_kanidm_sdk_call(
619                metrics,
620                KANIDM_RESOURCE_OAUTH2,
621                KANIDM_OP_CREATE,
622                KANIDM_OUTCOME_CHANGED,
623                kanidm_client.idm_oauth2_rs_basic_create(
624                    name,
625                    &self.spec.displayname,
626                    &self.spec.origin,
627                ),
628            )
629            .await
630            .map_err(|e| {
631                Error::kanidm_client_error(
632                    "create",
633                    name,
634                    self.kanidm_namespace(),
635                    self.kanidm_name(),
636                    e,
637                )
638            })?;
639        }
640        Ok(())
641    }
642
643    async fn update(
644        &self,
645        kanidm_client: &KanidmClient,
646        name: &str,
647        metrics: &kaniop_operator::metrics::ControllerMetrics,
648    ) -> Result<()> {
649        debug!("update");
650        record_kanidm_sdk_call(
651            metrics,
652            KANIDM_RESOURCE_OAUTH2,
653            KANIDM_OP_UPDATE,
654            KANIDM_OUTCOME_CHANGED,
655            kanidm_client.idm_oauth2_rs_update(
656                name,
657                None,
658                Some(&self.spec.displayname),
659                Some(&self.spec.origin),
660                false,
661            ),
662        )
663        .await
664        .map_err(|e| {
665            Error::kanidm_client_error(
666                "update",
667                name,
668                self.kanidm_namespace(),
669                self.kanidm_name(),
670                e,
671            )
672        })?;
673        Ok(())
674    }
675
676    async fn rotate_secret(
677        &self,
678        kanidm_client: &KanidmClient,
679        name: &str,
680        ctx: Arc<Context>,
681        metrics: &kaniop_operator::metrics::ControllerMetrics,
682    ) -> Result<()> {
683        info!("rotating OAuth2 client secret");
684        // Reset the secret in Kanidm using idm_oauth2_rs_update with reset_secret=true
685        record_kanidm_sdk_call(
686            metrics,
687            KANIDM_RESOURCE_OAUTH2,
688            KANIDM_OP_RESET_SECRET,
689            KANIDM_OUTCOME_CHANGED,
690            kanidm_client.idm_oauth2_rs_update(name, None, None, None, true),
691        )
692        .await
693        .map_err(|e| {
694            Error::kanidm_client_error_attr(
695                "rotate",
696                "secret",
697                name,
698                self.kanidm_namespace(),
699                self.kanidm_name(),
700                e,
701            )
702        })?;
703
704        // Regenerate and patch the Kubernetes secret with the new client secret
705        let secret = record_kanidm_sdk_call(
706            metrics,
707            KANIDM_RESOURCE_OAUTH2,
708            KANIDM_OP_GET_SECRET,
709            KANIDM_OUTCOME_CHANGED,
710            self.generate_secret(
711                kanidm_client,
712                self.spec.secret_rotation.as_ref(),
713                self.spec.secret_key_aliases.as_ref(),
714            ),
715        )
716        .await?;
717        self.apply_secret(&ctx, secret).await?;
718        Ok(())
719    }
720
721    async fn update_redirect_url(
722        &self,
723        kanidm_client: &KanidmClient,
724        name: &str,
725        status: &KanidmOAuth2ClientStatus,
726        metrics: &kaniop_operator::metrics::ControllerMetrics,
727    ) -> Result<()> {
728        debug!("update {ATTR_OAUTH2_RS_ORIGIN} attribute");
729
730        let current_urls: BTreeSet<_> = status
731            .origin
732            .as_ref()
733            .map(|o| o.iter().filter_map(|u| url::Url::parse(u).ok()).collect())
734            .unwrap_or_default();
735
736        let redirect_url = self
737            .spec
738            .redirect_url
739            .iter()
740            .map(|u| {
741                url::Url::parse(u).map_err(|e| {
742                    Error::UrlParseError(
743                        format!(
744                            "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
745                            namespace = self.kanidm_namespace(),
746                            kanidm = self.kanidm_name(),
747                        ),
748                        e,
749                    )
750                })
751            })
752            .collect::<Result<BTreeSet<_>>>()?;
753
754        let metrics_remove = metrics.clone();
755        let delete_futures = current_urls
756            .difference(&redirect_url)
757            .map(|url| {
758                let metrics = metrics_remove.clone();
759                async move {
760                    record_kanidm_sdk_call(
761                        &metrics,
762                        KANIDM_RESOURCE_OAUTH2,
763                        KANIDM_OP_REMOVE_ORIGIN,
764                        KANIDM_OUTCOME_CHANGED,
765                        kanidm_client.idm_oauth2_client_remove_origin(name, url),
766                    )
767                    .await
768                }
769            })
770            .collect::<TryJoinAll<_>>();
771
772        let metrics_add = metrics.clone();
773        let add_futures = redirect_url
774            .difference(&current_urls)
775            .map(|url| {
776                let metrics = metrics_add.clone();
777                async move {
778                    record_kanidm_sdk_call(
779                        &metrics,
780                        KANIDM_RESOURCE_OAUTH2,
781                        KANIDM_OP_ADD_ORIGIN,
782                        KANIDM_OUTCOME_CHANGED,
783                        kanidm_client.idm_oauth2_client_add_origin(name, url),
784                    )
785                    .await
786                }
787            })
788            .collect::<TryJoinAll<_>>();
789
790        futures::try_join!(delete_futures, add_futures).map_err(|e| {
791            Error::kanidm_client_error_attr(
792                "modify",
793                ATTR_OAUTH2_RS_ORIGIN,
794                name,
795                self.kanidm_namespace(),
796                self.kanidm_name(),
797                e,
798            )
799        })?;
800
801        Ok(())
802    }
803
804    async fn update_scope_map(
805        &self,
806        kanidm_client: &KanidmClient,
807        name: &str,
808        status: &KanidmOAuth2ClientStatus,
809        metrics: &kaniop_operator::metrics::ControllerMetrics,
810    ) -> Result<()> {
811        debug!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute");
812
813        let current_scope_map: BTreeSet<_> = status
814            .scope_map
815            .as_ref()
816            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
817            .unwrap_or_default();
818
819        let scope_map: BTreeSet<KanidmScopeMap> = self
820            .spec
821            .scope_map
822            .clone()
823            .unwrap_or_default()
824            .clone()
825            .into_iter()
826            .collect();
827
828        let metrics_del = metrics.clone();
829        let delete_futures = current_scope_map
830            .difference(&scope_map)
831            .map(|s| {
832                let metrics = metrics_del.clone();
833                async move {
834                    record_kanidm_sdk_call(
835                        &metrics,
836                        KANIDM_RESOURCE_OAUTH2,
837                        KANIDM_OP_DELETE_SCOPE_MAP,
838                        KANIDM_OUTCOME_CHANGED,
839                        kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group),
840                    )
841                    .await
842                }
843            })
844            .collect::<TryJoinAll<_>>();
845
846        let metrics_add = metrics.clone();
847        let add_futures = scope_map
848            .difference(&current_scope_map)
849            .map(|s| {
850                let metrics = metrics_add.clone();
851                let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
852                async move {
853                    record_kanidm_sdk_call(
854                        &metrics,
855                        KANIDM_RESOURCE_OAUTH2,
856                        KANIDM_OP_UPDATE_SCOPE_MAP,
857                        KANIDM_OUTCOME_CHANGED,
858                        kanidm_client.idm_oauth2_rs_update_scope_map(name, &s.group, scopes),
859                    )
860                    .await
861                }
862            })
863            .collect::<TryJoinAll<_>>();
864
865        try_join!(delete_futures, add_futures).map_err(|e| {
866            Error::kanidm_client_error_attr(
867                "modify",
868                ATTR_OAUTH2_RS_SCOPE_MAP,
869                name,
870                self.kanidm_namespace(),
871                self.kanidm_name(),
872                e,
873            )
874        })?;
875        Ok(())
876    }
877
878    async fn update_sup_scope_map(
879        &self,
880        kanidm_client: &KanidmClient,
881        name: &str,
882        status: &KanidmOAuth2ClientStatus,
883        metrics: &kaniop_operator::metrics::ControllerMetrics,
884    ) -> Result<()> {
885        debug!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute");
886
887        let current_sup_scope_map: BTreeSet<_> = status
888            .sup_scope_map
889            .as_ref()
890            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
891            .unwrap_or_default();
892
893        let sup_scope_map: BTreeSet<KanidmScopeMap> = self
894            .spec
895            .sup_scope_map
896            .clone()
897            .unwrap_or_default()
898            .clone()
899            .into_iter()
900            .collect();
901
902        let metrics_del = metrics.clone();
903        let delete_futures = current_sup_scope_map
904            .difference(&sup_scope_map)
905            .map(|s| {
906                let metrics = metrics_del.clone();
907                async move {
908                    record_kanidm_sdk_call(
909                        &metrics,
910                        KANIDM_RESOURCE_OAUTH2,
911                        KANIDM_OP_DELETE_SUP_SCOPE_MAP,
912                        KANIDM_OUTCOME_CHANGED,
913                        kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group),
914                    )
915                    .await
916                }
917            })
918            .collect::<TryJoinAll<_>>();
919
920        let metrics_add = metrics.clone();
921        let add_futures = sup_scope_map
922            .difference(&current_sup_scope_map)
923            .map(|s| {
924                let metrics = metrics_add.clone();
925                let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
926                async move {
927                    record_kanidm_sdk_call(
928                        &metrics,
929                        KANIDM_RESOURCE_OAUTH2,
930                        KANIDM_OP_UPDATE_SUP_SCOPE_MAP,
931                        KANIDM_OUTCOME_CHANGED,
932                        kanidm_client.idm_oauth2_rs_update_sup_scope_map(name, &s.group, scopes),
933                    )
934                    .await
935                }
936            })
937            .collect::<TryJoinAll<_>>();
938
939        try_join!(delete_futures, add_futures).map_err(|e| {
940            Error::kanidm_client_error_attr(
941                "modify",
942                ATTR_OAUTH2_RS_SUP_SCOPE_MAP,
943                name,
944                self.kanidm_namespace(),
945                self.kanidm_name(),
946                e,
947            )
948        })?;
949        Ok(())
950    }
951
952    async fn update_claims_map(
953        &self,
954        kanidm_client: &KanidmClient,
955        name: &str,
956        status: &KanidmOAuth2ClientStatus,
957        metrics: &kaniop_operator::metrics::ControllerMetrics,
958    ) -> Result<()> {
959        debug!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute");
960
961        let current_claims_map: BTreeSet<_> = status
962            .claims_map
963            .as_ref()
964            .map(|v| {
965                KanidmClaimMap::group(
966                    &v.iter()
967                        .filter_map(|c| KanidmClaimMap::from(c))
968                        .collect::<Vec<_>>(),
969                )
970            })
971            .unwrap_or_default();
972
973        let claims_map: BTreeSet<KanidmClaimMap> = self
974            .spec
975            .claim_map
976            .clone()
977            .unwrap_or_default()
978            .clone()
979            .into_iter()
980            .collect();
981
982        let metrics_del = metrics.clone();
983        let delete_futures = current_claims_map
984            .difference(&claims_map)
985            .flat_map(|c| {
986                c.values_map
987                    .iter()
988                    .map(|v| {
989                        let metrics = metrics_del.clone();
990                        async move {
991                            record_kanidm_sdk_call(
992                                &metrics,
993                                KANIDM_RESOURCE_OAUTH2,
994                                KANIDM_OP_DELETE_CLAIM_MAP,
995                                KANIDM_OUTCOME_CHANGED,
996                                kanidm_client
997                                    .idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group),
998                            )
999                            .await
1000                        }
1001                    })
1002                    .collect::<Vec<_>>()
1003            })
1004            .collect::<TryJoinAll<_>>();
1005
1006        let claims_to_add = claims_map.difference(&current_claims_map);
1007        let metrics_add = metrics.clone();
1008        let add_futures = claims_to_add
1009            .clone()
1010            .flat_map(|c| {
1011                c.values_map
1012                    .iter()
1013                    .map(|v| {
1014                        let metrics = metrics_add.clone();
1015                        let values = v.values.clone();
1016                        async move {
1017                            record_kanidm_sdk_call(
1018                                &metrics,
1019                                KANIDM_RESOURCE_OAUTH2,
1020                                KANIDM_OP_UPDATE_CLAIM_MAP,
1021                                KANIDM_OUTCOME_CHANGED,
1022                                kanidm_client.idm_oauth2_rs_update_claim_map(
1023                                    name, &c.name, &v.group, &values,
1024                                ),
1025                            )
1026                            .await
1027                        }
1028                    })
1029                    .collect::<Vec<_>>()
1030            })
1031            .collect::<TryJoinAll<_>>();
1032
1033        let metrics_join = metrics.clone();
1034        let join_strategy_futures = claims_to_add
1035            .map(|c| {
1036                let metrics = metrics_join.clone();
1037                let join_strategy = c.join_strategy.to_oauth2_claim_map_join();
1038                async move {
1039                    record_kanidm_sdk_call(
1040                        &metrics,
1041                        KANIDM_RESOURCE_OAUTH2,
1042                        KANIDM_OP_UPDATE_CLAIM_MAP_JOIN,
1043                        KANIDM_OUTCOME_CHANGED,
1044                        kanidm_client.idm_oauth2_rs_update_claim_map_join(
1045                            name,
1046                            &c.name,
1047                            join_strategy,
1048                        ),
1049                    )
1050                    .await
1051                }
1052            })
1053            .collect::<TryJoinAll<_>>();
1054
1055        try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
1056            Error::kanidm_client_error_attr(
1057                "modify",
1058                ATTR_OAUTH2_RS_CLAIM_MAP,
1059                name,
1060                self.kanidm_namespace(),
1061                self.kanidm_name(),
1062                e,
1063            )
1064        })?;
1065        Ok(())
1066    }
1067
1068    async fn update_strict_redirect_url(
1069        &self,
1070        kanidm_client: &KanidmClient,
1071        name: &str,
1072        metrics: &kaniop_operator::metrics::ControllerMetrics,
1073    ) -> Result<()> {
1074        debug!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute");
1075        if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
1076            if strict_redirect_url_enabled {
1077                record_kanidm_sdk_call(
1078                    metrics,
1079                    KANIDM_RESOURCE_OAUTH2,
1080                    KANIDM_OP_UPDATE,
1081                    KANIDM_OUTCOME_CHANGED,
1082                    kanidm_client.idm_oauth2_rs_enable_strict_redirect_uri(name),
1083                )
1084                .await
1085                .map_err(|e| {
1086                    Error::kanidm_client_error_attr(
1087                        "update",
1088                        ATTR_OAUTH2_STRICT_REDIRECT_URI,
1089                        name,
1090                        self.kanidm_namespace(),
1091                        self.kanidm_name(),
1092                        e,
1093                    )
1094                })?;
1095            } else {
1096                record_kanidm_sdk_call(
1097                    metrics,
1098                    KANIDM_RESOURCE_OAUTH2,
1099                    KANIDM_OP_UPDATE,
1100                    KANIDM_OUTCOME_CHANGED,
1101                    kanidm_client.idm_oauth2_rs_disable_strict_redirect_uri(name),
1102                )
1103                .await
1104                .map_err(|e| {
1105                    Error::kanidm_client_error_attr(
1106                        "update",
1107                        ATTR_OAUTH2_STRICT_REDIRECT_URI,
1108                        name,
1109                        self.kanidm_namespace(),
1110                        self.kanidm_name(),
1111                        e,
1112                    )
1113                })?;
1114            }
1115        };
1116        Ok(())
1117    }
1118
1119    async fn update_disable_pkce(
1120        &self,
1121        kanidm_client: &KanidmClient,
1122        name: &str,
1123        metrics: &kaniop_operator::metrics::ControllerMetrics,
1124    ) -> Result<()> {
1125        debug!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute");
1126        if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
1127            if disable_pkce {
1128                record_kanidm_sdk_call(
1129                    metrics,
1130                    KANIDM_RESOURCE_OAUTH2,
1131                    KANIDM_OP_UPDATE,
1132                    KANIDM_OUTCOME_CHANGED,
1133                    kanidm_client.idm_oauth2_rs_disable_pkce(name),
1134                )
1135                .await
1136                .map_err(|e| {
1137                    Error::kanidm_client_error_attr(
1138                        "update",
1139                        ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1140                        name,
1141                        self.kanidm_namespace(),
1142                        self.kanidm_name(),
1143                        e,
1144                    )
1145                })?;
1146            } else {
1147                record_kanidm_sdk_call(
1148                    metrics,
1149                    KANIDM_RESOURCE_OAUTH2,
1150                    KANIDM_OP_UPDATE,
1151                    KANIDM_OUTCOME_CHANGED,
1152                    kanidm_client.idm_oauth2_rs_enable_pkce(name),
1153                )
1154                .await
1155                .map_err(|e| {
1156                    Error::kanidm_client_error_attr(
1157                        "update",
1158                        ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1159                        name,
1160                        self.kanidm_namespace(),
1161                        self.kanidm_name(),
1162                        e,
1163                    )
1164                })?;
1165            }
1166        };
1167        Ok(())
1168    }
1169
1170    async fn update_prefer_short_name(
1171        &self,
1172        kanidm_client: &KanidmClient,
1173        name: &str,
1174        metrics: &kaniop_operator::metrics::ControllerMetrics,
1175    ) -> Result<()> {
1176        debug!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute");
1177        if let Some(prefer_short_username) = self.spec.prefer_short_username {
1178            if prefer_short_username {
1179                record_kanidm_sdk_call(
1180                    metrics,
1181                    KANIDM_RESOURCE_OAUTH2,
1182                    KANIDM_OP_UPDATE,
1183                    KANIDM_OUTCOME_CHANGED,
1184                    kanidm_client.idm_oauth2_rs_prefer_short_username(name),
1185                )
1186                .await
1187                .map_err(|e| {
1188                    Error::kanidm_client_error_attr(
1189                        "update",
1190                        ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1191                        name,
1192                        self.kanidm_namespace(),
1193                        self.kanidm_name(),
1194                        e,
1195                    )
1196                })?;
1197            } else {
1198                record_kanidm_sdk_call(
1199                    metrics,
1200                    KANIDM_RESOURCE_OAUTH2,
1201                    KANIDM_OP_UPDATE,
1202                    KANIDM_OUTCOME_CHANGED,
1203                    kanidm_client.idm_oauth2_rs_prefer_spn_username(name),
1204                )
1205                .await
1206                .map_err(|e| {
1207                    Error::kanidm_client_error_attr(
1208                        "update",
1209                        ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1210                        name,
1211                        self.kanidm_namespace(),
1212                        self.kanidm_name(),
1213                        e,
1214                    )
1215                })?;
1216            }
1217        };
1218        Ok(())
1219    }
1220
1221    async fn update_allow_localhost_redirect(
1222        &self,
1223        kanidm_client: &KanidmClient,
1224        name: &str,
1225        metrics: &kaniop_operator::metrics::ControllerMetrics,
1226    ) -> Result<()> {
1227        debug!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute");
1228        if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
1229            if allow_localhost_redirect {
1230                record_kanidm_sdk_call(
1231                    metrics,
1232                    KANIDM_RESOURCE_OAUTH2,
1233                    KANIDM_OP_UPDATE,
1234                    KANIDM_OUTCOME_CHANGED,
1235                    kanidm_client.idm_oauth2_rs_enable_public_localhost_redirect(name),
1236                )
1237                .await
1238                .map_err(|e| {
1239                    Error::kanidm_client_error_attr(
1240                        "update",
1241                        ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1242                        name,
1243                        self.kanidm_namespace(),
1244                        self.kanidm_name(),
1245                        e,
1246                    )
1247                })?;
1248            } else {
1249                record_kanidm_sdk_call(
1250                    metrics,
1251                    KANIDM_RESOURCE_OAUTH2,
1252                    KANIDM_OP_UPDATE,
1253                    KANIDM_OUTCOME_CHANGED,
1254                    kanidm_client.idm_oauth2_rs_disable_public_localhost_redirect(name),
1255                )
1256                .await
1257                .map_err(|e| {
1258                    Error::kanidm_client_error_attr(
1259                        "update",
1260                        ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1261                        name,
1262                        self.kanidm_namespace(),
1263                        self.kanidm_name(),
1264                        e,
1265                    )
1266                })?;
1267            }
1268        };
1269        Ok(())
1270    }
1271
1272    async fn update_legacy_crypto(
1273        &self,
1274        kanidm_client: &KanidmClient,
1275        name: &str,
1276        metrics: &kaniop_operator::metrics::ControllerMetrics,
1277    ) -> Result<()> {
1278        debug!("update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} attribute");
1279        if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
1280            if legacy_crypto {
1281                record_kanidm_sdk_call(
1282                    metrics,
1283                    KANIDM_RESOURCE_OAUTH2,
1284                    KANIDM_OP_UPDATE,
1285                    KANIDM_OUTCOME_CHANGED,
1286                    kanidm_client.idm_oauth2_rs_enable_legacy_crypto(name),
1287                )
1288                .await
1289                .map_err(|e| {
1290                    Error::kanidm_client_error_attr(
1291                        "update",
1292                        ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1293                        name,
1294                        self.kanidm_namespace(),
1295                        self.kanidm_name(),
1296                        e,
1297                    )
1298                })?;
1299            } else {
1300                record_kanidm_sdk_call(
1301                    metrics,
1302                    KANIDM_RESOURCE_OAUTH2,
1303                    KANIDM_OP_UPDATE,
1304                    KANIDM_OUTCOME_CHANGED,
1305                    kanidm_client.idm_oauth2_rs_disable_legacy_crypto(name),
1306                )
1307                .await
1308                .map_err(|e| {
1309                    Error::kanidm_client_error_attr(
1310                        "update",
1311                        ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1312                        name,
1313                        self.kanidm_namespace(),
1314                        self.kanidm_name(),
1315                        e,
1316                    )
1317                })?;
1318            }
1319        };
1320        Ok(())
1321    }
1322
1323    async fn update_consent_prompt(
1324        &self,
1325        kanidm_client: &KanidmClient,
1326        name: &str,
1327        metrics: &kaniop_operator::metrics::ControllerMetrics,
1328    ) -> Result<()> {
1329        debug!("update {ATTR_OAUTH2_CONSENT_PROMPT_ENABLE} attribute");
1330        if let Some(disable_consent_prompt) = self.spec.disable_consent_prompt {
1331            if disable_consent_prompt {
1332                record_kanidm_sdk_call(
1333                    metrics,
1334                    KANIDM_RESOURCE_OAUTH2,
1335                    KANIDM_OP_UPDATE,
1336                    KANIDM_OUTCOME_CHANGED,
1337                    kanidm_client.idm_oauth2_rs_disable_consent_prompt(name),
1338                )
1339                .await
1340                .map_err(|e| {
1341                    Error::kanidm_client_error_attr(
1342                        "update",
1343                        ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1344                        name,
1345                        self.kanidm_namespace(),
1346                        self.kanidm_name(),
1347                        e,
1348                    )
1349                })?;
1350            } else {
1351                record_kanidm_sdk_call(
1352                    metrics,
1353                    KANIDM_RESOURCE_OAUTH2,
1354                    KANIDM_OP_UPDATE,
1355                    KANIDM_OUTCOME_CHANGED,
1356                    kanidm_client.idm_oauth2_rs_enable_consent_prompt(name),
1357                )
1358                .await
1359                .map_err(|e| {
1360                    Error::kanidm_client_error_attr(
1361                        "update",
1362                        ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1363                        name,
1364                        self.kanidm_namespace(),
1365                        self.kanidm_name(),
1366                        e,
1367                    )
1368                })?;
1369            }
1370        };
1371        Ok(())
1372    }
1373
1374    async fn update_image(
1375        &self,
1376        kanidm_client: &KanidmClient,
1377        name: &str,
1378        status: &KanidmOAuth2ClientStatus,
1379        ctx: Arc<Context>,
1380        metrics: &kaniop_operator::metrics::ControllerMetrics,
1381    ) -> Result<bool> {
1382        match &self.spec.image {
1383            None => {
1384                debug!("deleting image from OAuth2 client");
1385                record_kanidm_sdk_call(
1386                    metrics,
1387                    KANIDM_RESOURCE_OAUTH2,
1388                    KANIDM_OP_DELETE_IMAGE,
1389                    KANIDM_OUTCOME_CHANGED,
1390                    kanidm_client.idm_oauth2_rs_delete_image(name),
1391                )
1392                .await
1393                .map_err(|e| {
1394                    Error::kanidm_client_error_attr(
1395                        "delete",
1396                        "image",
1397                        name,
1398                        self.kanidm_namespace(),
1399                        self.kanidm_name(),
1400                        e,
1401                    )
1402                })?;
1403                Ok(true)
1404            }
1405            Some(image_spec) => {
1406                let url = &image_spec.url;
1407                debug!("updating image for OAuth2 client from {url}");
1408
1409                let namespace = self.kanidm_namespace();
1410                let kanidm = self.kanidm_name();
1411                let namespace_for_closure = namespace.clone();
1412                let kanidm_for_closure = kanidm.clone();
1413                let metrics_clone = metrics.clone();
1414
1415                let update_result =
1416                    update_image_if_needed(url, status.image.as_ref(), |image_value| {
1417                        let metrics = metrics_clone.clone();
1418                        let namespace = namespace_for_closure.clone();
1419                        let kanidm = kanidm_for_closure.clone();
1420                        async move {
1421                            record_kanidm_sdk_call(
1422                                &metrics,
1423                                KANIDM_RESOURCE_OAUTH2,
1424                                KANIDM_OP_UPDATE_IMAGE,
1425                                KANIDM_OUTCOME_CHANGED,
1426                                kanidm_client.idm_oauth2_rs_update_image(name, image_value),
1427                            )
1428                            .await
1429                            .map_err(|e| {
1430                                Error::kanidm_client_error_attr(
1431                                    "update", "image", name, namespace, kanidm, e,
1432                                )
1433                            })
1434                        }
1435                    })
1436                    .await;
1437
1438                match update_result {
1439                    Ok(Some(updated)) => {
1440                        let new_image_status = OAuth2ClientImageStatus {
1441                            url: updated.image_status.url,
1442                            etag: updated.image_status.etag,
1443                            last_modified: updated.image_status.last_modified,
1444                            content_length: updated.image_status.content_length,
1445                            content_hash: Some(updated.image_status.content_hash),
1446                        };
1447
1448                        let namespace = self.namespace().unwrap();
1449                        let name = self.name_any();
1450                        let oauth2_api = Api::<KanidmOAuth2Client>::namespaced(
1451                            ctx.kaniop_ctx.client.clone(),
1452                            &namespace,
1453                        );
1454                        let status_patch = Patch::Apply(KanidmOAuth2Client {
1455                            status: Some(KanidmOAuth2ClientStatus {
1456                                image: Some(new_image_status),
1457                                ..status.clone()
1458                            }),
1459                            ..KanidmOAuth2Client::default()
1460                        });
1461                        oauth2_api
1462                            .patch_status(
1463                                &name,
1464                                &PatchParams::apply(OAUTH2_OPERATOR_NAME),
1465                                &status_patch,
1466                            )
1467                            .await
1468                            .map_err(|e| {
1469                                Error::kube_status_error("KanidmOAuth2Client", &namespace, &name, e)
1470                            })?;
1471                        Ok(true)
1472                    }
1473                    Ok(None) => Ok(false),
1474                    Err(e) => {
1475                        let operation = if matches!(e, Error::HttpError(_, _)) {
1476                            ImageOperation::Fetch
1477                        } else {
1478                            ImageOperation::Download
1479                        };
1480                        Err(publish_image_error_event(
1481                            e,
1482                            operation,
1483                            name,
1484                            &namespace,
1485                            &kanidm,
1486                            &ctx.kaniop_ctx.recorder,
1487                            self,
1488                        )
1489                        .await)
1490                    }
1491                }
1492            }
1493        }
1494    }
1495
1496    async fn cleanup(
1497        &self,
1498        kanidm_client: Arc<KanidmClient>,
1499        status: KanidmOAuth2ClientStatus,
1500        ctx: Arc<Context>,
1501    ) -> Result<(Action, bool)> {
1502        let name = &self.kanidm_entity_name();
1503        let mut changed = false;
1504        if is_oauth2(TYPE_EXISTS, status.clone()) {
1505            debug!("delete");
1506            record_kanidm_sdk_call(
1507                &ctx.kaniop_ctx.metrics,
1508                KANIDM_RESOURCE_OAUTH2,
1509                KANIDM_OP_DELETE,
1510                KANIDM_OUTCOME_CHANGED,
1511                kanidm_client.idm_oauth2_rs_delete(name),
1512            )
1513            .await
1514            .map_err(|e| {
1515                Error::kanidm_client_error(
1516                    "delete",
1517                    name,
1518                    self.kanidm_namespace(),
1519                    self.kanidm_name(),
1520                    e,
1521                )
1522            })?;
1523            changed = true;
1524        }
1525        Ok((Action::requeue(idm_reconcile_interval()), changed))
1526    }
1527}
1528
1529pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1530    status
1531        .conditions
1532        .unwrap_or_default()
1533        .iter()
1534        .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
1535}
1536
1537pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1538    status
1539        .conditions
1540        .unwrap_or_default()
1541        .iter()
1542        .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
1543}