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