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_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        if is_oauth2_false(TYPE_IMAGE_UPDATED, status.clone()) {
589            let image_changed = self
590                .update_image(&kanidm_client, name, &status, ctx.clone(), metrics)
591                .await?;
592            require_status_update = true;
593            changed = changed || image_changed;
594        }
595
596        if require_status_update {
597            trace!("status update required, requeueing in 500ms");
598            Ok((Action::requeue(Duration::from_millis(500)), changed))
599        } else {
600            Ok((Action::requeue(idm_reconcile_interval()), changed))
601        }
602    }
603
604    async fn create(
605        &self,
606        kanidm_client: &KanidmClient,
607        name: &str,
608        metrics: &kaniop_operator::metrics::ControllerMetrics,
609    ) -> Result<()> {
610        debug!("create");
611        if self.spec.public {
612            debug!("create public client");
613            record_kanidm_sdk_call(
614                metrics,
615                KANIDM_RESOURCE_OAUTH2,
616                KANIDM_OP_CREATE,
617                KANIDM_OUTCOME_CHANGED,
618                kanidm_client.idm_oauth2_rs_public_create(
619                    name,
620                    &self.spec.displayname,
621                    &self.spec.origin,
622                ),
623            )
624            .await
625            .map_err(|e| {
626                Error::kanidm_client_error(
627                    "create",
628                    name,
629                    self.kanidm_namespace(),
630                    self.kanidm_name(),
631                    e,
632                )
633            })?;
634        } else {
635            record_kanidm_sdk_call(
636                metrics,
637                KANIDM_RESOURCE_OAUTH2,
638                KANIDM_OP_CREATE,
639                KANIDM_OUTCOME_CHANGED,
640                kanidm_client.idm_oauth2_rs_basic_create(
641                    name,
642                    &self.spec.displayname,
643                    &self.spec.origin,
644                ),
645            )
646            .await
647            .map_err(|e| {
648                Error::kanidm_client_error(
649                    "create",
650                    name,
651                    self.kanidm_namespace(),
652                    self.kanidm_name(),
653                    e,
654                )
655            })?;
656        }
657        Ok(())
658    }
659
660    async fn update(
661        &self,
662        kanidm_client: &KanidmClient,
663        name: &str,
664        metrics: &kaniop_operator::metrics::ControllerMetrics,
665    ) -> Result<()> {
666        debug!("update");
667        record_kanidm_sdk_call(
668            metrics,
669            KANIDM_RESOURCE_OAUTH2,
670            KANIDM_OP_UPDATE,
671            KANIDM_OUTCOME_CHANGED,
672            kanidm_client.idm_oauth2_rs_update(
673                name,
674                None,
675                Some(&self.spec.displayname),
676                Some(&self.spec.origin),
677                false,
678            ),
679        )
680        .await
681        .map_err(|e| {
682            Error::kanidm_client_error(
683                "update",
684                name,
685                self.kanidm_namespace(),
686                self.kanidm_name(),
687                e,
688            )
689        })?;
690        Ok(())
691    }
692
693    async fn update_description(
694        &self,
695        kanidm_client: &KanidmClient,
696        name: &str,
697        metrics: &kaniop_operator::metrics::ControllerMetrics,
698    ) -> Result<()> {
699        let description = self.spec.description.as_deref().ok_or_else(|| {
700            Error::MissingData("OAuth2 client description is not defined".to_string())
701        })?;
702        let entry = Entry {
703            attrs: BTreeMap::from([(
704                ATTR_DESCRIPTION.to_string(),
705                if description.is_empty() {
706                    Vec::new()
707                } else {
708                    vec![description.to_string()]
709                },
710            )]),
711        };
712        // The Kanidm PATCH API purges a field for an empty attribute value list.
713        let _: () = record_kanidm_sdk_call(
714            metrics,
715            KANIDM_RESOURCE_OAUTH2,
716            KANIDM_OP_UPDATE,
717            KANIDM_OUTCOME_CHANGED,
718            kanidm_client.perform_patch_request(&format!("/v1/oauth2/{name}"), entry),
719        )
720        .await
721        .map_err(|e| {
722            Error::kanidm_client_error_attr(
723                "update",
724                ATTR_DESCRIPTION,
725                name,
726                self.kanidm_namespace(),
727                self.kanidm_name(),
728                e,
729            )
730        })?;
731        Ok(())
732    }
733
734    async fn rotate_secret(
735        &self,
736        kanidm_client: &KanidmClient,
737        name: &str,
738        ctx: Arc<Context>,
739        metrics: &kaniop_operator::metrics::ControllerMetrics,
740    ) -> Result<()> {
741        info!("rotating OAuth2 client secret");
742        // Reset the secret in Kanidm using idm_oauth2_rs_update with reset_secret=true
743        record_kanidm_sdk_call(
744            metrics,
745            KANIDM_RESOURCE_OAUTH2,
746            KANIDM_OP_RESET_SECRET,
747            KANIDM_OUTCOME_CHANGED,
748            kanidm_client.idm_oauth2_rs_update(name, None, None, None, true),
749        )
750        .await
751        .map_err(|e| {
752            Error::kanidm_client_error_attr(
753                "rotate",
754                "secret",
755                name,
756                self.kanidm_namespace(),
757                self.kanidm_name(),
758                e,
759            )
760        })?;
761
762        // Regenerate and patch the Kubernetes secret with the new client secret
763        let secret = record_kanidm_sdk_call(
764            metrics,
765            KANIDM_RESOURCE_OAUTH2,
766            KANIDM_OP_GET_SECRET,
767            KANIDM_OUTCOME_CHANGED,
768            self.generate_secret(
769                kanidm_client,
770                self.spec.secret_rotation.as_ref(),
771                self.spec.secret_key_aliases.as_ref(),
772            ),
773        )
774        .await?;
775        self.apply_secret(&ctx, secret).await?;
776        Ok(())
777    }
778
779    async fn update_redirect_url(
780        &self,
781        kanidm_client: &KanidmClient,
782        name: &str,
783        status: &KanidmOAuth2ClientStatus,
784        metrics: &kaniop_operator::metrics::ControllerMetrics,
785    ) -> Result<()> {
786        debug!("update {ATTR_OAUTH2_RS_ORIGIN} attribute");
787
788        let current_urls: BTreeSet<_> = status
789            .origin
790            .as_ref()
791            .map(|o| o.iter().filter_map(|u| url::Url::parse(u).ok()).collect())
792            .unwrap_or_default();
793
794        let redirect_url = self
795            .spec
796            .redirect_url
797            .iter()
798            .map(|u| {
799                url::Url::parse(u).map_err(|e| {
800                    Error::UrlParseError(
801                        format!(
802                            "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
803                            namespace = self.kanidm_namespace(),
804                            kanidm = self.kanidm_name(),
805                        ),
806                        e,
807                    )
808                })
809            })
810            .collect::<Result<BTreeSet<_>>>()?;
811
812        let metrics_remove = metrics.clone();
813        let delete_futures = current_urls
814            .difference(&redirect_url)
815            .map(|url| {
816                let metrics = metrics_remove.clone();
817                async move {
818                    record_kanidm_sdk_call(
819                        &metrics,
820                        KANIDM_RESOURCE_OAUTH2,
821                        KANIDM_OP_REMOVE_ORIGIN,
822                        KANIDM_OUTCOME_CHANGED,
823                        kanidm_client.idm_oauth2_client_remove_origin(name, url),
824                    )
825                    .await
826                }
827            })
828            .collect::<TryJoinAll<_>>();
829
830        let metrics_add = metrics.clone();
831        let add_futures = redirect_url
832            .difference(&current_urls)
833            .map(|url| {
834                let metrics = metrics_add.clone();
835                async move {
836                    record_kanidm_sdk_call(
837                        &metrics,
838                        KANIDM_RESOURCE_OAUTH2,
839                        KANIDM_OP_ADD_ORIGIN,
840                        KANIDM_OUTCOME_CHANGED,
841                        kanidm_client.idm_oauth2_client_add_origin(name, url),
842                    )
843                    .await
844                }
845            })
846            .collect::<TryJoinAll<_>>();
847
848        futures::try_join!(delete_futures, add_futures).map_err(|e| {
849            Error::kanidm_client_error_attr(
850                "modify",
851                ATTR_OAUTH2_RS_ORIGIN,
852                name,
853                self.kanidm_namespace(),
854                self.kanidm_name(),
855                e,
856            )
857        })?;
858
859        Ok(())
860    }
861
862    async fn update_scope_map(
863        &self,
864        kanidm_client: &KanidmClient,
865        name: &str,
866        status: &KanidmOAuth2ClientStatus,
867        metrics: &kaniop_operator::metrics::ControllerMetrics,
868    ) -> Result<()> {
869        debug!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute");
870
871        let current_scope_map: BTreeSet<_> = status
872            .scope_map
873            .as_ref()
874            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
875            .unwrap_or_default();
876
877        let scope_map: BTreeSet<KanidmScopeMap> = self
878            .spec
879            .scope_map
880            .clone()
881            .unwrap_or_default()
882            .clone()
883            .into_iter()
884            .collect();
885
886        let metrics_del = metrics.clone();
887        let delete_futures = current_scope_map
888            .difference(&scope_map)
889            .map(|s| {
890                let metrics = metrics_del.clone();
891                async move {
892                    record_kanidm_sdk_call(
893                        &metrics,
894                        KANIDM_RESOURCE_OAUTH2,
895                        KANIDM_OP_DELETE_SCOPE_MAP,
896                        KANIDM_OUTCOME_CHANGED,
897                        kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group),
898                    )
899                    .await
900                }
901            })
902            .collect::<TryJoinAll<_>>();
903
904        let metrics_add = metrics.clone();
905        let add_futures = scope_map
906            .difference(&current_scope_map)
907            .map(|s| {
908                let metrics = metrics_add.clone();
909                let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
910                async move {
911                    record_kanidm_sdk_call(
912                        &metrics,
913                        KANIDM_RESOURCE_OAUTH2,
914                        KANIDM_OP_UPDATE_SCOPE_MAP,
915                        KANIDM_OUTCOME_CHANGED,
916                        kanidm_client.idm_oauth2_rs_update_scope_map(name, &s.group, scopes),
917                    )
918                    .await
919                }
920            })
921            .collect::<TryJoinAll<_>>();
922
923        try_join!(delete_futures, add_futures).map_err(|e| {
924            Error::kanidm_client_error_attr(
925                "modify",
926                ATTR_OAUTH2_RS_SCOPE_MAP,
927                name,
928                self.kanidm_namespace(),
929                self.kanidm_name(),
930                e,
931            )
932        })?;
933        Ok(())
934    }
935
936    async fn update_sup_scope_map(
937        &self,
938        kanidm_client: &KanidmClient,
939        name: &str,
940        status: &KanidmOAuth2ClientStatus,
941        metrics: &kaniop_operator::metrics::ControllerMetrics,
942    ) -> Result<()> {
943        debug!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute");
944
945        let current_sup_scope_map: BTreeSet<_> = status
946            .sup_scope_map
947            .as_ref()
948            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
949            .unwrap_or_default();
950
951        let sup_scope_map: BTreeSet<KanidmScopeMap> = self
952            .spec
953            .sup_scope_map
954            .clone()
955            .unwrap_or_default()
956            .clone()
957            .into_iter()
958            .collect();
959
960        let metrics_del = metrics.clone();
961        let delete_futures = current_sup_scope_map
962            .difference(&sup_scope_map)
963            .map(|s| {
964                let metrics = metrics_del.clone();
965                async move {
966                    record_kanidm_sdk_call(
967                        &metrics,
968                        KANIDM_RESOURCE_OAUTH2,
969                        KANIDM_OP_DELETE_SUP_SCOPE_MAP,
970                        KANIDM_OUTCOME_CHANGED,
971                        kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group),
972                    )
973                    .await
974                }
975            })
976            .collect::<TryJoinAll<_>>();
977
978        let metrics_add = metrics.clone();
979        let add_futures = sup_scope_map
980            .difference(&current_sup_scope_map)
981            .map(|s| {
982                let metrics = metrics_add.clone();
983                let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
984                async move {
985                    record_kanidm_sdk_call(
986                        &metrics,
987                        KANIDM_RESOURCE_OAUTH2,
988                        KANIDM_OP_UPDATE_SUP_SCOPE_MAP,
989                        KANIDM_OUTCOME_CHANGED,
990                        kanidm_client.idm_oauth2_rs_update_sup_scope_map(name, &s.group, scopes),
991                    )
992                    .await
993                }
994            })
995            .collect::<TryJoinAll<_>>();
996
997        try_join!(delete_futures, add_futures).map_err(|e| {
998            Error::kanidm_client_error_attr(
999                "modify",
1000                ATTR_OAUTH2_RS_SUP_SCOPE_MAP,
1001                name,
1002                self.kanidm_namespace(),
1003                self.kanidm_name(),
1004                e,
1005            )
1006        })?;
1007        Ok(())
1008    }
1009
1010    async fn update_claims_map(
1011        &self,
1012        kanidm_client: &KanidmClient,
1013        name: &str,
1014        status: &KanidmOAuth2ClientStatus,
1015        metrics: &kaniop_operator::metrics::ControllerMetrics,
1016    ) -> Result<()> {
1017        debug!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute");
1018
1019        let current_claims_map: BTreeSet<_> = status
1020            .claims_map
1021            .as_ref()
1022            .map(|v| {
1023                KanidmClaimMap::group(
1024                    &v.iter()
1025                        .filter_map(|c| KanidmClaimMap::from(c))
1026                        .collect::<Vec<_>>(),
1027                )
1028            })
1029            .unwrap_or_default();
1030
1031        let claims_map: BTreeSet<KanidmClaimMap> = self
1032            .spec
1033            .claim_map
1034            .clone()
1035            .unwrap_or_default()
1036            .clone()
1037            .into_iter()
1038            .collect();
1039
1040        let metrics_del = metrics.clone();
1041        let delete_futures = current_claims_map
1042            .difference(&claims_map)
1043            .flat_map(|c| {
1044                c.values_map
1045                    .iter()
1046                    .map(|v| {
1047                        let metrics = metrics_del.clone();
1048                        async move {
1049                            record_kanidm_sdk_call(
1050                                &metrics,
1051                                KANIDM_RESOURCE_OAUTH2,
1052                                KANIDM_OP_DELETE_CLAIM_MAP,
1053                                KANIDM_OUTCOME_CHANGED,
1054                                kanidm_client
1055                                    .idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group),
1056                            )
1057                            .await
1058                        }
1059                    })
1060                    .collect::<Vec<_>>()
1061            })
1062            .collect::<TryJoinAll<_>>();
1063
1064        let claims_to_add = claims_map.difference(&current_claims_map);
1065        let metrics_add = metrics.clone();
1066        let add_futures = claims_to_add
1067            .clone()
1068            .flat_map(|c| {
1069                c.values_map
1070                    .iter()
1071                    .map(|v| {
1072                        let metrics = metrics_add.clone();
1073                        let values = v.values.clone();
1074                        async move {
1075                            record_kanidm_sdk_call(
1076                                &metrics,
1077                                KANIDM_RESOURCE_OAUTH2,
1078                                KANIDM_OP_UPDATE_CLAIM_MAP,
1079                                KANIDM_OUTCOME_CHANGED,
1080                                kanidm_client.idm_oauth2_rs_update_claim_map(
1081                                    name, &c.name, &v.group, &values,
1082                                ),
1083                            )
1084                            .await
1085                        }
1086                    })
1087                    .collect::<Vec<_>>()
1088            })
1089            .collect::<TryJoinAll<_>>();
1090
1091        let metrics_join = metrics.clone();
1092        let join_strategy_futures = claims_to_add
1093            .map(|c| {
1094                let metrics = metrics_join.clone();
1095                let join_strategy = c.join_strategy.to_oauth2_claim_map_join();
1096                async move {
1097                    record_kanidm_sdk_call(
1098                        &metrics,
1099                        KANIDM_RESOURCE_OAUTH2,
1100                        KANIDM_OP_UPDATE_CLAIM_MAP_JOIN,
1101                        KANIDM_OUTCOME_CHANGED,
1102                        kanidm_client.idm_oauth2_rs_update_claim_map_join(
1103                            name,
1104                            &c.name,
1105                            join_strategy,
1106                        ),
1107                    )
1108                    .await
1109                }
1110            })
1111            .collect::<TryJoinAll<_>>();
1112
1113        try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
1114            Error::kanidm_client_error_attr(
1115                "modify",
1116                ATTR_OAUTH2_RS_CLAIM_MAP,
1117                name,
1118                self.kanidm_namespace(),
1119                self.kanidm_name(),
1120                e,
1121            )
1122        })?;
1123        Ok(())
1124    }
1125
1126    async fn update_strict_redirect_url(
1127        &self,
1128        kanidm_client: &KanidmClient,
1129        name: &str,
1130        metrics: &kaniop_operator::metrics::ControllerMetrics,
1131    ) -> Result<()> {
1132        debug!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute");
1133        if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
1134            if strict_redirect_url_enabled {
1135                record_kanidm_sdk_call(
1136                    metrics,
1137                    KANIDM_RESOURCE_OAUTH2,
1138                    KANIDM_OP_UPDATE,
1139                    KANIDM_OUTCOME_CHANGED,
1140                    kanidm_client.idm_oauth2_rs_enable_strict_redirect_uri(name),
1141                )
1142                .await
1143                .map_err(|e| {
1144                    Error::kanidm_client_error_attr(
1145                        "update",
1146                        ATTR_OAUTH2_STRICT_REDIRECT_URI,
1147                        name,
1148                        self.kanidm_namespace(),
1149                        self.kanidm_name(),
1150                        e,
1151                    )
1152                })?;
1153            } else {
1154                record_kanidm_sdk_call(
1155                    metrics,
1156                    KANIDM_RESOURCE_OAUTH2,
1157                    KANIDM_OP_UPDATE,
1158                    KANIDM_OUTCOME_CHANGED,
1159                    kanidm_client.idm_oauth2_rs_disable_strict_redirect_uri(name),
1160                )
1161                .await
1162                .map_err(|e| {
1163                    Error::kanidm_client_error_attr(
1164                        "update",
1165                        ATTR_OAUTH2_STRICT_REDIRECT_URI,
1166                        name,
1167                        self.kanidm_namespace(),
1168                        self.kanidm_name(),
1169                        e,
1170                    )
1171                })?;
1172            }
1173        };
1174        Ok(())
1175    }
1176
1177    async fn update_disable_pkce(
1178        &self,
1179        kanidm_client: &KanidmClient,
1180        name: &str,
1181        metrics: &kaniop_operator::metrics::ControllerMetrics,
1182    ) -> Result<()> {
1183        debug!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute");
1184        if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
1185            if disable_pkce {
1186                record_kanidm_sdk_call(
1187                    metrics,
1188                    KANIDM_RESOURCE_OAUTH2,
1189                    KANIDM_OP_UPDATE,
1190                    KANIDM_OUTCOME_CHANGED,
1191                    kanidm_client.idm_oauth2_rs_disable_pkce(name),
1192                )
1193                .await
1194                .map_err(|e| {
1195                    Error::kanidm_client_error_attr(
1196                        "update",
1197                        ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1198                        name,
1199                        self.kanidm_namespace(),
1200                        self.kanidm_name(),
1201                        e,
1202                    )
1203                })?;
1204            } else {
1205                record_kanidm_sdk_call(
1206                    metrics,
1207                    KANIDM_RESOURCE_OAUTH2,
1208                    KANIDM_OP_UPDATE,
1209                    KANIDM_OUTCOME_CHANGED,
1210                    kanidm_client.idm_oauth2_rs_enable_pkce(name),
1211                )
1212                .await
1213                .map_err(|e| {
1214                    Error::kanidm_client_error_attr(
1215                        "update",
1216                        ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1217                        name,
1218                        self.kanidm_namespace(),
1219                        self.kanidm_name(),
1220                        e,
1221                    )
1222                })?;
1223            }
1224        };
1225        Ok(())
1226    }
1227
1228    async fn update_prefer_short_name(
1229        &self,
1230        kanidm_client: &KanidmClient,
1231        name: &str,
1232        metrics: &kaniop_operator::metrics::ControllerMetrics,
1233    ) -> Result<()> {
1234        debug!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute");
1235        if let Some(prefer_short_username) = self.spec.prefer_short_username {
1236            if prefer_short_username {
1237                record_kanidm_sdk_call(
1238                    metrics,
1239                    KANIDM_RESOURCE_OAUTH2,
1240                    KANIDM_OP_UPDATE,
1241                    KANIDM_OUTCOME_CHANGED,
1242                    kanidm_client.idm_oauth2_rs_prefer_short_username(name),
1243                )
1244                .await
1245                .map_err(|e| {
1246                    Error::kanidm_client_error_attr(
1247                        "update",
1248                        ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1249                        name,
1250                        self.kanidm_namespace(),
1251                        self.kanidm_name(),
1252                        e,
1253                    )
1254                })?;
1255            } else {
1256                record_kanidm_sdk_call(
1257                    metrics,
1258                    KANIDM_RESOURCE_OAUTH2,
1259                    KANIDM_OP_UPDATE,
1260                    KANIDM_OUTCOME_CHANGED,
1261                    kanidm_client.idm_oauth2_rs_prefer_spn_username(name),
1262                )
1263                .await
1264                .map_err(|e| {
1265                    Error::kanidm_client_error_attr(
1266                        "update",
1267                        ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1268                        name,
1269                        self.kanidm_namespace(),
1270                        self.kanidm_name(),
1271                        e,
1272                    )
1273                })?;
1274            }
1275        };
1276        Ok(())
1277    }
1278
1279    async fn update_allow_localhost_redirect(
1280        &self,
1281        kanidm_client: &KanidmClient,
1282        name: &str,
1283        metrics: &kaniop_operator::metrics::ControllerMetrics,
1284    ) -> Result<()> {
1285        debug!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute");
1286        if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
1287            if allow_localhost_redirect {
1288                record_kanidm_sdk_call(
1289                    metrics,
1290                    KANIDM_RESOURCE_OAUTH2,
1291                    KANIDM_OP_UPDATE,
1292                    KANIDM_OUTCOME_CHANGED,
1293                    kanidm_client.idm_oauth2_rs_enable_public_localhost_redirect(name),
1294                )
1295                .await
1296                .map_err(|e| {
1297                    Error::kanidm_client_error_attr(
1298                        "update",
1299                        ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1300                        name,
1301                        self.kanidm_namespace(),
1302                        self.kanidm_name(),
1303                        e,
1304                    )
1305                })?;
1306            } else {
1307                record_kanidm_sdk_call(
1308                    metrics,
1309                    KANIDM_RESOURCE_OAUTH2,
1310                    KANIDM_OP_UPDATE,
1311                    KANIDM_OUTCOME_CHANGED,
1312                    kanidm_client.idm_oauth2_rs_disable_public_localhost_redirect(name),
1313                )
1314                .await
1315                .map_err(|e| {
1316                    Error::kanidm_client_error_attr(
1317                        "update",
1318                        ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1319                        name,
1320                        self.kanidm_namespace(),
1321                        self.kanidm_name(),
1322                        e,
1323                    )
1324                })?;
1325            }
1326        };
1327        Ok(())
1328    }
1329
1330    async fn update_legacy_crypto(
1331        &self,
1332        kanidm_client: &KanidmClient,
1333        name: &str,
1334        metrics: &kaniop_operator::metrics::ControllerMetrics,
1335    ) -> Result<()> {
1336        debug!("update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} attribute");
1337        if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
1338            if legacy_crypto {
1339                record_kanidm_sdk_call(
1340                    metrics,
1341                    KANIDM_RESOURCE_OAUTH2,
1342                    KANIDM_OP_UPDATE,
1343                    KANIDM_OUTCOME_CHANGED,
1344                    kanidm_client.idm_oauth2_rs_enable_legacy_crypto(name),
1345                )
1346                .await
1347                .map_err(|e| {
1348                    Error::kanidm_client_error_attr(
1349                        "update",
1350                        ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1351                        name,
1352                        self.kanidm_namespace(),
1353                        self.kanidm_name(),
1354                        e,
1355                    )
1356                })?;
1357            } else {
1358                record_kanidm_sdk_call(
1359                    metrics,
1360                    KANIDM_RESOURCE_OAUTH2,
1361                    KANIDM_OP_UPDATE,
1362                    KANIDM_OUTCOME_CHANGED,
1363                    kanidm_client.idm_oauth2_rs_disable_legacy_crypto(name),
1364                )
1365                .await
1366                .map_err(|e| {
1367                    Error::kanidm_client_error_attr(
1368                        "update",
1369                        ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1370                        name,
1371                        self.kanidm_namespace(),
1372                        self.kanidm_name(),
1373                        e,
1374                    )
1375                })?;
1376            }
1377        };
1378        Ok(())
1379    }
1380
1381    async fn update_consent_prompt(
1382        &self,
1383        kanidm_client: &KanidmClient,
1384        name: &str,
1385        metrics: &kaniop_operator::metrics::ControllerMetrics,
1386    ) -> Result<()> {
1387        debug!("update {ATTR_OAUTH2_CONSENT_PROMPT_ENABLE} attribute");
1388        if let Some(disable_consent_prompt) = self.spec.disable_consent_prompt {
1389            if disable_consent_prompt {
1390                record_kanidm_sdk_call(
1391                    metrics,
1392                    KANIDM_RESOURCE_OAUTH2,
1393                    KANIDM_OP_UPDATE,
1394                    KANIDM_OUTCOME_CHANGED,
1395                    kanidm_client.idm_oauth2_rs_disable_consent_prompt(name),
1396                )
1397                .await
1398                .map_err(|e| {
1399                    Error::kanidm_client_error_attr(
1400                        "update",
1401                        ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1402                        name,
1403                        self.kanidm_namespace(),
1404                        self.kanidm_name(),
1405                        e,
1406                    )
1407                })?;
1408            } else {
1409                record_kanidm_sdk_call(
1410                    metrics,
1411                    KANIDM_RESOURCE_OAUTH2,
1412                    KANIDM_OP_UPDATE,
1413                    KANIDM_OUTCOME_CHANGED,
1414                    kanidm_client.idm_oauth2_rs_enable_consent_prompt(name),
1415                )
1416                .await
1417                .map_err(|e| {
1418                    Error::kanidm_client_error_attr(
1419                        "update",
1420                        ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1421                        name,
1422                        self.kanidm_namespace(),
1423                        self.kanidm_name(),
1424                        e,
1425                    )
1426                })?;
1427            }
1428        };
1429        Ok(())
1430    }
1431
1432    async fn update_refresh_token_expiry(
1433        &self,
1434        kanidm_client: &KanidmClient,
1435        name: &str,
1436        metrics: &kaniop_operator::metrics::ControllerMetrics,
1437    ) -> Result<()> {
1438        if let Some(expiry) = self.spec.refresh_token_expiry {
1439            debug!("update {ATTR_OAUTH2_REFRESH_TOKEN_EXPIRY} attribute");
1440            record_kanidm_sdk_call(
1441                metrics,
1442                KANIDM_RESOURCE_OAUTH2,
1443                KANIDM_OP_UPDATE,
1444                KANIDM_OUTCOME_CHANGED,
1445                kanidm_client.idm_oauth2_rs_set_refresh_token_expiry(name, Some(expiry)),
1446            )
1447            .await
1448            .map_err(|e| {
1449                Error::kanidm_client_error_attr(
1450                    "update",
1451                    ATTR_OAUTH2_REFRESH_TOKEN_EXPIRY,
1452                    name,
1453                    self.kanidm_namespace(),
1454                    self.kanidm_name(),
1455                    e,
1456                )
1457            })?;
1458        }
1459        Ok(())
1460    }
1461
1462    async fn update_image(
1463        &self,
1464        kanidm_client: &KanidmClient,
1465        name: &str,
1466        status: &KanidmOAuth2ClientStatus,
1467        ctx: Arc<Context>,
1468        metrics: &kaniop_operator::metrics::ControllerMetrics,
1469    ) -> Result<bool> {
1470        match &self.spec.image {
1471            None => {
1472                debug!("deleting image from OAuth2 client");
1473                record_kanidm_sdk_call(
1474                    metrics,
1475                    KANIDM_RESOURCE_OAUTH2,
1476                    KANIDM_OP_DELETE_IMAGE,
1477                    KANIDM_OUTCOME_CHANGED,
1478                    kanidm_client.idm_oauth2_rs_delete_image(name),
1479                )
1480                .await
1481                .map_err(|e| {
1482                    Error::kanidm_client_error_attr(
1483                        "delete",
1484                        "image",
1485                        name,
1486                        self.kanidm_namespace(),
1487                        self.kanidm_name(),
1488                        e,
1489                    )
1490                })?;
1491                Ok(true)
1492            }
1493            Some(image_spec) => {
1494                let url = &image_spec.url;
1495                debug!("updating image for OAuth2 client from {url}");
1496
1497                let namespace = self.kanidm_namespace();
1498                let kanidm = self.kanidm_name();
1499                let namespace_for_closure = namespace.clone();
1500                let kanidm_for_closure = kanidm.clone();
1501                let metrics_clone = metrics.clone();
1502
1503                let update_result =
1504                    update_image_if_needed(url, status.image.as_ref(), |image_value| {
1505                        let metrics = metrics_clone.clone();
1506                        let namespace = namespace_for_closure.clone();
1507                        let kanidm = kanidm_for_closure.clone();
1508                        async move {
1509                            record_kanidm_sdk_call(
1510                                &metrics,
1511                                KANIDM_RESOURCE_OAUTH2,
1512                                KANIDM_OP_UPDATE_IMAGE,
1513                                KANIDM_OUTCOME_CHANGED,
1514                                kanidm_client.idm_oauth2_rs_update_image(name, image_value),
1515                            )
1516                            .await
1517                            .map_err(|e| {
1518                                Error::kanidm_client_error_attr(
1519                                    "update", "image", name, namespace, kanidm, e,
1520                                )
1521                            })
1522                        }
1523                    })
1524                    .await;
1525
1526                match update_result {
1527                    Ok(Some(updated)) => {
1528                        let new_image_status = OAuth2ClientImageStatus {
1529                            url: updated.image_status.url,
1530                            etag: updated.image_status.etag,
1531                            last_modified: updated.image_status.last_modified,
1532                            content_length: updated.image_status.content_length,
1533                            content_hash: Some(updated.image_status.content_hash),
1534                        };
1535
1536                        let namespace = self.namespace().unwrap();
1537                        let name = self.name_any();
1538                        let oauth2_api = Api::<KanidmOAuth2Client>::namespaced(
1539                            ctx.kaniop_ctx.client.clone(),
1540                            &namespace,
1541                        );
1542                        let status_patch = Patch::Apply(KanidmOAuth2Client {
1543                            status: Some(KanidmOAuth2ClientStatus {
1544                                image: Some(new_image_status),
1545                                ..status.clone()
1546                            }),
1547                            ..KanidmOAuth2Client::default()
1548                        });
1549                        // Forced for the same reason as `update_status`, which shares this manager
1550                        // string: the applied document is the whole status object, so a foreign
1551                        // manager owning any status field conflicts. `update_status` early-returns
1552                        // when unchanged, so no forced apply follows; image status never converges.
1553                        oauth2_api
1554                            .patch_status(
1555                                &name,
1556                                &PatchParams::apply(OAUTH2_OPERATOR_NAME).force(),
1557                                &status_patch,
1558                            )
1559                            .await
1560                            .map_err(|e| {
1561                                Error::kube_status_error("KanidmOAuth2Client", &namespace, &name, e)
1562                            })?;
1563                        Ok(true)
1564                    }
1565                    Ok(None) => Ok(false),
1566                    Err(e) => {
1567                        let operation = if matches!(e, Error::HttpError(_, _)) {
1568                            ImageOperation::Fetch
1569                        } else {
1570                            ImageOperation::Download
1571                        };
1572                        Err(publish_image_error_event(
1573                            e,
1574                            operation,
1575                            name,
1576                            &namespace,
1577                            &kanidm,
1578                            &ctx.kaniop_ctx.recorder,
1579                            self,
1580                        )
1581                        .await)
1582                    }
1583                }
1584            }
1585        }
1586    }
1587
1588    async fn cleanup(
1589        &self,
1590        kanidm_client: Arc<KanidmClient>,
1591        status: KanidmOAuth2ClientStatus,
1592        ctx: Arc<Context>,
1593    ) -> Result<(Action, bool)> {
1594        let name = &self.kanidm_entity_name();
1595        let mut changed = false;
1596        if is_oauth2(TYPE_EXISTS, status.clone()) {
1597            debug!("delete");
1598            record_kanidm_sdk_call(
1599                &ctx.kaniop_ctx.metrics,
1600                KANIDM_RESOURCE_OAUTH2,
1601                KANIDM_OP_DELETE,
1602                KANIDM_OUTCOME_CHANGED,
1603                kanidm_client.idm_oauth2_rs_delete(name),
1604            )
1605            .await
1606            .map_err(|e| {
1607                Error::kanidm_client_error(
1608                    "delete",
1609                    name,
1610                    self.kanidm_namespace(),
1611                    self.kanidm_name(),
1612                    e,
1613                )
1614            })?;
1615            changed = true;
1616        }
1617        Ok((Action::requeue(idm_reconcile_interval()), changed))
1618    }
1619}
1620
1621pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1622    status
1623        .conditions
1624        .unwrap_or_default()
1625        .iter()
1626        .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
1627}
1628
1629pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1630    status
1631        .conditions
1632        .unwrap_or_default()
1633        .iter()
1634        .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
1635}