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