Skip to main content

kaniop_oauth2/reconcile/
mod.rs

1mod secret;
2mod status;
3
4use self::secret::SecretExt;
5use self::status::{
6    CONDITION_FALSE, CONDITION_TRUE, StatusExt, TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED,
7    TYPE_CLAIMS_MAP_UPDATED, TYPE_DISABLE_PKCE_UPDATED, TYPE_EXISTS, TYPE_LEGACY_CRYPTO_UPDATED,
8    TYPE_PREFER_SHORT_NAME_UPDATED, TYPE_REDIRECT_URL_UPDATED, TYPE_SCOPE_MAP_UPDATED,
9    TYPE_SECRET_INITIALIZED, TYPE_SECRET_ROTATED, TYPE_STRICT_REDIRECT_URL_UPDATED,
10    TYPE_SUP_SCOPE_MAP_UPDATED, TYPE_UPDATED,
11};
12
13use crate::{
14    controller::Context,
15    crd::{KanidmClaimMap, KanidmOAuth2Client, KanidmOAuth2ClientStatus, KanidmScopeMap},
16};
17
18use kanidm_proto::internal::OperationError;
19use kaniop_k8s_util::error::{Error, Result};
20use kaniop_operator::controller::DEFAULT_RECONCILE_INTERVAL;
21use kaniop_operator::controller::context::{IdmClientContext, KubeOperations};
22use kaniop_operator::controller::kanidm::{KanidmResource, is_resource_watched};
23use kaniop_operator::telemetry;
24
25use std::collections::BTreeSet;
26use std::sync::Arc;
27use std::time::Duration;
28
29use futures::future::TryJoinAll;
30use futures::try_join;
31
32use k8s_openapi::NamespaceResourceScope;
33use kanidm_client::{ClientError, KanidmClient, StatusCode};
34use kanidm_proto::constants::{
35    ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE, ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
36    ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE, ATTR_OAUTH2_PREFER_SHORT_USERNAME,
37    ATTR_OAUTH2_RS_CLAIM_MAP, ATTR_OAUTH2_RS_ORIGIN, ATTR_OAUTH2_RS_SCOPE_MAP,
38    ATTR_OAUTH2_RS_SUP_SCOPE_MAP, ATTR_OAUTH2_STRICT_REDIRECT_URI,
39};
40use kube::api::Api;
41use kube::runtime::controller::Action;
42use kube::runtime::events::{Event, EventType};
43use kube::runtime::finalizer::{Event as Finalizer, finalizer};
44use kube::{Resource, ResourceExt};
45use serde::{Deserialize, Serialize};
46
47use tracing::{Span, debug, field, info, instrument, trace, warn};
48
49static OAUTH2_OPERATOR_NAME: &str = "kanidmoauth2clients.kaniop.rs";
50static OAUTH2_FINALIZER: &str = "kanidmoauth2clients.kaniop.rs/finalizer";
51
52pub fn watched_resource(oauth2: &KanidmOAuth2Client, ctx: Arc<Context>) -> bool {
53    let kanidm = if let Some(k) = ctx.kaniop_ctx.get_kanidm(oauth2) {
54        k
55    } else {
56        trace!(msg = "no kanidm found");
57        return false;
58    };
59
60    is_resource_watched(oauth2, &kanidm, &ctx.kaniop_ctx.namespace_store)
61}
62
63#[instrument(skip(ctx, oauth2))]
64pub async fn reconcile_oauth2(
65    oauth2: Arc<KanidmOAuth2Client>,
66    ctx: Arc<Context>,
67) -> Result<Action> {
68    let trace_id = telemetry::get_trace_id();
69    Span::current().record("trace_id", field::display(&trace_id));
70    let _timer = ctx
71        .kaniop_ctx
72        .metrics
73        .reconcile_count_and_measure(&trace_id);
74    let kanidm_client = ctx.get_idm_client(&oauth2).await?;
75
76    if !watched_resource(&oauth2, ctx.clone()) {
77        debug!(msg = "resource not watched, skipping reconcile");
78        ctx.kaniop_ctx.recorder
79        .publish(
80            &Event {
81                type_: EventType::Warning,
82                reason: "ResourceNotWatched".to_string(),
83                note: Some("configure `oauth2ClientNamespaceSelector` on Kanidm resource to watch this namespace".to_string()),
84                action: "Reconcile".to_string(),
85                secondary: None,
86            },
87            &oauth2.object_ref(&()),
88        )
89        .await
90        .map_err(|e| {
91            warn!(msg = "failed to publish KanidmError event", %e);
92            Error::KubeError("failed to publish event".to_string(), Box::new(e))
93        })?;
94        return Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL));
95    }
96
97    info!(msg = "reconciling oauth2 client");
98    let namespace = oauth2.get_namespace();
99    let status = oauth2
100        .update_status(kanidm_client.clone(), ctx.clone())
101        .await
102        .map_err(|e| {
103            debug!(msg = "failed to reconcile status", %e);
104            ctx.kaniop_ctx.metrics.status_update_errors_inc();
105            e
106        })?;
107    let persons_api: Api<KanidmOAuth2Client> =
108        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
109    finalizer(&persons_api, OAUTH2_FINALIZER, oauth2, |event| async {
110        match event {
111            Finalizer::Apply(p) => p.reconcile(kanidm_client, status, ctx).await,
112            Finalizer::Cleanup(p) => p.cleanup(kanidm_client, status).await,
113        }
114    })
115    .await
116    .map_err(|e| {
117        Error::FinalizerError("failed on oauth2 client finalizer".to_string(), Box::new(e))
118    })
119}
120
121impl KanidmOAuth2Client {
122    // Method kube_patch are provided by KubeOperations trait
123    pub async fn patch<K>(&self, ctx: &Context, resource: K) -> Result<K>
124    where
125        K: Resource<Scope = NamespaceResourceScope>
126            + Serialize
127            + Clone
128            + std::fmt::Debug
129            + for<'de> Deserialize<'de>,
130        <K as kube::Resource>::DynamicType: Default,
131        <K as Resource>::Scope: std::marker::Sized,
132    {
133        self.kube_patch(
134            ctx.kaniop_ctx.client.clone(),
135            &ctx.kaniop_ctx.metrics,
136            resource,
137            OAUTH2_OPERATOR_NAME,
138        )
139        .await
140    }
141
142    #[inline]
143    fn get_namespace(&self) -> String {
144        // safe unwrap: oauth2 is namespaced scoped
145        self.namespace().unwrap()
146    }
147
148    #[inline]
149    async fn reconcile(
150        &self,
151        kanidm_client: Arc<KanidmClient>,
152        status: KanidmOAuth2ClientStatus,
153        ctx: Arc<Context>,
154    ) -> Result<Action> {
155        match self
156            .internal_reconcile(kanidm_client, status, ctx.clone())
157            .await
158        {
159            Ok(action) => Ok(action),
160            Err(e) => match &e {
161                Error::KanidmClientError(msg, client_err) => {
162                    let event_note = match client_err.as_ref() {
163                        ClientError::Http(
164                            StatusCode::NOT_FOUND,
165                            Some(OperationError::NoMatchingEntries),
166                            kopid,
167                        ) => {
168                            format!("group not found: {msg}. KOpId: {kopid}")
169                        }
170                        _ => {
171                            format!("{msg}: KanidmClientError: {client_err:?}")
172                        }
173                    };
174                    ctx.kaniop_ctx
175                        .recorder
176                        .publish(
177                            &Event {
178                                type_: EventType::Warning,
179                                reason: "KanidmError".to_string(),
180                                note: Some(event_note),
181                                action: "KanidmRequest".to_string(),
182                                secondary: None,
183                            },
184                            &self.object_ref(&()),
185                        )
186                        .await
187                        .map_err(|e| {
188                            warn!(msg = "failed to publish KanidmError event", %e);
189                            Error::KubeError("failed to publish event".to_string(), Box::new(e))
190                        })?;
191                    Err(e)
192                }
193                _ => Err(e),
194            },
195        }
196    }
197
198    #[inline]
199    async fn internal_reconcile(
200        &self,
201        kanidm_client: Arc<KanidmClient>,
202        status: KanidmOAuth2ClientStatus,
203        ctx: Arc<Context>,
204    ) -> Result<Action> {
205        let name = &self.name_any();
206        let mut require_status_update = false;
207
208        if is_oauth2_false(TYPE_EXISTS, status.clone()) {
209            self.create(&kanidm_client, name).await?;
210            require_status_update = true;
211        }
212
213        if is_oauth2_false(TYPE_SECRET_INITIALIZED, status.clone()) {
214            let secret = self
215                .generate_secret(&kanidm_client, self.spec.secret_rotation.as_ref())
216                .await?;
217            self.patch(&ctx, secret).await?;
218            require_status_update = true;
219        }
220
221        // Handle secret rotation for confidential clients
222        if is_oauth2_false(TYPE_SECRET_ROTATED, status.clone()) {
223            self.rotate_secret(&kanidm_client, name, ctx.clone())
224                .await?;
225            require_status_update = true;
226        }
227
228        if is_oauth2_false(TYPE_UPDATED, status.clone()) {
229            self.update(&kanidm_client, name).await?;
230            require_status_update = true;
231        }
232
233        if is_oauth2_false(TYPE_REDIRECT_URL_UPDATED, status.clone()) {
234            self.update_redirect_url(&kanidm_client, name, &status)
235                .await?;
236            require_status_update = true;
237        }
238
239        if is_oauth2_false(TYPE_SCOPE_MAP_UPDATED, status.clone()) {
240            self.update_scope_map(&kanidm_client, name, &status).await?;
241            require_status_update = true;
242        }
243
244        if is_oauth2_false(TYPE_SUP_SCOPE_MAP_UPDATED, status.clone()) {
245            self.update_sup_scope_map(&kanidm_client, name, &status)
246                .await?;
247            require_status_update = true;
248        }
249
250        if is_oauth2_false(TYPE_CLAIMS_MAP_UPDATED, status.clone()) {
251            self.update_claims_map(&kanidm_client, name, &status)
252                .await?;
253            require_status_update = true;
254        }
255
256        if is_oauth2_false(TYPE_STRICT_REDIRECT_URL_UPDATED, status.clone()) {
257            self.update_strict_redirect_url(&kanidm_client, name)
258                .await?;
259            require_status_update = true;
260        }
261
262        if is_oauth2_false(TYPE_DISABLE_PKCE_UPDATED, status.clone()) {
263            self.update_disable_pkce(&kanidm_client, name).await?;
264            require_status_update = true;
265        }
266
267        if is_oauth2_false(TYPE_PREFER_SHORT_NAME_UPDATED, status.clone()) {
268            self.update_prefer_short_name(&kanidm_client, name).await?;
269            require_status_update = true;
270        }
271
272        if is_oauth2_false(TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED, status.clone()) {
273            self.update_allow_localhost_redirect(&kanidm_client, name)
274                .await?;
275            require_status_update = true;
276        }
277
278        if is_oauth2_false(TYPE_LEGACY_CRYPTO_UPDATED, status.clone()) {
279            self.update_legacy_crypto(&kanidm_client, name).await?;
280            require_status_update = true;
281        }
282
283        if require_status_update {
284            trace!(msg = "status update required, requeueing in 500ms");
285            Ok(Action::requeue(Duration::from_millis(500)))
286        } else {
287            Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
288        }
289    }
290
291    async fn create(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
292        debug!(msg = "create");
293        if self.spec.public {
294            debug!(msg = "create public client");
295            kanidm_client
296                .idm_oauth2_rs_public_create(name, &self.spec.displayname, &self.spec.origin)
297                .await
298                .map_err(|e| {
299                    Error::KanidmClientError(
300                        format!(
301                            "failed to create {name} from {namespace}/{kanidm}",
302                            namespace = self.kanidm_namespace(),
303                            kanidm = self.kanidm_name(),
304                        ),
305                        Box::new(e),
306                    )
307                })?;
308        } else {
309            kanidm_client
310                .idm_oauth2_rs_basic_create(name, &self.spec.displayname, &self.spec.origin)
311                .await
312                .map_err(|e| {
313                    Error::KanidmClientError(
314                        format!(
315                            "failed to create {name} from {namespace}/{kanidm}",
316                            namespace = self.kanidm_namespace(),
317                            kanidm = self.kanidm_name(),
318                        ),
319                        Box::new(e),
320                    )
321                })?;
322        }
323        Ok(())
324    }
325
326    async fn update(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
327        debug!(msg = "update");
328        kanidm_client
329            .idm_oauth2_rs_update(
330                name,
331                None,
332                Some(&self.spec.displayname),
333                Some(&self.spec.origin),
334                false,
335            )
336            .await
337            .map_err(|e| {
338                Error::KanidmClientError(
339                    format!(
340                        "failed to create {name} from {namespace}/{kanidm}",
341                        namespace = self.kanidm_namespace(),
342                        kanidm = self.kanidm_name(),
343                    ),
344                    Box::new(e),
345                )
346            })?;
347        Ok(())
348    }
349
350    async fn rotate_secret(
351        &self,
352        kanidm_client: &KanidmClient,
353        name: &str,
354        ctx: Arc<Context>,
355    ) -> Result<()> {
356        info!(msg = "rotating OAuth2 client secret");
357        // Reset the secret in Kanidm using idm_oauth2_rs_update with reset_secret=true
358        kanidm_client
359            .idm_oauth2_rs_update(name, None, None, None, true)
360            .await
361            .map_err(|e| {
362                Error::KanidmClientError(
363                    format!(
364                        "failed to rotate secret for {name} from {namespace}/{kanidm}",
365                        namespace = self.kanidm_namespace(),
366                        kanidm = self.kanidm_name(),
367                    ),
368                    Box::new(e),
369                )
370            })?;
371
372        // Regenerate and patch the Kubernetes secret with the new client secret
373        let secret = self
374            .generate_secret(kanidm_client, self.spec.secret_rotation.as_ref())
375            .await?;
376        self.patch(&ctx, secret).await?;
377        Ok(())
378    }
379
380    async fn update_redirect_url(
381        &self,
382        kanidm_client: &KanidmClient,
383        name: &str,
384        status: &KanidmOAuth2ClientStatus,
385    ) -> Result<()> {
386        debug!(msg = format!("update {ATTR_OAUTH2_RS_ORIGIN} attribute"));
387
388        let current_urls: BTreeSet<_> = status
389            .origin
390            .as_ref()
391            .map(|o| o.iter().map(|u| url::Url::parse(u).unwrap()).collect())
392            .unwrap_or_default();
393
394        let redirect_url = self
395            .spec
396            .redirect_url
397            .iter()
398            .map(|u| {
399                url::Url::parse(u).map_err(|e| {
400                    Error::UrlParseError(
401                        format!(
402                            "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
403                            namespace = self.kanidm_namespace(),
404                            kanidm = self.kanidm_name(),
405                        ),
406                        e,
407                    )
408                })
409            })
410            .collect::<Result<BTreeSet<_>>>()?;
411
412        let delete_futures = current_urls
413            .difference(&redirect_url)
414            .map(|url| kanidm_client.idm_oauth2_client_remove_origin(name, url))
415            .collect::<TryJoinAll<_>>();
416
417        let add_futures = redirect_url
418            .difference(&current_urls)
419            .map(|url| kanidm_client.idm_oauth2_client_add_origin(name, url))
420            .collect::<TryJoinAll<_>>();
421
422        futures::try_join!(delete_futures, add_futures).map_err(|e| {
423            Error::KanidmClientError(
424                format!(
425                    "failed to modify {ATTR_OAUTH2_RS_ORIGIN} for {name} from {namespace}/{kanidm}",
426                    namespace = self.kanidm_namespace(),
427                    kanidm = self.kanidm_name(),
428                ),
429                Box::new(e),
430            )
431        })?;
432
433        Ok(())
434    }
435
436    async fn update_scope_map(
437        &self,
438        kanidm_client: &KanidmClient,
439        name: &str,
440        status: &KanidmOAuth2ClientStatus,
441    ) -> Result<()> {
442        debug!(msg = format!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute"));
443
444        let current_scope_map: BTreeSet<_> = status
445            .scope_map
446            .as_ref()
447            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
448            .unwrap_or_default();
449
450        let scope_map: BTreeSet<KanidmScopeMap> = self
451            .spec
452            .scope_map
453            .clone()
454            .unwrap_or_default()
455            .clone()
456            .into_iter()
457            .collect();
458
459        let delete_futures = current_scope_map
460            .difference(&scope_map)
461            .map(|s| kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group))
462            .collect::<TryJoinAll<_>>();
463
464        let add_futures = scope_map
465            .difference(&current_scope_map)
466            .map(|s| {
467                kanidm_client.idm_oauth2_rs_update_scope_map(
468                    name,
469                    &s.group,
470                    s.scopes.iter().map(|s| s.as_str()).collect(),
471                )
472            })
473            .collect::<TryJoinAll<_>>();
474
475        try_join!(delete_futures, add_futures).map_err(|e| {
476            Error::KanidmClientError(
477                format!(
478                    "failed to modify {ATTR_OAUTH2_RS_SCOPE_MAP} for {name} from {namespace}/{kanidm}",
479                    namespace = self.kanidm_namespace(),
480                    kanidm = self.kanidm_name(),
481                ),
482                Box::new(e),
483            )
484        })?;
485        Ok(())
486    }
487
488    async fn update_sup_scope_map(
489        &self,
490        kanidm_client: &KanidmClient,
491        name: &str,
492        status: &KanidmOAuth2ClientStatus,
493    ) -> Result<()> {
494        debug!(msg = format!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute"));
495
496        let current_sup_scope_map: BTreeSet<_> = status
497            .sup_scope_map
498            .as_ref()
499            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
500            .unwrap_or_default();
501
502        let sup_scope_map: BTreeSet<KanidmScopeMap> = self
503            .spec
504            .sup_scope_map
505            .clone()
506            .unwrap_or_default()
507            .clone()
508            .into_iter()
509            .collect();
510
511        let delete_futures = current_sup_scope_map
512            .difference(&sup_scope_map)
513            .map(|s| kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group))
514            .collect::<TryJoinAll<_>>();
515
516        let add_futures = sup_scope_map
517            .difference(&current_sup_scope_map)
518            .map(|s| {
519                kanidm_client.idm_oauth2_rs_update_sup_scope_map(
520                    name,
521                    &s.group,
522                    s.scopes.iter().map(|s| s.as_str()).collect(),
523                )
524            })
525            .collect::<TryJoinAll<_>>();
526
527        try_join!(delete_futures, add_futures).map_err(|e| {
528            Error::KanidmClientError(
529                format!(
530                    "failed to modify {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} for {name} from {namespace}/{kanidm}",
531                    namespace = self.kanidm_namespace(),
532                    kanidm = self.kanidm_name(),
533                ),
534                Box::new(e),
535            )
536        })?;
537        Ok(())
538    }
539
540    async fn update_claims_map(
541        &self,
542        kanidm_client: &KanidmClient,
543        name: &str,
544        status: &KanidmOAuth2ClientStatus,
545    ) -> Result<()> {
546        debug!(msg = format!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute"));
547
548        let current_claims_map: BTreeSet<_> = status
549            .claims_map
550            .as_ref()
551            .map(|v| {
552                KanidmClaimMap::group(
553                    &v.iter()
554                        .filter_map(|c| KanidmClaimMap::from(c))
555                        .collect::<Vec<_>>(),
556                )
557            })
558            .unwrap_or_default();
559
560        let claims_map: BTreeSet<KanidmClaimMap> = self
561            .spec
562            .claim_map
563            .clone()
564            .unwrap_or_default()
565            .clone()
566            .into_iter()
567            .collect();
568
569        let delete_futures = current_claims_map
570            .difference(&claims_map)
571            .flat_map(|c| {
572                c.values_map
573                    .iter()
574                    .map(|v| kanidm_client.idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group))
575            })
576            .collect::<TryJoinAll<_>>();
577
578        let claims_to_add = claims_map.difference(&current_claims_map);
579        let add_futures = claims_to_add
580            .clone()
581            .flat_map(|c| {
582                c.values_map.iter().map(|v| {
583                    kanidm_client.idm_oauth2_rs_update_claim_map(name, &c.name, &v.group, &v.values)
584                })
585            })
586            .collect::<TryJoinAll<_>>();
587
588        let join_strategy_futures = claims_to_add
589            .map(|c| {
590                kanidm_client.idm_oauth2_rs_update_claim_map_join(
591                    name,
592                    &c.name,
593                    c.join_strategy.to_oauth2_claim_map_join(),
594                )
595            })
596            .collect::<TryJoinAll<_>>();
597
598        try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
599            Error::KanidmClientError(
600                format!(
601                    "failed to modify {ATTR_OAUTH2_RS_CLAIM_MAP} for {name} from {namespace}/{kanidm}",
602                    namespace = self.kanidm_namespace(),
603                    kanidm = self.kanidm_name(),
604                ),
605                Box::new(e),
606            )
607        })?;
608        Ok(())
609    }
610
611    async fn update_strict_redirect_url(
612        &self,
613        kanidm_client: &KanidmClient,
614        name: &str,
615    ) -> Result<()> {
616        debug!(msg = format!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute"));
617        if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
618            if strict_redirect_url_enabled {
619                kanidm_client
620                    .idm_oauth2_rs_enable_strict_redirect_uri(
621                        name,
622                    )
623                    .await
624                    .map_err(|e| {
625                        Error::KanidmClientError(
626                            format!(
627                                "failed to update {ATTR_OAUTH2_STRICT_REDIRECT_URI} for {name} from {namespace}/{kanidm}",
628                                namespace = self.kanidm_namespace(),
629                                kanidm = self.kanidm_name(),
630                            ),
631                            Box::new(e),
632                        )
633                    })?;
634            } else {
635                kanidm_client
636                .idm_oauth2_rs_disable_strict_redirect_uri(
637                    name,
638                )
639                .await
640                .map_err(|e| {
641                    Error::KanidmClientError(
642                        format!(
643                            "failed to update {ATTR_OAUTH2_STRICT_REDIRECT_URI} for {name} from {namespace}/{kanidm}",
644                            namespace = self.kanidm_namespace(),
645                            kanidm = self.kanidm_name(),
646                        ),
647                        Box::new(e),
648                    )
649                })?;
650            }
651        };
652        Ok(())
653    }
654
655    async fn update_disable_pkce(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
656        debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute"));
657        if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
658            if disable_pkce {
659                kanidm_client
660                    .idm_oauth2_rs_disable_pkce(
661                        name,
662                    )
663                    .await
664                    .map_err(|e| {
665                        Error::KanidmClientError(
666                            format!(
667                                "failed to update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} for {name} from {namespace}/{kanidm}",
668                                namespace = self.kanidm_namespace(),
669                                kanidm = self.kanidm_name(),
670                            ),
671                            Box::new(e),
672                        )
673                    })?;
674            } else {
675                kanidm_client
676                .idm_oauth2_rs_enable_pkce(
677                    name,
678                )
679                .await
680                .map_err(|e| {
681                    Error::KanidmClientError(
682                        format!(
683                            "failed to update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} for {name} from {namespace}/{kanidm}",
684                            namespace = self.kanidm_namespace(),
685                            kanidm = self.kanidm_name(),
686                        ),
687                        Box::new(e),
688                    )
689                })?;
690            }
691        };
692        Ok(())
693    }
694
695    async fn update_prefer_short_name(
696        &self,
697        kanidm_client: &KanidmClient,
698        name: &str,
699    ) -> Result<()> {
700        debug!(msg = format!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute"));
701        if let Some(prefer_short_username) = self.spec.prefer_short_username {
702            if prefer_short_username {
703                kanidm_client
704                    .idm_oauth2_rs_prefer_short_username(
705                        name,
706                    )
707                    .await
708                    .map_err(|e| {
709                        Error::KanidmClientError(
710                            format!(
711                                "failed to update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} for {name} from {namespace}/{kanidm}",
712                                namespace = self.kanidm_namespace(),
713                                kanidm = self.kanidm_name(),
714                            ),
715                            Box::new(e),
716                        )
717                    })?;
718            } else {
719                kanidm_client
720                .idm_oauth2_rs_prefer_spn_username(
721                    name,
722                )
723                .await
724                .map_err(|e| {
725                    Error::KanidmClientError(
726                        format!(
727                            "failed to update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} for {name} from {namespace}/{kanidm}",
728                            namespace = self.kanidm_namespace(),
729                            kanidm = self.kanidm_name(),
730                        ),
731                        Box::new(e),
732                    )
733                })?;
734            }
735        };
736        Ok(())
737    }
738
739    async fn update_allow_localhost_redirect(
740        &self,
741        kanidm_client: &KanidmClient,
742        name: &str,
743    ) -> Result<()> {
744        debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute"));
745        if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
746            if allow_localhost_redirect {
747                kanidm_client
748                    .idm_oauth2_rs_enable_public_localhost_redirect(
749                        name,
750                    )
751                    .await
752                    .map_err(|e| {
753                        Error::KanidmClientError(
754                            format!(
755                                "failed to update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} for {name} from {namespace}/{kanidm}",
756                                namespace = self.kanidm_namespace(),
757                                kanidm = self.kanidm_name(),
758                            ),
759                            Box::new(e),
760                        )
761                    })?;
762            } else {
763                kanidm_client
764                .idm_oauth2_rs_disable_public_localhost_redirect(
765                    name,
766                )
767                .await
768                .map_err(|e| {
769                    Error::KanidmClientError(
770                        format!(
771                            "failed to update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} for {name} from {namespace}/{kanidm}",
772                            namespace = self.kanidm_namespace(),
773                            kanidm = self.kanidm_name(),
774                        ),
775                        Box::new(e),
776                    )
777                })?;
778            }
779        };
780        Ok(())
781    }
782
783    async fn update_legacy_crypto(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
784        debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute"));
785        if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
786            if legacy_crypto {
787                kanidm_client
788                    .idm_oauth2_rs_enable_legacy_crypto(
789                        name,
790                    )
791                    .await
792                    .map_err(|e| {
793                        Error::KanidmClientError(
794                            format!(
795                                "failed to update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} for {name} from {namespace}/{kanidm}",
796                                namespace = self.kanidm_namespace(),
797                                kanidm = self.kanidm_name(),
798                            ),
799                            Box::new(e),
800                        )
801                    })?;
802            } else {
803                kanidm_client
804                .idm_oauth2_rs_disable_legacy_crypto(
805                    name,
806                )
807                .await
808                .map_err(|e| {
809                    Error::KanidmClientError(
810                        format!(
811                            "failed to update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} for {name} from {namespace}/{kanidm}",
812                            namespace = self.kanidm_namespace(),
813                            kanidm = self.kanidm_name(),
814                        ),
815                        Box::new(e),
816                    )
817                })?;
818            }
819        };
820        Ok(())
821    }
822
823    async fn cleanup(
824        &self,
825        kanidm_client: Arc<KanidmClient>,
826        status: KanidmOAuth2ClientStatus,
827    ) -> Result<Action> {
828        let name = &self.name_any();
829        if is_oauth2(TYPE_EXISTS, status.clone()) {
830            debug!(msg = "delete");
831            kanidm_client
832                .idm_oauth2_rs_delete(name)
833                .await
834                .map_err(|e| {
835                    Error::KanidmClientError(
836                        format!(
837                            "failed to delete {name} from {namespace}/{kanidm}",
838                            namespace = self.kanidm_namespace(),
839                            kanidm = self.kanidm_name(),
840                        ),
841                        Box::new(e),
842                    )
843                })?;
844        }
845        Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
846    }
847}
848
849pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
850    status
851        .conditions
852        .unwrap_or_default()
853        .iter()
854        .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
855}
856
857pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
858    status
859        .conditions
860        .unwrap_or_default()
861        .iter()
862        .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
863}